# encoding: utf-8 # module vtkmodules.vtkRenderingParallel # from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\vtkmodules\vtkRenderingParallel.cp311-win_amd64.pyd # by generator 1.147 # no doc # imports import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore import vtkmodules.vtkRenderingCore as __vtkmodules_vtkRenderingCore import vtkmodules.vtkRenderingOpenGL2 as __vtkmodules_vtkRenderingOpenGL2 # no functions # classes class vtkClientServerCompositePass(__vtkmodules_vtkRenderingCore.vtkRenderPass): """ vtkClientServerCompositePass - vtkClientServerCompositePass is a render-pass that can handle client-server image delivery. Superclass: vtkRenderPass This is designed to be used in configurations in two-processes configurations. """ def GetController(self): # real signature unknown; restored from __doc__ """ GetController(self) -> vtkMultiProcessController C++: virtual vtkMultiProcessController *GetController() Controller If it is NULL, nothing will be rendered and a warning will be emitted. Initial value is a NULL pointer. This must be set to the socket controller used for communicating between the client and the server. """ pass def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetPostProcessingRenderPass(self): # real signature unknown; restored from __doc__ """ GetPostProcessingRenderPass(self) -> vtkRenderPass C++: virtual vtkRenderPass *GetPostProcessingRenderPass() """ pass def GetProcessIsServer(self): # real signature unknown; restored from __doc__ """ GetProcessIsServer(self) -> bool C++: virtual bool GetProcessIsServer() """ return False def GetRenderPass(self): # real signature unknown; restored from __doc__ """ GetRenderPass(self) -> vtkRenderPass C++: virtual vtkRenderPass *GetRenderPass() """ pass def GetServerSideRendering(self): # real signature unknown; restored from __doc__ """ GetServerSideRendering(self) -> bool C++: virtual bool GetServerSideRendering() """ return False def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkClientServerCompositePass C++: vtkClientServerCompositePass *NewInstance() """ return vtkClientServerCompositePass def ProcessIsServerOff(self): # real signature unknown; restored from __doc__ """ ProcessIsServerOff(self) -> None C++: virtual void ProcessIsServerOff() """ pass def ProcessIsServerOn(self): # real signature unknown; restored from __doc__ """ ProcessIsServerOn(self) -> None C++: virtual void ProcessIsServerOn() """ pass def ReleaseGraphicsResources(self, w): # real signature unknown; restored from __doc__ """ ReleaseGraphicsResources(self, w:vtkWindow) -> None C++: void ReleaseGraphicsResources(vtkWindow *w) override; Release graphics resources and ask components to release their own resources. \pre w_exists: w!=0 """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkClientServerCompositePass C++: static vtkClientServerCompositePass *SafeDownCast( vtkObjectBase *o) """ return vtkClientServerCompositePass def ServerSideRenderingOff(self): # real signature unknown; restored from __doc__ """ ServerSideRenderingOff(self) -> None C++: virtual void ServerSideRenderingOff() """ pass def ServerSideRenderingOn(self): # real signature unknown; restored from __doc__ """ ServerSideRenderingOn(self) -> None C++: virtual void ServerSideRenderingOn() """ pass def SetController(self, controller): # real signature unknown; restored from __doc__ """ SetController(self, controller:vtkMultiProcessController) -> None C++: virtual void SetController( vtkMultiProcessController *controller) """ pass def SetPostProcessingRenderPass(self, __a): # real signature unknown; restored from __doc__ """ SetPostProcessingRenderPass(self, __a:vtkRenderPass) -> None C++: void SetPostProcessingRenderPass(vtkRenderPass *) Set/Get the optional post-fetch render pass. On the client-process this is called after the server-side image is fetched (if ServerSideRendering is true). On server-process, this is called after the image rendered by this->RenderPass is delivered to the client (if ServerSideRendering is true). This is optional, so you can set this either on one of the two processes or both or neither. """ pass def SetProcessIsServer(self, _arg): # real signature unknown; restored from __doc__ """ SetProcessIsServer(self, _arg:bool) -> None C++: virtual void SetProcessIsServer(bool _arg) Set the current process type. This is needed since when using the socket communicator there's no easy way of determining which process is the server and which one is the client. """ pass def SetRenderPass(self, __a): # real signature unknown; restored from __doc__ """ SetRenderPass(self, __a:vtkRenderPass) -> None C++: void SetRenderPass(vtkRenderPass *) Get/Set the render pass used to do the actual rendering. When ServerSideRendering is true, the rendering-pass is called only on the server side. """ pass def SetServerSideRendering(self, _arg): # real signature unknown; restored from __doc__ """ SetServerSideRendering(self, _arg:bool) -> None C++: virtual void SetServerSideRendering(bool _arg) Enable/Disable fetching of the image from the server side to the client. If this flag is disabled, then this pass just acts as a "pass-through" pass. This flag must be set to the same value on both the processes. """ pass def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkClientServerCompositePass', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'ReleaseGraphicsResources': , 'GetController': , 'SetController': , 'SetRenderPass': , 'GetRenderPass': , 'SetPostProcessingRenderPass': , 'GetPostProcessingRenderPass': , 'SetProcessIsServer': , 'ProcessIsServerOn': , 'ProcessIsServerOff': , 'GetProcessIsServer': , 'SetServerSideRendering': , 'ServerSideRenderingOn': , 'ServerSideRenderingOff': , 'GetServerSideRendering': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkClientServerCompositePass - vtkClientServerCompositePass is a\\nrender-pass that can handle client-server image delivery.\\n\\nSuperclass: vtkRenderPass\\n\\nThis is designed to be used in configurations in two-processes\\nconfigurations.\\n\\n'})" __vtkname__ = 'vtkClientServerCompositePass' class vtkSynchronizedRenderers(__vtkmodules_vtkCommonCore.vtkObject): """ vtkSynchronizedRenderers - synchronizes renderers across processes. Superclass: vtkObject vtkSynchronizedRenderers is used to synchronize renderers (vtkRenderer and subclasses) across processes for parallel rendering. It's designed to be used in conjunction with vtkSynchronizedRenderWindows to synchronize the render windows among those processes. This class handles synchronization of certain render parameters among the renderers such as viewport, camera parameters. It doesn't support compositing of rendered images across processes on its own. You typically either subclass to implement a compositing algorithm or use a renderer capable of compositing eg. IceT based renderer. """ def AutomaticEventHandlingOff(self): # real signature unknown; restored from __doc__ """ AutomaticEventHandlingOff(self) -> None C++: virtual void AutomaticEventHandlingOff() """ pass def AutomaticEventHandlingOn(self): # real signature unknown; restored from __doc__ """ AutomaticEventHandlingOn(self) -> None C++: virtual void AutomaticEventHandlingOn() """ pass def CollectiveExpandForVisiblePropBounds(self, bounds, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ CollectiveExpandForVisiblePropBounds(self, bounds:[float, float, float, float, float, float]) -> None C++: void CollectiveExpandForVisiblePropBounds(double bounds[6]) Computes visible prob bounds. This must be called on all processes at the same time. The collective result is made available on all processes once this method returns. Note that this method requires that bounds is initialized to some value. This expands the bounds to include the prop bounds. """ pass def FixBackgroundOff(self): # real signature unknown; restored from __doc__ """ FixBackgroundOff(self) -> None C++: virtual void FixBackgroundOff() """ pass def FixBackgroundOn(self): # real signature unknown; restored from __doc__ """ FixBackgroundOn(self) -> None C++: virtual void FixBackgroundOn() """ pass def GetAutomaticEventHandling(self): # real signature unknown; restored from __doc__ """ GetAutomaticEventHandling(self) -> bool C++: virtual bool GetAutomaticEventHandling() """ return False def GetCaptureDelegate(self): # real signature unknown; restored from __doc__ """ GetCaptureDelegate(self) -> vtkSynchronizedRenderers C++: virtual vtkSynchronizedRenderers *GetCaptureDelegate() """ return vtkSynchronizedRenderers def GetFixBackground(self): # real signature unknown; restored from __doc__ """ GetFixBackground(self) -> bool C++: virtual bool GetFixBackground() """ return False def GetImageReductionFactor(self): # real signature unknown; restored from __doc__ """ GetImageReductionFactor(self) -> int C++: virtual int GetImageReductionFactor() """ return 0 def GetImageReductionFactorMaxValue(self): # real signature unknown; restored from __doc__ """ GetImageReductionFactorMaxValue(self) -> int C++: virtual int GetImageReductionFactorMaxValue() """ return 0 def GetImageReductionFactorMinValue(self): # real signature unknown; restored from __doc__ """ GetImageReductionFactorMinValue(self) -> int C++: virtual int GetImageReductionFactorMinValue() """ return 0 def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetParallelController(self): # real signature unknown; restored from __doc__ """ GetParallelController(self) -> vtkMultiProcessController C++: virtual vtkMultiProcessController *GetParallelController() """ pass def GetParallelRendering(self): # real signature unknown; restored from __doc__ """ GetParallelRendering(self) -> bool C++: virtual bool GetParallelRendering() """ return False def GetRenderer(self): # real signature unknown; restored from __doc__ """ GetRenderer(self) -> vtkRenderer C++: virtual vtkRenderer *GetRenderer() """ pass def GetRootProcessId(self): # real signature unknown; restored from __doc__ """ GetRootProcessId(self) -> int C++: virtual int GetRootProcessId() """ return 0 def GetWriteBackImages(self): # real signature unknown; restored from __doc__ """ GetWriteBackImages(self) -> bool C++: virtual bool GetWriteBackImages() """ return False def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkSynchronizedRenderers C++: vtkSynchronizedRenderers *NewInstance() """ return vtkSynchronizedRenderers def ParallelRenderingOff(self): # real signature unknown; restored from __doc__ """ ParallelRenderingOff(self) -> None C++: virtual void ParallelRenderingOff() """ pass def ParallelRenderingOn(self): # real signature unknown; restored from __doc__ """ ParallelRenderingOn(self) -> None C++: virtual void ParallelRenderingOn() """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkSynchronizedRenderers C++: static vtkSynchronizedRenderers *SafeDownCast( vtkObjectBase *o) """ return vtkSynchronizedRenderers def SetAutomaticEventHandling(self, _arg): # real signature unknown; restored from __doc__ """ SetAutomaticEventHandling(self, _arg:bool) -> None C++: virtual void SetAutomaticEventHandling(bool _arg) When multiple groups of processes are synchronized together using different controllers, one needs to specify the order in which the various synchronizers execute. In such cases one starts with the outer most vtkSynchronizedRenderers, sets the dependent one as a CaptureDelegate on it and the turn off AutomaticEventHandling on the delegate. """ pass def SetCaptureDelegate(self, __a): # real signature unknown; restored from __doc__ """ SetCaptureDelegate(self, __a:vtkSynchronizedRenderers) -> None C++: virtual void SetCaptureDelegate(vtkSynchronizedRenderers *) When set, this->CaptureRenderedImage() does not capture image from the screen instead passes the call to the delegate. """ pass def SetFixBackground(self, _arg): # real signature unknown; restored from __doc__ """ SetFixBackground(self, _arg:bool) -> None C++: virtual void SetFixBackground(bool _arg) When doing rendering between multiple processes, it is often easier to have all ranks do the rendering on a black background. This helps avoid issues where the background gets over blended as the images are composted together. If set to true (default is false), before the rendering begins, vtkSynchronizedRenderers will change the renderer's background color and other flags to make it render on a black background and then restore then on end render. If WriteBackImages is true, then the background will indeed be restored before the write-back happens, thus ensuring the result displayed to the user is on correct background. """ pass def SetImageReductionFactor(self, _arg): # real signature unknown; restored from __doc__ """ SetImageReductionFactor(self, _arg:int) -> None C++: virtual void SetImageReductionFactor(int _arg) Get/Set the image reduction factor. """ pass def SetParallelController(self, __a): # real signature unknown; restored from __doc__ """ SetParallelController(self, __a:vtkMultiProcessController) -> None C++: virtual void SetParallelController( vtkMultiProcessController *) Set the parallel message communicator. This is used to communicate among processes. """ pass def SetParallelRendering(self, _arg): # real signature unknown; restored from __doc__ """ SetParallelRendering(self, _arg:bool) -> None C++: virtual void SetParallelRendering(bool _arg) Enable/Disable parallel rendering. Unless Parallel rendering is on, the cameras won't be synchronized across processes. """ pass def SetRenderer(self, __a): # real signature unknown; restored from __doc__ """ SetRenderer(self, __a:vtkRenderer) -> None C++: virtual void SetRenderer(vtkRenderer *) Set the renderer to be synchronized by this instance. A vtkSynchronizedRenderers instance can be used to synchronize exactly 1 renderer on each processes. You can create multiple instances on vtkSynchronizedRenderers to synchronize multiple renderers. """ pass def SetRootProcessId(self, _arg): # real signature unknown; restored from __doc__ """ SetRootProcessId(self, _arg:int) -> None C++: virtual void SetRootProcessId(int _arg) Get/Set the root-process id. This is required when the ParallelController is a vtkSocketController. Set to 0 by default (which will not work when using a vtkSocketController but will work for vtkMPIController). """ pass def SetWriteBackImages(self, _arg): # real signature unknown; restored from __doc__ """ SetWriteBackImages(self, _arg:bool) -> None C++: virtual void SetWriteBackImages(bool _arg) If on (default), the rendered images are pasted back on to the screen. You should turn this flag off on processes that are not meant to be visible to the user. """ pass def WriteBackImagesOff(self): # real signature unknown; restored from __doc__ """ WriteBackImagesOff(self) -> None C++: virtual void WriteBackImagesOff() """ pass def WriteBackImagesOn(self): # real signature unknown; restored from __doc__ """ WriteBackImagesOn(self) -> None C++: virtual void WriteBackImagesOn() """ pass def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" COMPUTE_BOUNDS_TAG = 15103 RESET_CAMERA_TAG = 15102 SYNC_RENDERER_TAG = 15101 __dict__ = None # (!) real value is 'mappingproxy({\'__vtkname__\': \'vtkSynchronizedRenderers\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'SetRenderer\': , \'GetRenderer\': , \'SetParallelController\': , \'GetParallelController\': , \'SetParallelRendering\': , \'GetParallelRendering\': , \'ParallelRenderingOn\': , \'ParallelRenderingOff\': , \'SetImageReductionFactor\': , \'GetImageReductionFactorMinValue\': , \'GetImageReductionFactorMaxValue\': , \'GetImageReductionFactor\': , \'SetWriteBackImages\': , \'GetWriteBackImages\': , \'WriteBackImagesOn\': , \'WriteBackImagesOff\': , \'SetRootProcessId\': , \'GetRootProcessId\': , \'CollectiveExpandForVisiblePropBounds\': , \'SetCaptureDelegate\': , \'GetCaptureDelegate\': , \'SetAutomaticEventHandling\': , \'GetAutomaticEventHandling\': , \'AutomaticEventHandlingOn\': , \'AutomaticEventHandlingOff\': , \'SetFixBackground\': , \'GetFixBackground\': , \'FixBackgroundOn\': , \'FixBackgroundOff\': , \'SYNC_RENDERER_TAG\': 15101, \'RESET_CAMERA_TAG\': 15102, \'COMPUTE_BOUNDS_TAG\': 15103, \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': "vtkSynchronizedRenderers - synchronizes renderers across processes.\\n\\nSuperclass: vtkObject\\n\\nvtkSynchronizedRenderers is used to synchronize renderers\\n(vtkRenderer and subclasses) across processes for parallel rendering.\\nIt\'s designed to be used in conjunction with\\nvtkSynchronizedRenderWindows to synchronize the render windows among\\nthose processes. This class handles synchronization of certain render\\nparameters among the renderers such as viewport, camera parameters.\\nIt doesn\'t support compositing of rendered images across processes on\\nits own. You typically either subclass to implement a compositing\\nalgorithm or use a renderer capable of compositing eg. IceT based\\nrenderer.\\n\\n"})' __vtkname__ = 'vtkSynchronizedRenderers' class vtkClientServerSynchronizedRenderers(vtkSynchronizedRenderers): """ vtkClientServerSynchronizedRenderers - vtkClientServerSynchronizedRenderers is a vtkSynchronizedRenderers subclass designed to be used in 2 processes, client-server mode. Superclass: vtkSynchronizedRenderers """ def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkClientServerSynchronizedRenderers C++: vtkClientServerSynchronizedRenderers *NewInstance() """ return vtkClientServerSynchronizedRenderers def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkClientServerSynchronizedRenderers C++: static vtkClientServerSynchronizedRenderers *SafeDownCast( vtkObjectBase *o) """ return vtkClientServerSynchronizedRenderers def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkClientServerSynchronizedRenderers', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkClientServerSynchronizedRenderers -\\nvtkClientServerSynchronizedRenderers is a vtkSynchronizedRenderers\\nsubclass designed to be used in 2 processes, client-server mode.\\n\\nSuperclass: vtkSynchronizedRenderers\\n\\n'})" __vtkname__ = 'vtkClientServerSynchronizedRenderers' class vtkCompositedSynchronizedRenderers(vtkSynchronizedRenderers): """ vtkCompositedSynchronizedRenderers - vtkCompositedSynchronizedRenderers is vtkSynchronizedRenderers that uses vtkCompositer to composite the images on the root node. Superclass: vtkSynchronizedRenderers """ def GetCompositer(self): # real signature unknown; restored from __doc__ """ GetCompositer(self) -> vtkCompositer C++: virtual vtkCompositer *GetCompositer() """ return vtkCompositer def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkCompositedSynchronizedRenderers C++: vtkCompositedSynchronizedRenderers *NewInstance() """ return vtkCompositedSynchronizedRenderers def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkCompositedSynchronizedRenderers C++: static vtkCompositedSynchronizedRenderers *SafeDownCast( vtkObjectBase *o) """ return vtkCompositedSynchronizedRenderers def SetCompositer(self, __a): # real signature unknown; restored from __doc__ """ SetCompositer(self, __a:vtkCompositer) -> None C++: void SetCompositer(vtkCompositer *) Get/Set the composite. vtkTreeCompositer is used by default. """ pass def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkCompositedSynchronizedRenderers', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'SetCompositer': , 'GetCompositer': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkCompositedSynchronizedRenderers -\\nvtkCompositedSynchronizedRenderers is vtkSynchronizedRenderers that\\nuses vtkCompositer to composite the images on the root node.\\n\\nSuperclass: vtkSynchronizedRenderers\\n\\n'})" __vtkname__ = 'vtkCompositedSynchronizedRenderers' class vtkCompositer(__vtkmodules_vtkCommonCore.vtkObject): """ vtkCompositer - Super class for composite algorithms. Superclass: vtkObject vtkCompositer operates in multiple processes. Each compositer has a render window. They use vtkMultiProcessControllers to communicate the color and depth buffer to process 0's render window. It will not handle transparency well. @sa vtkCompositeManager. """ def CompositeBuffer(self, pBuf, zBuf, pTmp, zTmp): # real signature unknown; restored from __doc__ """ CompositeBuffer(self, pBuf:vtkDataArray, zBuf:vtkFloatArray, pTmp:vtkDataArray, zTmp:vtkFloatArray) -> None C++: virtual void CompositeBuffer(vtkDataArray *pBuf, vtkFloatArray *zBuf, vtkDataArray *pTmp, vtkFloatArray *zTmp) This method gets called on every process. The final image gets put into pBuf and zBuf. """ pass def DeleteArray(self, da): # real signature unknown; restored from __doc__ """ DeleteArray(da:vtkDataArray) -> None C++: static void DeleteArray(vtkDataArray *da) Methods that allocate and delete memory with special MPIPro calls. """ pass def GetController(self): # real signature unknown; restored from __doc__ """ GetController(self) -> vtkMultiProcessController C++: virtual vtkMultiProcessController *GetController() """ pass def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfProcesses(self): # real signature unknown; restored from __doc__ """ GetNumberOfProcesses(self) -> int C++: virtual int GetNumberOfProcesses() """ return 0 def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkCompositer C++: vtkCompositer *NewInstance() """ return vtkCompositer def ResizeFloatArray(self, fa, numComp, size): # real signature unknown; restored from __doc__ """ ResizeFloatArray(fa:vtkFloatArray, numComp:int, size:int) -> None C++: static void ResizeFloatArray(vtkFloatArray *fa, int numComp, vtkIdType size) """ pass def ResizeUnsignedCharArray(self, uca, numComp, size): # real signature unknown; restored from __doc__ """ ResizeUnsignedCharArray(uca:vtkUnsignedCharArray, numComp:int, size:int) -> None C++: static void ResizeUnsignedCharArray( vtkUnsignedCharArray *uca, int numComp, vtkIdType size) """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkCompositer C++: static vtkCompositer *SafeDownCast(vtkObjectBase *o) """ return vtkCompositer def SetController(self, __a): # real signature unknown; restored from __doc__ """ SetController(self, __a:vtkMultiProcessController) -> None C++: virtual void SetController(vtkMultiProcessController *) Access to the controller. """ pass def SetNumberOfProcesses(self, _arg): # real signature unknown; restored from __doc__ """ SetNumberOfProcesses(self, _arg:int) -> None C++: virtual void SetNumberOfProcesses(int _arg) A hack to get a sub world until I can get communicators working. """ pass def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is 'mappingproxy({\'__vtkname__\': \'vtkCompositer\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'CompositeBuffer\': , \'SetController\': , \'GetController\': , \'SetNumberOfProcesses\': , \'GetNumberOfProcesses\': , \'DeleteArray\': , \'ResizeFloatArray\': , \'ResizeUnsignedCharArray\': , \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': "vtkCompositer - Super class for composite algorithms.\\n\\nSuperclass: vtkObject\\n\\nvtkCompositer operates in multiple processes. Each compositer has a\\nrender window. They use vtkMultiProcessControllers to communicate\\nthe color and depth buffer to process 0\'s render window. It will not\\nhandle transparency well.\\n\\n@sa\\nvtkCompositeManager.\\n\\n"})' __vtkname__ = 'vtkCompositer' class vtkParallelRenderManager(__vtkmodules_vtkCommonCore.vtkObject): """ vtkParallelRenderManager - An object to control parallel rendering. Superclass: vtkObject vtkParallelRenderManager operates in multiple processes. It provides proper renderers and render windows for performing the parallel rendering correctly. It can also attach itself to render windows and propagate rendering events and camera views. @attention Many parallel rendering schemes do not correctly handle transparency. Unless otherwise documented, assume a sub class does not. @todo Synchronization/barrier primitives. @todo Query ranges of scalar values of objects in addition to the boundary in three-space """ def AddRenderer(self, __a): # real signature unknown; restored from __doc__ """ AddRenderer(self, __a:vtkRenderer) -> None C++: virtual void AddRenderer(vtkRenderer *) """ pass def AutoImageReductionFactorOff(self): # real signature unknown; restored from __doc__ """ AutoImageReductionFactorOff(self) -> None C++: virtual void AutoImageReductionFactorOff() """ pass def AutoImageReductionFactorOn(self): # real signature unknown; restored from __doc__ """ AutoImageReductionFactorOn(self) -> None C++: virtual void AutoImageReductionFactorOn() """ pass def CheckForAbortComposite(self): # real signature unknown; restored from __doc__ """ CheckForAbortComposite(self) -> int C++: virtual int CheckForAbortComposite() """ return 0 def CheckForAbortRender(self): # real signature unknown; restored from __doc__ """ CheckForAbortRender(self) -> None C++: virtual void CheckForAbortRender() """ pass def ComputeVisiblePropBounds(self, ren, bounds, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ ComputeVisiblePropBounds(self, ren:vtkRenderer, bounds:[float, float, float, float, float, float]) -> None C++: virtual void ComputeVisiblePropBounds(vtkRenderer *ren, double bounds[6]) Calculates the bounds by gathering information from all processes. """ pass def ComputeVisiblePropBoundsRMI(self, renderId): # real signature unknown; restored from __doc__ """ ComputeVisiblePropBoundsRMI(self, renderId:int) -> None C++: virtual void ComputeVisiblePropBoundsRMI(int renderId) """ pass def EndRender(self): # real signature unknown; restored from __doc__ """ EndRender(self) -> None C++: virtual void EndRender() """ pass def GenericEndRenderCallback(self): # real signature unknown; restored from __doc__ """ GenericEndRenderCallback(self) -> None C++: virtual void GenericEndRenderCallback() """ pass def GenericStartRenderCallback(self): # real signature unknown; restored from __doc__ """ GenericStartRenderCallback(self) -> None C++: virtual void GenericStartRenderCallback() INTERNAL METHODS (DON NOT USE). There are internal methods made public so that they can be called from callback functions. """ pass def GetAutoImageReductionFactor(self): # real signature unknown; restored from __doc__ """ GetAutoImageReductionFactor(self) -> int C++: virtual int GetAutoImageReductionFactor() """ return 0 def GetController(self): # real signature unknown; restored from __doc__ """ GetController(self) -> vtkMultiProcessController C++: virtual vtkMultiProcessController *GetController() Set/Get the vtkMultiProcessController which will handle communications for the parallel rendering. """ pass def GetDefaultRenderEventPropagation(self): # real signature unknown; restored from __doc__ """ GetDefaultRenderEventPropagation() -> bool C++: static bool GetDefaultRenderEventPropagation() """ return False def GetForcedRenderWindowSize(self): # real signature unknown; restored from __doc__ """ GetForcedRenderWindowSize(self) -> (int, int) C++: virtual int *GetForcedRenderWindowSize() """ pass def GetForceRenderWindowSize(self): # real signature unknown; restored from __doc__ """ GetForceRenderWindowSize(self) -> int C++: virtual int GetForceRenderWindowSize() """ return 0 def GetFullImageSize(self): # real signature unknown; restored from __doc__ """ GetFullImageSize(self) -> (int, int) C++: virtual int *GetFullImageSize() Returns the full image size calculated at the last render. """ pass def GetImageProcessingTime(self): # real signature unknown; restored from __doc__ """ GetImageProcessingTime(self) -> float C++: virtual double GetImageProcessingTime() """ return 0.0 def GetImageReductionFactor(self): # real signature unknown; restored from __doc__ """ GetImageReductionFactor(self) -> float C++: virtual double GetImageReductionFactor() """ return 0.0 def GetMagnifyImageMethod(self): # real signature unknown; restored from __doc__ """ GetMagnifyImageMethod(self) -> int C++: virtual int GetMagnifyImageMethod() """ return 0 def GetMagnifyImages(self): # real signature unknown; restored from __doc__ """ GetMagnifyImages(self) -> int C++: virtual int GetMagnifyImages() """ return 0 def GetMaxImageReductionFactor(self): # real signature unknown; restored from __doc__ """ GetMaxImageReductionFactor(self) -> float C++: virtual double GetMaxImageReductionFactor() """ return 0.0 def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetParallelRendering(self): # real signature unknown; restored from __doc__ """ GetParallelRendering(self) -> int C++: virtual int GetParallelRendering() """ return 0 def GetPixelData(self, data): # real signature unknown; restored from __doc__ """ GetPixelData(self, data:vtkUnsignedCharArray) -> None C++: virtual void GetPixelData(vtkUnsignedCharArray *data) GetPixelData(self, x1:int, y1:int, x2:int, y2:int, data:vtkUnsignedCharArray) -> None C++: virtual void GetPixelData(int x1, int y1, int x2, int y2, vtkUnsignedCharArray *data) The most appropriate way to retrieve full size image data after a render. Will work regardless of whether WriteBackImages or MagnifyImage is on or off. The data returned may be a shallow copy of an internal array. Therefore, the data may be invalid after the next render or if the ParallelRenderManager is destroyed. """ pass def GetReducedImageSize(self): # real signature unknown; restored from __doc__ """ GetReducedImageSize(self) -> (int, int) C++: virtual int *GetReducedImageSize() Returns the reduced image size calculated at the last render. """ pass def GetReducedPixelData(self, data): # real signature unknown; restored from __doc__ """ GetReducedPixelData(self, data:vtkUnsignedCharArray) -> None C++: virtual void GetReducedPixelData(vtkUnsignedCharArray *data) GetReducedPixelData(self, x1:int, y1:int, x2:int, y2:int, data:vtkUnsignedCharArray) -> None C++: virtual void GetReducedPixelData(int x1, int y1, int x2, int y2, vtkUnsignedCharArray *data) The most appropriate way to retrieve reduced size image data after a render. Will work regardless of whether WriteBackImages or MagnifyImage is on or off. The data returned may be a shallow copy of an internal array. Therefore, the data may be invalid after the next render or if the ParallelRenderManager is destroyed. """ pass def GetRenderEventPropagation(self): # real signature unknown; restored from __doc__ """ GetRenderEventPropagation(self) -> int C++: virtual int GetRenderEventPropagation() """ return 0 def GetRenderTime(self): # real signature unknown; restored from __doc__ """ GetRenderTime(self) -> float C++: virtual double GetRenderTime() Get rendering metrics. """ return 0.0 def GetRenderWindow(self): # real signature unknown; restored from __doc__ """ GetRenderWindow(self) -> vtkRenderWindow C++: virtual vtkRenderWindow *GetRenderWindow() Set/Get the RenderWindow to use for compositing. We add a start and end observer to the window. """ pass def GetSynchronizeTileProperties(self): # real signature unknown; restored from __doc__ """ GetSynchronizeTileProperties(self) -> int C++: virtual int GetSynchronizeTileProperties() """ return 0 def GetSyncRenderWindowRenderers(self): # real signature unknown; restored from __doc__ """ GetSyncRenderWindowRenderers(self) -> int C++: virtual int GetSyncRenderWindowRenderers() By default, the state of all renderers in the root's render window is propagated to the rest of the processes. In order for this to work, all render windows must have the same renderers in the same order. If this is not the case, you can turn off the SyncRenderWindowRenderers. When this flag is off, the list of renderers held by this parallel render manager (initially empty) is synced. You can modify the list of renderers with the AddRenderer, RemoveRenderer, and RemoveAllRenderers methods. """ return 0 def GetUseBackBuffer(self): # real signature unknown; restored from __doc__ """ GetUseBackBuffer(self) -> int C++: virtual int GetUseBackBuffer() """ return 0 def GetUseCompositing(self): # real signature unknown; restored from __doc__ """ GetUseCompositing(self) -> int C++: virtual int GetUseCompositing() """ return 0 def GetUseRGBA(self): # real signature unknown; restored from __doc__ """ GetUseRGBA(self) -> int C++: virtual int GetUseRGBA() """ return 0 def GetWriteBackImages(self): # real signature unknown; restored from __doc__ """ GetWriteBackImages(self) -> int C++: virtual int GetWriteBackImages() """ return 0 def InitializeOffScreen(self): # real signature unknown; restored from __doc__ """ InitializeOffScreen(self) -> None C++: virtual void InitializeOffScreen() Make all rendering windows not viewable set as off screen rendering. To make all renderwindows on screen rendering again, call OffScreenRenderingOff on all the render windows. This class assumes the window on root node is the only one viewable. Subclasses should change this as necessary. """ pass def InitializePieces(self): # real signature unknown; restored from __doc__ """ InitializePieces(self) -> None C++: virtual void InitializePieces() This method sets the piece and number of pieces for each actor with a polydata mapper. """ pass def InitializeRMIs(self): # real signature unknown; restored from __doc__ """ InitializeRMIs(self) -> None C++: virtual void InitializeRMIs() """ pass def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def MagnifyImage(self, fullImage, fullImageSize, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ MagnifyImage(self, fullImage:vtkUnsignedCharArray, fullImageSize:( int, int), reducedImage:vtkUnsignedCharArray, reducedImageSize:(int, int), fullImageViewport:(int, int, int, int)=..., reducedImageViewport:(int, int, int, int)=...) -> None C++: virtual void MagnifyImage(vtkUnsignedCharArray *fullImage, const int fullImageSize[2], vtkUnsignedCharArray *reducedImage, const int reducedImageSize[2], const int fullImageViewport[4]=nullptr, const int reducedImageViewport[4]=nullptr) Convenience functions for magnifying images. """ pass def MagnifyImageLinear(self, fullImage, fullImageSize, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ MagnifyImageLinear(fullImage:vtkUnsignedCharArray, fullImageSize:( int, int), reducedImage:vtkUnsignedCharArray, reducedImageSize:(int, int), fullImageViewport:(int, int, int, int)=..., reducedImageViewport:(int, int, int, int)=...) -> None C++: static void MagnifyImageLinear( vtkUnsignedCharArray *fullImage, const int fullImageSize[2], vtkUnsignedCharArray *reducedImage, const int reducedImageSize[2], const int fullImageViewport[4]=nullptr, const int reducedImageViewport[4]=nullptr) """ pass def MagnifyImageNearest(self, fullImage, fullImageSize, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ MagnifyImageNearest(fullImage:vtkUnsignedCharArray, fullImageSize:(int, int), reducedImage:vtkUnsignedCharArray, reducedImageSize:(int, int), fullImageViewport:(int, int, int, int)=..., reducedImageViewport:(int, int, int, int)=...) -> None C++: static void MagnifyImageNearest( vtkUnsignedCharArray *fullImage, const int fullImageSize[2], vtkUnsignedCharArray *reducedImage, const int reducedImageSize[2], const int fullImageViewport[4]=nullptr, const int reducedImageViewport[4]=nullptr) """ pass def MagnifyImagesOff(self): # real signature unknown; restored from __doc__ """ MagnifyImagesOff(self) -> None C++: virtual void MagnifyImagesOff() """ pass def MagnifyImagesOn(self): # real signature unknown; restored from __doc__ """ MagnifyImagesOn(self) -> None C++: virtual void MagnifyImagesOn() """ pass def MakeRenderer(self): # real signature unknown; restored from __doc__ """ MakeRenderer(self) -> vtkRenderer C++: virtual vtkRenderer *MakeRenderer() Builds a vtkRenderer compatible with this render manager. (Should we also register it?) The user program is responsible for calling Delete. It is not advisable to use a parallel render manager with a renderer that was not built with this method. """ pass def MakeRenderWindow(self): # real signature unknown; restored from __doc__ """ MakeRenderWindow(self) -> vtkRenderWindow C++: virtual vtkRenderWindow *MakeRenderWindow() Builds a vtkRenderWindow compatible with this render manager. The user program is responsible for registering the render window with the SetRenderWindow method and calling Delete. It is not advisable to use a parallel render manager with a render window that was not built with this method. """ pass def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkParallelRenderManager C++: vtkParallelRenderManager *NewInstance() """ return vtkParallelRenderManager def ParallelRenderingOff(self): # real signature unknown; restored from __doc__ """ ParallelRenderingOff(self) -> None C++: virtual void ParallelRenderingOff() """ pass def ParallelRenderingOn(self): # real signature unknown; restored from __doc__ """ ParallelRenderingOn(self) -> None C++: virtual void ParallelRenderingOn() """ pass def RemoveAllRenderers(self): # real signature unknown; restored from __doc__ """ RemoveAllRenderers(self) -> None C++: virtual void RemoveAllRenderers() """ pass def RemoveRenderer(self, __a): # real signature unknown; restored from __doc__ """ RemoveRenderer(self, __a:vtkRenderer) -> None C++: virtual void RemoveRenderer(vtkRenderer *) """ pass def RenderEventPropagationOff(self): # real signature unknown; restored from __doc__ """ RenderEventPropagationOff(self) -> None C++: virtual void RenderEventPropagationOff() """ pass def RenderEventPropagationOn(self): # real signature unknown; restored from __doc__ """ RenderEventPropagationOn(self) -> None C++: virtual void RenderEventPropagationOn() """ pass def RenderRMI(self): # real signature unknown; restored from __doc__ """ RenderRMI(self) -> None C++: virtual void RenderRMI() """ pass def ResetAllCameras(self): # real signature unknown; restored from __doc__ """ ResetAllCameras(self) -> None C++: virtual void ResetAllCameras() Resets the camera of each renderer contained in the RenderWindow. Should only be called in the "root" process, and all remote processes must be processing RMIs for this method to complete. """ pass def ResetCamera(self, ren): # real signature unknown; restored from __doc__ """ ResetCamera(self, ren:vtkRenderer) -> None C++: virtual void ResetCamera(vtkRenderer *ren) """ pass def ResetCameraClippingRange(self, ren): # real signature unknown; restored from __doc__ """ ResetCameraClippingRange(self, ren:vtkRenderer) -> None C++: virtual void ResetCameraClippingRange(vtkRenderer *ren) """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkParallelRenderManager C++: static vtkParallelRenderManager *SafeDownCast( vtkObjectBase *o) """ return vtkParallelRenderManager def SatelliteEndRender(self): # real signature unknown; restored from __doc__ """ SatelliteEndRender(self) -> None C++: virtual void SatelliteEndRender() """ pass def SatelliteStartRender(self): # real signature unknown; restored from __doc__ """ SatelliteStartRender(self) -> None C++: virtual void SatelliteStartRender() """ pass def SetAutoImageReductionFactor(self, _arg): # real signature unknown; restored from __doc__ """ SetAutoImageReductionFactor(self, _arg:int) -> None C++: virtual void SetAutoImageReductionFactor(int _arg) If on, the ReductionFactor is automatically adjusted to best meet the the DesiredUpdateRate in the current RenderWindow based on metrics from the last render. """ pass def SetController(self, controller): # real signature unknown; restored from __doc__ """ SetController(self, controller:vtkMultiProcessController) -> None C++: virtual void SetController( vtkMultiProcessController *controller) """ pass def SetDefaultRenderEventPropagation(self, val): # real signature unknown; restored from __doc__ """ SetDefaultRenderEventPropagation(val:bool) -> None C++: static void SetDefaultRenderEventPropagation(bool val) Get/Set the default value used for RenderEventPropagation when a new instance of vtkParallelRenderManager is created. Set to true by default. """ pass def SetForcedRenderWindowSize(self, _arg1, _arg2): # real signature unknown; restored from __doc__ """ SetForcedRenderWindowSize(self, _arg1:int, _arg2:int) -> None C++: virtual void SetForcedRenderWindowSize(int _arg1, int _arg2) SetForcedRenderWindowSize(self, _arg:(int, int)) -> None C++: void SetForcedRenderWindowSize(const int _arg[2]) If ForceRenderWindowSize is set to true, the render manager will use the Size ivar instead of getting the size from the render window. """ pass def SetForceRenderWindowSize(self, _arg): # real signature unknown; restored from __doc__ """ SetForceRenderWindowSize(self, _arg:int) -> None C++: virtual void SetForceRenderWindowSize(int _arg) If ForceRenderWindowSize is set to true, the render manager will use the RenderWindowSize ivar instead of getting the size from the render window. """ pass def SetImageReductionFactor(self, factor): # real signature unknown; restored from __doc__ """ SetImageReductionFactor(self, factor:float) -> None C++: virtual void SetImageReductionFactor(double factor) Set/Get the reduction factor (for sort-last based parallel renderers). The size of rendered image is divided by the reduction factor and then is blown up to the size of the current vtkRenderWindow. Setting higher reduction factors enables shorter image transfer times (which is often the bottleneck) but will greatly reduce image quality. A reduction factor of 2 or greater should only be used for intermediate images in interactive applications. A reduction factor of 1 (or less) will result in no change in image quality. A parallel render manager may ignore the image reduction factor if it will result in little or no performance enhancements (eg. it does not do image space manipulations). """ pass def SetImageReductionFactorForUpdateRate(self, DesiredUpdateRate): # real signature unknown; restored from __doc__ """ SetImageReductionFactorForUpdateRate(self, DesiredUpdateRate:float) -> None C++: virtual void SetImageReductionFactorForUpdateRate( double DesiredUpdateRate) Sets the ReductionFactor based on the given desired update rate and the rendering metrics taken from the last time UpdateServerInfo was called. Note that if AutoReductionFactor is on, this function is called with the desired update rate of the render window automatically. """ pass def SetMagnifyImageMethod(self, method): # real signature unknown; restored from __doc__ """ SetMagnifyImageMethod(self, method:int) -> None C++: virtual void SetMagnifyImageMethod(int method) Sets the method used to magnify images. Nearest simply replicates each pixel enough times to fill the image. Linear performs linear interpolation between the pixels. """ pass def SetMagnifyImageMethodToLinear(self): # real signature unknown; restored from __doc__ """ SetMagnifyImageMethodToLinear(self) -> None C++: void SetMagnifyImageMethodToLinear() """ pass def SetMagnifyImageMethodToNearest(self): # real signature unknown; restored from __doc__ """ SetMagnifyImageMethodToNearest(self) -> None C++: void SetMagnifyImageMethodToNearest() """ pass def SetMagnifyImages(self, _arg): # real signature unknown; restored from __doc__ """ SetMagnifyImages(self, _arg:int) -> None C++: virtual void SetMagnifyImages(int _arg) If on (the default), when the ImageReductionFactor is greater than 1 and WriteBackImages is on, the image will be magnified to fill the entire render window. """ pass def SetMaxImageReductionFactor(self, _arg): # real signature unknown; restored from __doc__ """ SetMaxImageReductionFactor(self, _arg:float) -> None C++: virtual void SetMaxImageReductionFactor(double _arg) """ pass def SetParallelRendering(self, _arg): # real signature unknown; restored from __doc__ """ SetParallelRendering(self, _arg:int) -> None C++: virtual void SetParallelRendering(int _arg) Turns on/off parallel rendering. When on (the default) the object responds to render events of the attached window, propagates the render event to other processors, and otherwise enables the parallel rendering process. """ pass def SetRenderEventPropagation(self, _arg): # real signature unknown; restored from __doc__ """ SetRenderEventPropagation(self, _arg:int) -> None C++: virtual void SetRenderEventPropagation(int _arg) Turns on/off render event propagation. When on (the default) and ParallelRendering is on, process 0 will send an RMI call to all remote processes to perform a synchronized render. When off, render must be manually called on each process. """ pass def SetRenderWindow(self, renWin): # real signature unknown; restored from __doc__ """ SetRenderWindow(self, renWin:vtkRenderWindow) -> None C++: virtual void SetRenderWindow(vtkRenderWindow *renWin) """ pass def SetSynchronizeTileProperties(self, _arg): # real signature unknown; restored from __doc__ """ SetSynchronizeTileProperties(self, _arg:int) -> None C++: virtual void SetSynchronizeTileProperties(int _arg) When set the render manager will synchronize the TileViewport and TileScale properties. This may not be desirable in cases where there's some other mechanism to set the tile dimensions eg. Tile displays. """ pass def SetSyncRenderWindowRenderers(self, _arg): # real signature unknown; restored from __doc__ """ SetSyncRenderWindowRenderers(self, _arg:int) -> None C++: virtual void SetSyncRenderWindowRenderers(int _arg) """ pass def SetUseBackBuffer(self, _arg): # real signature unknown; restored from __doc__ """ SetUseBackBuffer(self, _arg:int) -> None C++: virtual void SetUseBackBuffer(int _arg) The default is to allow the use of the back buffer for compositing. If set to false, this will prevent to manager from swapping buffers. This allows something else (for instance VisibleCellSelection) to control front/back buffer swapping. """ pass def SetUseCompositing(self, _arg): # real signature unknown; restored from __doc__ """ SetUseCompositing(self, _arg:int) -> None C++: virtual void SetUseCompositing(int _arg) This is used for tiled display rendering. When data has been duplicated on all processes, then we do not need to compositing. Cameras and renders are still propagated though. """ pass def SetUseRGBA(self, _arg): # real signature unknown; restored from __doc__ """ SetUseRGBA(self, _arg:int) -> None C++: virtual void SetUseRGBA(int _arg) Get/Set if all Images must use RGBA instead of RGB. By default, this flag is on. """ pass def SetWriteBackImages(self, _arg): # real signature unknown; restored from __doc__ """ SetWriteBackImages(self, _arg:int) -> None C++: virtual void SetWriteBackImages(int _arg) If on (the default), the result of any image space manipulations are written back to the render window frame buffer. If off, the image stored in the frame buffer may not be correct. Either way, the correct frame buffer images may be read with vtkParallelRenderManager::GetPixelData. Turning WriteBackImages off may result in a speedup if the render window is not visible to the user and images are read back for further processing or transit. """ pass def StartInteractor(self): # real signature unknown; restored from __doc__ """ StartInteractor(self) -> None C++: virtual void StartInteractor() Initializes the RMIs and then, if on root node, starts the interactor on the attached render window. Otherwise, starts processing RMIs. When the interactor returns, it breaks the RMI listening on all other processors. """ pass def StartRender(self): # real signature unknown; restored from __doc__ """ StartRender(self) -> None C++: virtual void StartRender() Callbacks that initialize and finish rendering and other tasks. """ pass def StartServices(self): # real signature unknown; restored from __doc__ """ StartServices(self) -> None C++: virtual void StartServices() If on node other than root, starts serving RMI requests for parallel renders. """ pass def StopServices(self): # real signature unknown; restored from __doc__ """ StopServices(self) -> None C++: virtual void StopServices() If on root node, stops the RMI processing on all service nodes. """ pass def SynchronizeTilePropertiesOff(self): # real signature unknown; restored from __doc__ """ SynchronizeTilePropertiesOff(self) -> None C++: virtual void SynchronizeTilePropertiesOff() """ pass def SynchronizeTilePropertiesOn(self): # real signature unknown; restored from __doc__ """ SynchronizeTilePropertiesOn(self) -> None C++: virtual void SynchronizeTilePropertiesOn() """ pass def SyncRenderWindowRenderersOff(self): # real signature unknown; restored from __doc__ """ SyncRenderWindowRenderersOff(self) -> None C++: virtual void SyncRenderWindowRenderersOff() """ pass def SyncRenderWindowRenderersOn(self): # real signature unknown; restored from __doc__ """ SyncRenderWindowRenderersOn(self) -> None C++: virtual void SyncRenderWindowRenderersOn() """ pass def TileWindows(self, xsize, ysize, nColumns): # real signature unknown; restored from __doc__ """ TileWindows(self, xsize:int, ysize:int, nColumns:int) -> None C++: void TileWindows(int xsize, int ysize, int nColumns) Given the x and y size of the render windows, reposition them in a tile of n columns. """ pass def UseBackBufferOff(self): # real signature unknown; restored from __doc__ """ UseBackBufferOff(self) -> None C++: virtual void UseBackBufferOff() """ pass def UseBackBufferOn(self): # real signature unknown; restored from __doc__ """ UseBackBufferOn(self) -> None C++: virtual void UseBackBufferOn() """ pass def UseCompositingOff(self): # real signature unknown; restored from __doc__ """ UseCompositingOff(self) -> None C++: virtual void UseCompositingOff() """ pass def UseCompositingOn(self): # real signature unknown; restored from __doc__ """ UseCompositingOn(self) -> None C++: virtual void UseCompositingOn() """ pass def WriteBackImagesOff(self): # real signature unknown; restored from __doc__ """ WriteBackImagesOff(self) -> None C++: virtual void WriteBackImagesOff() """ pass def WriteBackImagesOn(self): # real signature unknown; restored from __doc__ """ WriteBackImagesOn(self) -> None C++: virtual void WriteBackImagesOn() """ pass def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" BOUNDS_TAG = 23543 COMPUTE_VISIBLE_PROP_BOUNDS_RMI_TAG = 54636 LIGHT_INFO_TAG = 87838 LINEAR = 1 NEAREST = 0 RENDER_RMI_TAG = 34532 REN_ID_TAG = 58794 REN_INFO_TAG = 87836 Tags = None # (!) real value is "" WIN_INFO_TAG = 87834 __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkParallelRenderManager', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'MakeRenderWindow': , 'MakeRenderer': , 'GetRenderWindow': , 'SetRenderWindow': , 'GetController': , 'SetController': , 'InitializePieces': , 'InitializeOffScreen': , 'StartInteractor': , 'StartServices': , 'StopServices': , 'StartRender': , 'EndRender': , 'SatelliteStartRender': , 'SatelliteEndRender': , 'RenderRMI': , 'ResetCamera': , 'ResetCameraClippingRange': , 'ComputeVisiblePropBoundsRMI': , 'InitializeRMIs': , 'ResetAllCameras': , 'ComputeVisiblePropBounds': , 'SetParallelRendering': , 'GetParallelRendering': , 'ParallelRenderingOn': , 'ParallelRenderingOff': , 'SetRenderEventPropagation': , 'GetRenderEventPropagation': , 'RenderEventPropagationOn': , 'RenderEventPropagationOff': , 'SetDefaultRenderEventPropagation': , 'GetDefaultRenderEventPropagation': , 'SetUseCompositing': , 'GetUseCompositing': , 'UseCompositingOn': , 'UseCompositingOff': , 'SetImageReductionFactor': , 'GetImageReductionFactor': , 'SetMaxImageReductionFactor': , 'GetMaxImageReductionFactor': , 'SetImageReductionFactorForUpdateRate': , 'SetAutoImageReductionFactor': , 'GetAutoImageReductionFactor': , 'AutoImageReductionFactorOn': , 'AutoImageReductionFactorOff': , 'GetRenderTime': , 'GetImageProcessingTime': , 'GetSyncRenderWindowRenderers': , 'SetSyncRenderWindowRenderers': , 'SyncRenderWindowRenderersOn': , 'SyncRenderWindowRenderersOff': , 'AddRenderer': , 'RemoveRenderer': , 'RemoveAllRenderers': , 'SetWriteBackImages': , 'GetWriteBackImages': , 'WriteBackImagesOn': , 'WriteBackImagesOff': , 'SetMagnifyImages': , 'GetMagnifyImages': , 'MagnifyImagesOn': , 'MagnifyImagesOff': , 'SetMagnifyImageMethod': , 'GetMagnifyImageMethod': , 'SetMagnifyImageMethodToNearest': , 'SetMagnifyImageMethodToLinear': , 'MagnifyImage': , 'MagnifyImageNearest': , 'MagnifyImageLinear': , 'GetPixelData': , 'GetReducedPixelData': , 'GetFullImageSize': , 'GetReducedImageSize': , 'TileWindows': , 'SetUseRGBA': , 'GetUseRGBA': , 'SetForceRenderWindowSize': , 'GetForceRenderWindowSize': , 'SetForcedRenderWindowSize': , 'GetForcedRenderWindowSize': , 'CheckForAbortRender': , 'CheckForAbortComposite': , 'SetUseBackBuffer': , 'GetUseBackBuffer': , 'UseBackBufferOn': , 'UseBackBufferOff': , 'SetSynchronizeTileProperties': , 'GetSynchronizeTileProperties': , 'SynchronizeTilePropertiesOn': , 'SynchronizeTilePropertiesOff': , 'GenericStartRenderCallback': , 'GenericEndRenderCallback': , 'Tags': , 'NEAREST': 0, 'LINEAR': 1, 'RENDER_RMI_TAG': 34532, 'COMPUTE_VISIBLE_PROP_BOUNDS_RMI_TAG': 54636, 'WIN_INFO_TAG': 87834, 'REN_INFO_TAG': 87836, 'LIGHT_INFO_TAG': 87838, 'REN_ID_TAG': 58794, 'BOUNDS_TAG': 23543, '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkParallelRenderManager - An object to control parallel rendering.\\n\\nSuperclass: vtkObject\\n\\nvtkParallelRenderManager operates in multiple processes. It provides\\nproper renderers and render windows for performing the parallel\\nrendering correctly. It can also attach itself to render windows and\\npropagate rendering events and camera views.\\n\\n@attention Many parallel rendering schemes do not correctly handle\\ntransparency. Unless otherwise documented, assume a sub class does\\nnot.\\n\\n@todo Synchronization/barrier primitives.\\n\\n@todo Query ranges of scalar values of objects in addition to the\\nboundary in three-space\\n\\n'})" __vtkname__ = 'vtkParallelRenderManager' class vtkCompositeRenderManager(vtkParallelRenderManager): """ vtkCompositeRenderManager - An object to control sort-last parallel rendering. Superclass: vtkParallelRenderManager vtkCompositeRenderManager is a subclass of vtkParallelRenderManager that uses compositing to do parallel rendering. This class has replaced vtkCompositeManager. """ def GetCompositer(self): # real signature unknown; restored from __doc__ """ GetCompositer(self) -> vtkCompositer C++: virtual vtkCompositer *GetCompositer() """ return vtkCompositer def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkCompositeRenderManager C++: vtkCompositeRenderManager *NewInstance() """ return vtkCompositeRenderManager def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkCompositeRenderManager C++: static vtkCompositeRenderManager *SafeDownCast( vtkObjectBase *o) """ return vtkCompositeRenderManager def SetCompositer(self, c): # real signature unknown; restored from __doc__ """ SetCompositer(self, c:vtkCompositer) -> None C++: void SetCompositer(vtkCompositer *c) Set/Get the composite algorithm. """ pass def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkCompositeRenderManager', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'SetCompositer': , 'GetCompositer': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkCompositeRenderManager - An object to control sort-last parallel\\nrendering.\\n\\nSuperclass: vtkParallelRenderManager\\n\\nvtkCompositeRenderManager is a subclass of vtkParallelRenderManager\\nthat uses compositing to do parallel rendering. This class has\\nreplaced vtkCompositeManager.\\n\\n'})" __vtkname__ = 'vtkCompositeRenderManager' class vtkCompositeRGBAPass(__vtkmodules_vtkRenderingCore.vtkRenderPass): """ vtkCompositeRGBAPass - Blend RGBA buffers of processes. Superclass: vtkRenderPass Blend the RGBA buffers of satellite processes over the root process RGBA buffer. The RGBA buffer of the satellite processes are not changed. This pass requires a OpenGL context that supports texture objects (TO), and pixel buffer objects (PBO). If not, it will emit an error message and will render its delegate and return. @sa vtkRenderPass """ def GetController(self): # real signature unknown; restored from __doc__ """ GetController(self) -> vtkMultiProcessController C++: virtual vtkMultiProcessController *GetController() Controller If it is NULL, nothing will be rendered and a warning will be emitted. Initial value is a NULL pointer. """ pass def GetKdtree(self): # real signature unknown; restored from __doc__ """ GetKdtree(self) -> vtkPKdTree C++: virtual vtkPKdTree *GetKdtree() kd tree that gives processes ordering. Initial value is a NULL pointer. """ pass def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsSupported(self, context): # real signature unknown; restored from __doc__ """ IsSupported(self, context:vtkOpenGLRenderWindow) -> bool C++: bool IsSupported(vtkOpenGLRenderWindow *context) Is the pass supported by the OpenGL context? """ return False def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkCompositeRGBAPass C++: vtkCompositeRGBAPass *NewInstance() """ return vtkCompositeRGBAPass def ReleaseGraphicsResources(self, w): # real signature unknown; restored from __doc__ """ ReleaseGraphicsResources(self, w:vtkWindow) -> None C++: void ReleaseGraphicsResources(vtkWindow *w) override; Release graphics resources and ask components to release their own resources. \pre w_exists: w!=0 """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkCompositeRGBAPass C++: static vtkCompositeRGBAPass *SafeDownCast(vtkObjectBase *o) """ return vtkCompositeRGBAPass def SetController(self, controller): # real signature unknown; restored from __doc__ """ SetController(self, controller:vtkMultiProcessController) -> None C++: virtual void SetController( vtkMultiProcessController *controller) """ pass def SetKdtree(self, kdtree): # real signature unknown; restored from __doc__ """ SetKdtree(self, kdtree:vtkPKdTree) -> None C++: virtual void SetKdtree(vtkPKdTree *kdtree) """ pass def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkCompositeRGBAPass', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'ReleaseGraphicsResources': , 'GetController': , 'SetController': , 'GetKdtree': , 'SetKdtree': , 'IsSupported': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkCompositeRGBAPass - Blend RGBA buffers of processes.\\n\\nSuperclass: vtkRenderPass\\n\\nBlend the RGBA buffers of satellite processes over the root process\\nRGBA buffer. The RGBA buffer of the satellite processes are not\\nchanged.\\n\\nThis pass requires a OpenGL context that supports texture objects\\n(TO), and pixel buffer objects (PBO). If not, it will emit an error\\nmessage and will render its delegate and return.\\n\\n@sa\\nvtkRenderPass\\n\\n'})" __vtkname__ = 'vtkCompositeRGBAPass' class vtkCompositeZPass(__vtkmodules_vtkRenderingCore.vtkRenderPass): """ vtkCompositeZPass - Merge depth buffers of processes. Superclass: vtkRenderPass Merge the depth buffers of satellite processes into the root process depth buffer. It assumes that all the depth buffers have the same number of bits. The depth buffer of the satellite processes are not changed. This pass requires a OpenGL context that supports texture objects (TO), and pixel buffer objects (PBO). If not, it will emit an error message and will render its delegate and return. @sa vtkRenderPass """ def GetController(self): # real signature unknown; restored from __doc__ """ GetController(self) -> vtkMultiProcessController C++: virtual vtkMultiProcessController *GetController() Controller If it is NULL, nothing will be rendered and a warning will be emitted. Initial value is a NULL pointer. """ pass def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsSupported(self, context): # real signature unknown; restored from __doc__ """ IsSupported(self, context:vtkOpenGLRenderWindow) -> bool C++: bool IsSupported(vtkOpenGLRenderWindow *context) Is the pass supported by the OpenGL context? """ return False def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkCompositeZPass C++: vtkCompositeZPass *NewInstance() """ return vtkCompositeZPass def ReleaseGraphicsResources(self, w): # real signature unknown; restored from __doc__ """ ReleaseGraphicsResources(self, w:vtkWindow) -> None C++: void ReleaseGraphicsResources(vtkWindow *w) override; Release graphics resources and ask components to release their own resources. \pre w_exists: w!=0 """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkCompositeZPass C++: static vtkCompositeZPass *SafeDownCast(vtkObjectBase *o) """ return vtkCompositeZPass def SetController(self, controller): # real signature unknown; restored from __doc__ """ SetController(self, controller:vtkMultiProcessController) -> None C++: virtual void SetController( vtkMultiProcessController *controller) """ pass def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkCompositeZPass', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'ReleaseGraphicsResources': , 'GetController': , 'SetController': , 'IsSupported': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkCompositeZPass - Merge depth buffers of processes.\\n\\nSuperclass: vtkRenderPass\\n\\nMerge the depth buffers of satellite processes into the root process\\ndepth buffer. It assumes that all the depth buffers have the same\\nnumber of bits. The depth buffer of the satellite processes are not\\nchanged.\\n\\nThis pass requires a OpenGL context that supports texture objects\\n(TO), and pixel buffer objects (PBO). If not, it will emit an error\\nmessage and will render its delegate and return.\\n\\n@sa\\nvtkRenderPass\\n\\n'})" __vtkname__ = 'vtkCompositeZPass' class vtkCompressCompositer(vtkCompositer): """ vtkCompressCompositer - Implements compressed tree based compositing. Superclass: vtkCompositer vtkCompressCompositer operates in multiple processes. Each compositer has a render window. They use vtkMultiProcessController to communicate the color and depth buffer to process 0's render window. It will not handle transparency. Compositing is run length encoding of background pixels. SECTION See Also vtkCompositeManager. """ def CompositeBuffer(self, pBuf, zBuf, pTmp, zTmp): # real signature unknown; restored from __doc__ """ CompositeBuffer(self, pBuf:vtkDataArray, zBuf:vtkFloatArray, pTmp:vtkDataArray, zTmp:vtkFloatArray) -> None C++: void CompositeBuffer(vtkDataArray *pBuf, vtkFloatArray *zBuf, vtkDataArray *pTmp, vtkFloatArray *zTmp) override; This method gets called on every process. The final image gets put into pBuf and zBuf. """ pass def CompositeImagePair(self, localZ, localP, remoteZ, remoteP, outZ, outP): # real signature unknown; restored from __doc__ """ CompositeImagePair(localZ:vtkFloatArray, localP:vtkDataArray, remoteZ:vtkFloatArray, remoteP:vtkDataArray, outZ:vtkFloatArray, outP:vtkDataArray) -> None C++: static void CompositeImagePair(vtkFloatArray *localZ, vtkDataArray *localP, vtkFloatArray *remoteZ, vtkDataArray *remoteP, vtkFloatArray *outZ, vtkDataArray *outP) """ pass def Compress(self, zIn, pIn, zOut, pOut): # real signature unknown; restored from __doc__ """ Compress(zIn:vtkFloatArray, pIn:vtkDataArray, zOut:vtkFloatArray, pOut:vtkDataArray) -> None C++: static void Compress(vtkFloatArray *zIn, vtkDataArray *pIn, vtkFloatArray *zOut, vtkDataArray *pOut) I am granting access to these methods and making them static So I can create a TileDisplayCompositer which uses compression. """ pass def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkCompressCompositer C++: vtkCompressCompositer *NewInstance() """ return vtkCompressCompositer def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkCompressCompositer C++: static vtkCompressCompositer *SafeDownCast(vtkObjectBase *o) """ return vtkCompressCompositer def Uncompress(self, zIn, pIn, zOut, pOut, lengthOut): # real signature unknown; restored from __doc__ """ Uncompress(zIn:vtkFloatArray, pIn:vtkDataArray, zOut:vtkFloatArray, pOut:vtkDataArray, lengthOut:int) -> None C++: static void Uncompress(vtkFloatArray *zIn, vtkDataArray *pIn, vtkFloatArray *zOut, vtkDataArray *pOut, int lengthOut) """ pass def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is 'mappingproxy({\'__vtkname__\': \'vtkCompressCompositer\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'CompositeBuffer\': , \'Compress\': , \'Uncompress\': , \'CompositeImagePair\': , \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': "vtkCompressCompositer - Implements compressed tree based compositing.\\n\\nSuperclass: vtkCompositer\\n\\nvtkCompressCompositer operates in multiple processes. Each\\ncompositer has a render window. They use vtkMultiProcessController\\nto communicate the color and depth buffer to process 0\'s render\\nwindow. It will not handle transparency. Compositing is run length\\nencoding of background pixels.\\n\\nSECTION See Also vtkCompositeManager.\\n\\n"})' __vtkname__ = 'vtkCompressCompositer' class vtkImageRenderManager(vtkParallelRenderManager): """ vtkImageRenderManager - An object to control sort-first parallel rendering. Superclass: vtkParallelRenderManager vtkImageRenderManager is a subclass of vtkParallelRenderManager that uses RGBA compositing (blending) to do parallel rendering. This is the exact opposite of vtkCompositeRenderManager. It actually does nothing special. It relies on the rendering pipeline to be initialized with a vtkCompositeRGBAPass. Compositing makes sense only for renderers in layer 0. @sa vtkCompositeRGBAPass """ def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkImageRenderManager C++: vtkImageRenderManager *NewInstance() """ return vtkImageRenderManager def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkImageRenderManager C++: static vtkImageRenderManager *SafeDownCast(vtkObjectBase *o) """ return vtkImageRenderManager def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkImageRenderManager', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkImageRenderManager - An object to control sort-first parallel\\nrendering.\\n\\nSuperclass: vtkParallelRenderManager\\n\\nvtkImageRenderManager is a subclass of vtkParallelRenderManager that\\nuses RGBA compositing (blending) to do parallel rendering. This is\\nthe exact opposite of vtkCompositeRenderManager. It actually does\\nnothing special. It relies on the rendering pipeline to be\\ninitialized with a vtkCompositeRGBAPass. Compositing makes sense only\\nfor renderers in layer 0.\\n@sa\\nvtkCompositeRGBAPass\\n\\n'})" __vtkname__ = 'vtkImageRenderManager' class vtkPHardwareSelector(__vtkmodules_vtkRenderingOpenGL2.vtkOpenGLHardwareSelector): """ vtkPHardwareSelector - vtkHardwareSelector useful for parallel rendering. Superclass: vtkOpenGLHardwareSelector vtkPHardwareSelector is a vtkHardwareSelector that is parallel aware. It relies on the fact that the application is going to use some other mechanism to ensure that renders are synchronized among windows on all processes. The synchronization happens from the root node. When the root node renders, all processes render. Only vtkPHardwareSelector instance on the root node triggers the renders. All other processes, simply listen to the StartEvent fired and beginning of the render to ensure that vtkHardwareSelector's CurrentPass is updated appropriately. """ def CaptureBuffers(self): # real signature unknown; restored from __doc__ """ CaptureBuffers(self) -> bool C++: bool CaptureBuffers() override; Overridden to only allow the superclass implementation on the root node. On all other processes, the updating the internal state of the vtkHardwareSelector as the capturing of buffers progresses is done as a slave to the master render. """ return False def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetProcessIsRoot(self): # real signature unknown; restored from __doc__ """ GetProcessIsRoot(self) -> bool C++: virtual bool GetProcessIsRoot() """ return False def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkPHardwareSelector C++: vtkPHardwareSelector *NewInstance() """ return vtkPHardwareSelector def ProcessIsRootOff(self): # real signature unknown; restored from __doc__ """ ProcessIsRootOff(self) -> None C++: virtual void ProcessIsRootOff() """ pass def ProcessIsRootOn(self): # real signature unknown; restored from __doc__ """ ProcessIsRootOn(self) -> None C++: virtual void ProcessIsRootOn() """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkPHardwareSelector C++: static vtkPHardwareSelector *SafeDownCast(vtkObjectBase *o) """ return vtkPHardwareSelector def SetProcessIsRoot(self, _arg): # real signature unknown; restored from __doc__ """ SetProcessIsRoot(self, _arg:bool) -> None C++: virtual void SetProcessIsRoot(bool _arg) Set/Get the is the root process. The root processes is the only processes which has the composited result and hence the only processes that capture buffers and builds selected list ids. """ pass def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is 'mappingproxy({\'__vtkname__\': \'vtkPHardwareSelector\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'SetProcessIsRoot\': , \'GetProcessIsRoot\': , \'ProcessIsRootOn\': , \'ProcessIsRootOff\': , \'CaptureBuffers\': , \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': "vtkPHardwareSelector - vtkHardwareSelector useful for parallel\\nrendering.\\n\\nSuperclass: vtkOpenGLHardwareSelector\\n\\nvtkPHardwareSelector is a vtkHardwareSelector that is parallel aware.\\nIt relies on the fact that the application is going to use some other\\nmechanism to ensure that renders are synchronized among windows on\\nall processes. The synchronization happens from the root node. When\\nthe root node renders, all processes render. Only\\nvtkPHardwareSelector instance on the root node triggers the renders.\\nAll other processes, simply listen to the StartEvent fired and\\nbeginning of the render to ensure that vtkHardwareSelector\'s\\nCurrentPass is updated appropriately.\\n\\n"})' __vtkname__ = 'vtkPHardwareSelector' class vtkSynchronizedRenderWindows(__vtkmodules_vtkCommonCore.vtkObject): """ vtkSynchronizedRenderWindows - synchronizes render windows across processes. Superclass: vtkObject vtkSynchronizedRenderWindows is used to synchronize render windows across processes for parallel rendering. """ def AbortRender(self): # real signature unknown; restored from __doc__ """ AbortRender(self) -> None C++: virtual void AbortRender() This method call be called while a render is in progress to abort the rendering. It should be called on the root node (or client). """ pass def GetIdentifier(self): # real signature unknown; restored from __doc__ """ GetIdentifier(self) -> int C++: virtual unsigned int GetIdentifier() """ return 0 def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetParallelController(self): # real signature unknown; restored from __doc__ """ GetParallelController(self) -> vtkMultiProcessController C++: virtual vtkMultiProcessController *GetParallelController() """ pass def GetParallelRendering(self): # real signature unknown; restored from __doc__ """ GetParallelRendering(self) -> bool C++: virtual bool GetParallelRendering() """ return False def GetRenderEventPropagation(self): # real signature unknown; restored from __doc__ """ GetRenderEventPropagation(self) -> bool C++: virtual bool GetRenderEventPropagation() """ return False def GetRenderWindow(self): # real signature unknown; restored from __doc__ """ GetRenderWindow(self) -> vtkRenderWindow C++: virtual vtkRenderWindow *GetRenderWindow() """ pass def GetRootProcessId(self): # real signature unknown; restored from __doc__ """ GetRootProcessId(self) -> int C++: virtual int GetRootProcessId() """ return 0 def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkSynchronizedRenderWindows C++: vtkSynchronizedRenderWindows *NewInstance() """ return vtkSynchronizedRenderWindows def ParallelRenderingOff(self): # real signature unknown; restored from __doc__ """ ParallelRenderingOff(self) -> None C++: virtual void ParallelRenderingOff() """ pass def ParallelRenderingOn(self): # real signature unknown; restored from __doc__ """ ParallelRenderingOn(self) -> None C++: virtual void ParallelRenderingOn() """ pass def RenderEventPropagationOff(self): # real signature unknown; restored from __doc__ """ RenderEventPropagationOff(self) -> None C++: virtual void RenderEventPropagationOff() """ pass def RenderEventPropagationOn(self): # real signature unknown; restored from __doc__ """ RenderEventPropagationOn(self) -> None C++: virtual void RenderEventPropagationOn() """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkSynchronizedRenderWindows C++: static vtkSynchronizedRenderWindows *SafeDownCast( vtkObjectBase *o) """ return vtkSynchronizedRenderWindows def SetIdentifier(self, id): # real signature unknown; restored from __doc__ """ SetIdentifier(self, id:int) -> None C++: void SetIdentifier(unsigned int id) It's acceptable to have multiple instances on vtkSynchronizedRenderWindows on each processes to synchronize different render windows. In that case there's no way to each of the vtkSynchronizedRenderWindows instance to know how they correspond across processes. To enable that identification, a vtkSynchronizedRenderWindows can be assigned a unique id. All vtkSynchronizedRenderWindows across different processes that have the same id are "linked" together for synchronization. It's critical that the id is set before any rendering happens. """ pass def SetParallelController(self, __a): # real signature unknown; restored from __doc__ """ SetParallelController(self, __a:vtkMultiProcessController) -> None C++: void SetParallelController(vtkMultiProcessController *) Set the parallel message communicator. This is used to communicate among processes. """ pass def SetParallelRendering(self, _arg): # real signature unknown; restored from __doc__ """ SetParallelRendering(self, _arg:bool) -> None C++: virtual void SetParallelRendering(bool _arg) Enable/Disable parallel rendering. Unless ParallelRendering is ON, no synchronization of vtkRenderWindow::Render() calls between processes happens. ON by default. """ pass def SetRenderEventPropagation(self, _arg): # real signature unknown; restored from __doc__ """ SetRenderEventPropagation(self, _arg:bool) -> None C++: virtual void SetRenderEventPropagation(bool _arg) """ pass def SetRenderWindow(self, __a): # real signature unknown; restored from __doc__ """ SetRenderWindow(self, __a:vtkRenderWindow) -> None C++: void SetRenderWindow(vtkRenderWindow *) Set the render window to be synchronized by this vtkSynchronizedRenderWindows instance. A vtkSynchronizedRenderWindows can be used to synchronize exactly 1 vtkRenderWindow on each process. """ pass def SetRootProcessId(self, _arg): # real signature unknown; restored from __doc__ """ SetRootProcessId(self, _arg:int) -> None C++: virtual void SetRootProcessId(int _arg) Get/Set the root-process id. This is required when the ParallelController is a vtkSocketController. Set to 0 by default (which will not work when using a vtkSocketController but will work for vtkMPIController). """ pass def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" SYNC_RENDER_TAG = 15001 __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkSynchronizedRenderWindows', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'SetRenderWindow': , 'GetRenderWindow': , 'SetParallelController': , 'GetParallelController': , 'SetIdentifier': , 'GetIdentifier': , 'SetParallelRendering': , 'GetParallelRendering': , 'ParallelRenderingOn': , 'ParallelRenderingOff': , 'SetRenderEventPropagation': , 'GetRenderEventPropagation': , 'RenderEventPropagationOn': , 'RenderEventPropagationOff': , 'AbortRender': , 'SetRootProcessId': , 'GetRootProcessId': , 'SYNC_RENDER_TAG': 15001, '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkSynchronizedRenderWindows - synchronizes render windows across\\nprocesses.\\n\\nSuperclass: vtkObject\\n\\nvtkSynchronizedRenderWindows is used to synchronize render windows\\nacross processes for parallel rendering.\\n\\n'})" __vtkname__ = 'vtkSynchronizedRenderWindows' class vtkTreeCompositer(vtkCompositer): """ vtkTreeCompositer - Implements tree based compositing. Superclass: vtkCompositer vtkTreeCompositer operates in multiple processes. Each compositer has a render window. They use a vtkMultiProcessController to communicate the color and depth buffer to process 0's render window. It will not handle transparency well. @sa vtkCompositeManager """ def CompositeBuffer(self, pBuf, zBuf, pTmp, zTmp): # real signature unknown; restored from __doc__ """ CompositeBuffer(self, pBuf:vtkDataArray, zBuf:vtkFloatArray, pTmp:vtkDataArray, zTmp:vtkFloatArray) -> None C++: void CompositeBuffer(vtkDataArray *pBuf, vtkFloatArray *zBuf, vtkDataArray *pTmp, vtkFloatArray *zTmp) override; This method gets called on every process. The final image gets put into pBuf and zBuf. """ pass def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkTreeCompositer C++: vtkTreeCompositer *NewInstance() """ return vtkTreeCompositer def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkTreeCompositer C++: static vtkTreeCompositer *SafeDownCast(vtkObjectBase *o) """ return vtkTreeCompositer def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is 'mappingproxy({\'__vtkname__\': \'vtkTreeCompositer\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'CompositeBuffer\': , \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': "vtkTreeCompositer - Implements tree based compositing.\\n\\nSuperclass: vtkCompositer\\n\\nvtkTreeCompositer operates in multiple processes. Each compositer\\nhas a render window. They use a vtkMultiProcessController to\\ncommunicate the color and depth buffer to process 0\'s render window.\\nIt will not handle transparency well.\\n\\n@sa\\nvtkCompositeManager\\n\\n"})' __vtkname__ = 'vtkTreeCompositer' # variables with complex values __loader__ = None # (!) real value is '<_frozen_importlib_external.ExtensionFileLoader object at 0x0000012366F9BC50>' __spec__ = None # (!) real value is "ModuleSpec(name='vtkmodules.vtkRenderingParallel', loader=<_frozen_importlib_external.ExtensionFileLoader object at 0x0000012366F9BC50>, origin='C:\\\\Users\\\\xukai\\\\Downloads\\\\??2\\\\venv\\\\Lib\\\\site-packages\\\\vtkmodules\\\\vtkRenderingParallel.cp311-win_amd64.pyd')"