# encoding: utf-8 # module vtkmodules.vtkRenderingVolumeOpenGL2 # from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\vtkmodules\vtkRenderingVolumeOpenGL2.cp311-win_amd64.pyd # by generator 1.147 # no doc # imports import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore import vtkmodules.vtkRenderingVolume as __vtkmodules_vtkRenderingVolume # no functions # classes class vtkMultiBlockUnstructuredGridVolumeMapper(__vtkmodules_vtkRenderingVolume.vtkUnstructuredGridVolumeMapper): """ vtkMultiBlockUnstructuredGridVolumeMapper - Mapper to render volumes defined as vtkMultiBlockDataSet. Superclass: vtkUnstructuredGridVolumeMapper """ def GetBounds(self): # real signature unknown; restored from __doc__ """ GetBounds(self) -> (float, float, float, float, float, float) C++: double *GetBounds() override; GetBounds(self, bounds:[float, float, float, float, float, float]) -> None C++: void GetBounds(double bounds[6]) override; API Superclass \sa vtkAbstractVolumeMapper """ 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 GetUseFloatingPointFrameBuffer(self): # real signature unknown; restored from __doc__ """ GetUseFloatingPointFrameBuffer(self) -> bool C++: virtual bool GetUseFloatingPointFrameBuffer() """ 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) -> vtkMultiBlockUnstructuredGridVolumeMapper C++: vtkMultiBlockUnstructuredGridVolumeMapper *NewInstance() """ return vtkMultiBlockUnstructuredGridVolumeMapper def ReleaseGraphicsResources(self, window): # real signature unknown; restored from __doc__ """ ReleaseGraphicsResources(self, window:vtkWindow) -> None C++: void ReleaseGraphicsResources(vtkWindow *window) override; \warning Internal method - not intended for general use, do NOT use this method outside of the rendering process. """ pass def Render(self, ren, vol): # real signature unknown; restored from __doc__ """ Render(self, ren:vtkRenderer, vol:vtkVolume) -> None C++: void Render(vtkRenderer *ren, vtkVolume *vol) override; Render the current dataset. \warning Internal method - not intended for general use, do NOT use this method outside of the rendering process. """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkMultiBlockUnstructuredGridVolumeMapper C++: static vtkMultiBlockUnstructuredGridVolumeMapper *SafeDownCast( vtkObjectBase *o) """ return vtkMultiBlockUnstructuredGridVolumeMapper def SelectScalarArray(self, arrayNum): # real signature unknown; restored from __doc__ """ SelectScalarArray(self, arrayNum:int) -> None C++: void SelectScalarArray(int arrayNum) override; SelectScalarArray(self, arrayName:str) -> None C++: void SelectScalarArray(char const *arrayName) override; When ScalarMode is set to UsePointFieldData or UseCellFieldData, you can specify which scalar array to use during rendering. The transfer function in the vtkVolumeProperty (attached to the calling vtkVolume) will decide how to convert vectors to colors. """ pass def SetArrayAccessMode(self, accessMode): # real signature unknown; restored from __doc__ """ SetArrayAccessMode(self, accessMode:int) -> None C++: void SetArrayAccessMode(int accessMode) override; """ pass def SetBlendMode(self, mode): # real signature unknown; restored from __doc__ """ SetBlendMode(self, mode:int) -> None C++: void SetBlendMode(int mode) override; blending mode api from vtkUnstructuredGridVolumemapper \sa vtkvolumemapper::setblendmode """ pass def SetScalarMode(self, ScalarMode): # real signature unknown; restored from __doc__ """ SetScalarMode(self, ScalarMode:int) -> None C++: void SetScalarMode(int ScalarMode) override; Control how the mapper works with scalar point data and cell attribute data. By default (ScalarModeToDefault), the mapper will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the mapper to use point data (ScalarModeToUsePointData) or cell data (ScalarModeToUseCellData). You can also choose to get the scalars from an array in point field data (ScalarModeToUsePointFieldData) or cell field data (ScalarModeToUseCellFieldData). If scalars are coming from a field data array, you must call SelectScalarArray. """ pass def SetUseFloatingPointFrameBuffer(self, use): # real signature unknown; restored from __doc__ """ SetUseFloatingPointFrameBuffer(self, use:bool) -> None C++: void SetUseFloatingPointFrameBuffer(bool use) Set/get whether to use floating-point rendering buffers rather than the default. \sa vtkOpenGLProjectedTetrahedraMapper::setusefloatingpointframebu ffer """ 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__': 'vtkMultiBlockUnstructuredGridVolumeMapper', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'GetBounds': , 'SelectScalarArray': , 'SetScalarMode': , 'SetArrayAccessMode': , 'Render': , 'ReleaseGraphicsResources': , 'SetUseFloatingPointFrameBuffer': , 'GetUseFloatingPointFrameBuffer': , 'SetBlendMode': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkMultiBlockUnstructuredGridVolumeMapper - Mapper to render volumes\\ndefined as vtkMultiBlockDataSet.\\n\\nSuperclass: vtkUnstructuredGridVolumeMapper\\n\\n'})" __vtkname__ = 'vtkMultiBlockUnstructuredGridVolumeMapper' class vtkMultiBlockVolumeMapper(__vtkmodules_vtkRenderingVolume.vtkVolumeMapper): """ vtkMultiBlockVolumeMapper - Mapper to render volumes defined as vtkMultiBlockDataSet. Superclass: vtkVolumeMapper vtkMultiBlockVolumeMapper renders vtkMultiBlockDataSet instances containing vtkImageData blocks (all of the blocks are expected to be vtkImageData). Bounds containing the full set of blocks are computed so that vtkRenderer can adjust the clipping planes appropriately. This mapper creates an instance of vtkSmartVolumeMapper per block to which it defers the actual rendering. At render time, blocks (mappers) are sorted back-to-front and each block is rendered independently. It attempts to load all of the blocks at the same time but tries to catch allocation errors in which case it falls back to using a single mapper instance and reloading data for each block. Jittering is used to alleviate seam artifacts at the block edges due to the discontinuous resolution between blocks. Jittering is enabled by default. Jittering is only supported in GPURenderMode. """ def GetBounds(self): # real signature unknown; restored from __doc__ """ GetBounds(self) -> (float, float, float, float, float, float) C++: double *GetBounds() override; GetBounds(self, bounds:[float, float, float, float, float, float]) -> None C++: void GetBounds(double bounds[6]) override; API Superclass \sa vtkAbstractVolumeMapper """ pass def GetGlobalIlluminationReach(self): # real signature unknown; restored from __doc__ """ GetGlobalIlluminationReach(self) -> float C++: virtual float GetGlobalIlluminationReach() """ 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 GetVectorComponent(self): # real signature unknown; restored from __doc__ """ GetVectorComponent(self) -> int C++: virtual int GetVectorComponent() """ return 0 def GetVectorMode(self): # real signature unknown; restored from __doc__ """ GetVectorMode(self) -> int C++: virtual int GetVectorMode() """ return 0 def GetVolumetricScatteringBlending(self): # real signature unknown; restored from __doc__ """ GetVolumetricScatteringBlending(self) -> float C++: virtual float GetVolumetricScatteringBlending() """ return 0.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) -> vtkMultiBlockVolumeMapper C++: vtkMultiBlockVolumeMapper *NewInstance() """ return vtkMultiBlockVolumeMapper def ReleaseGraphicsResources(self, window): # real signature unknown; restored from __doc__ """ ReleaseGraphicsResources(self, window:vtkWindow) -> None C++: void ReleaseGraphicsResources(vtkWindow *window) override; \warning Internal method - not intended for general use, do NOT use this method outside of the rendering process. """ pass def Render(self, ren, vol): # real signature unknown; restored from __doc__ """ Render(self, ren:vtkRenderer, vol:vtkVolume) -> None C++: void Render(vtkRenderer *ren, vtkVolume *vol) override; Render the current dataset. \warning Internal method - not intended for general use, do NOT use this method outside of the rendering process. """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkMultiBlockVolumeMapper C++: static vtkMultiBlockVolumeMapper *SafeDownCast( vtkObjectBase *o) """ return vtkMultiBlockVolumeMapper def SelectScalarArray(self, arrayNum): # real signature unknown; restored from __doc__ """ SelectScalarArray(self, arrayNum:int) -> None C++: void SelectScalarArray(int arrayNum) override; SelectScalarArray(self, arrayName:str) -> None C++: void SelectScalarArray(char const *arrayName) override; When ScalarMode is set to UsePointFieldData or UseCellFieldData, you can specify which scalar array to use during rendering. The transfer function in the vtkVolumeProperty (attached to the calling vtkVolume) will decide how to convert vectors to colors. """ pass def SetArrayAccessMode(self, accessMode): # real signature unknown; restored from __doc__ """ SetArrayAccessMode(self, accessMode:int) -> None C++: void SetArrayAccessMode(int accessMode) override; """ pass def SetBlendMode(self, mode): # real signature unknown; restored from __doc__ """ SetBlendMode(self, mode:int) -> None C++: void SetBlendMode(int mode) override; Blending mode API from vtkVolumeMapper \sa vtkVolumeMapper::SetBlendMode """ pass def SetComputeNormalFromOpacity(self, val): # real signature unknown; restored from __doc__ """ SetComputeNormalFromOpacity(self, val:bool) -> None C++: void SetComputeNormalFromOpacity(bool val) override; ComputeNormalFromOpacity exposed \sa vtkVolumeMapper::SetComputeNormalFromOpacity """ pass def SetCropping(self, mode): # real signature unknown; restored from __doc__ """ SetCropping(self, mode:int) -> None C++: void SetCropping(vtkTypeBool mode) override; Cropping API from vtkVolumeMapper \sa vtkVolumeMapper::SetCropping """ pass def SetCroppingRegionFlags(self, mode): # real signature unknown; restored from __doc__ """ SetCroppingRegionFlags(self, mode:int) -> None C++: void SetCroppingRegionFlags(int mode) override; \sa vtkVolumeMapper::SetCroppingRegionFlags """ pass def SetCroppingRegionPlanes(self, arg1, arg2, arg3, arg4, arg5, arg6): # real signature unknown; restored from __doc__ """ SetCroppingRegionPlanes(self, arg1:float, arg2:float, arg3:float, arg4:float, arg5:float, arg6:float) -> None C++: void SetCroppingRegionPlanes(double arg1, double arg2, double arg3, double arg4, double arg5, double arg6) override; SetCroppingRegionPlanes(self, planes:(float, float, float, float, float, float)) -> None C++: void SetCroppingRegionPlanes(const double *planes) override; \sa vtkVolumeMapper::SetCroppingRegionPlanes """ pass def SetGlobalIlluminationReach(self, val): # real signature unknown; restored from __doc__ """ SetGlobalIlluminationReach(self, val:float) -> None C++: void SetGlobalIlluminationReach(float val) @copydoc vtkSmartVolumeMapper::SetGlobalIlluminationReach(float) """ pass def SetRequestedRenderMode(self, __a): # real signature unknown; restored from __doc__ """ SetRequestedRenderMode(self, __a:int) -> None C++: void SetRequestedRenderMode(int) Forwarded to internal vtkSmartVolumeMappers used. @sa vtkSmartVolumeMapper::SetRequestedRenderMode. """ pass def SetScalarMode(self, ScalarMode): # real signature unknown; restored from __doc__ """ SetScalarMode(self, ScalarMode:int) -> None C++: void SetScalarMode(int ScalarMode) override; Control how the mapper works with scalar point data and cell attribute data. By default (ScalarModeToDefault), the mapper will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the mapper to use point data (ScalarModeToUsePointData) or cell data (ScalarModeToUseCellData). You can also choose to get the scalars from an array in point field data (ScalarModeToUsePointFieldData) or cell field data (ScalarModeToUseCellFieldData). If scalars are coming from a field data array, you must call SelectScalarArray. """ pass def SetTransfer2DYAxisArray(self, a): # real signature unknown; restored from __doc__ """ SetTransfer2DYAxisArray(self, a:str) -> None C++: void SetTransfer2DYAxisArray(const char *a) \sa vtkSmartVolumeMapper::SetTransfer2DYAxisArray """ pass def SetVectorComponent(self, component): # real signature unknown; restored from __doc__ """ SetVectorComponent(self, component:int) -> None C++: void SetVectorComponent(int component) """ pass def SetVectorMode(self, mode): # real signature unknown; restored from __doc__ """ SetVectorMode(self, mode:int) -> None C++: void SetVectorMode(int mode) VectorMode interface exposed from vtkSmartVolumeMapper. """ pass def SetVolumetricScatteringBlending(self, val): # real signature unknown; restored from __doc__ """ SetVolumetricScatteringBlending(self, val:float) -> None C++: void SetVolumetricScatteringBlending(float val) @copydoc vtkSmartVolumeMapper::SetVolumetricScatteringBlending(float) """ 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__': 'vtkMultiBlockVolumeMapper', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'GetBounds': , 'SelectScalarArray': , 'SetScalarMode': , 'SetArrayAccessMode': , 'Render': , 'ReleaseGraphicsResources': , 'SetVectorMode': , 'GetVectorMode': , 'SetVectorComponent': , 'GetVectorComponent': , 'SetBlendMode': , 'SetComputeNormalFromOpacity': , 'SetGlobalIlluminationReach': , 'GetGlobalIlluminationReach': , 'SetVolumetricScatteringBlending': , 'GetVolumetricScatteringBlending': , 'SetCropping': , 'SetCroppingRegionPlanes': , 'SetCroppingRegionFlags': , 'SetRequestedRenderMode': , 'SetTransfer2DYAxisArray': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkMultiBlockVolumeMapper - Mapper to render volumes defined as\\nvtkMultiBlockDataSet.\\n\\nSuperclass: vtkVolumeMapper\\n\\nvtkMultiBlockVolumeMapper renders vtkMultiBlockDataSet instances\\ncontaining vtkImageData blocks (all of the blocks are expected to be\\nvtkImageData). Bounds containing the full set of blocks are computed\\nso that vtkRenderer can adjust the clipping planes appropriately.\\n\\nThis mapper creates an instance of vtkSmartVolumeMapper per block to\\nwhich it defers the actual rendering. At render time, blocks\\n(mappers) are sorted back-to-front and each block is rendered\\nindependently. It attempts to load all of the blocks at the same\\ntime but tries to catch allocation errors in which case it falls back\\nto using a single mapper instance and reloading data for each block.\\n\\nJittering is used to alleviate seam artifacts at the block edges due\\nto the discontinuous resolution between blocks. Jittering is enabled\\nby default. Jittering is only supported in GPURenderMode.\\n\\n'})" __vtkname__ = 'vtkMultiBlockVolumeMapper' class vtkOpenGLGPUVolumeRayCastMapper(__vtkmodules_vtkRenderingVolume.vtkGPUVolumeRayCastMapper): """ vtkOpenGLGPUVolumeRayCastMapper - OpenGL implementation of volume rendering through ray-casting. Superclass: vtkGPUVolumeRayCastMapper @section multi Multiple Inputs * When multiple inputs are rendered simultaneously, it is possible to * composite overlapping areas correctly. Inputs are connected directly to * the mapper and their parameters (transfer functions, transformations, etc.) * are specified through standard vtkVolume instances. These vtkVolume * instances are to be registered in a special vtkProp3D, vtkMultiVolume. * * Structures related to a particular active input are stored in a helper * class (vtkVolumeInputHelper) and helper structures are kept in a * port-referenced map (VolumeInputMap). The order of the inputs in the * map is important as it defines the order in which parameters are * bound to uniform variables (transformation matrices, bias, scale and every * other required rendering parameter). * * A separate code path is used when rendering multiple-inputs in order to * facilitate the co-existance of these two modes (single/multiple), due to * current feature incompatibilities with multiple inputs (e.g. texture-streaming, * cropping, etc.). * * ote A limited set of the mapper features are currently supported for * multiple inputs: * * - Blending * - Composite (front-to-back) * * - Transfer functions (defined separately for per input) * - 1D color * - 1D scalar opacity * - 1D gradient magnitude opacity * - 2D scalar-gradient magnitude * * - Point and cell data * - With the limitation that all of the inputs are assumed to share the same * name/id. * * @sa vtkGPUVolumeRayCastMapper vtkVolumeInputHelper vtkVolumeTexture * vtkMultiVolume * """ def GetColorImage(self, im): # real signature unknown; restored from __doc__ """ GetColorImage(self, im:vtkImageData) -> None C++: void GetColorImage(vtkImageData *im) override; Low level API to export the color texture as vtkImageData in RenderToImage mode. """ pass def GetColorTexture(self): # real signature unknown; restored from __doc__ """ GetColorTexture(self) -> vtkTextureObject C++: vtkTextureObject *GetColorTexture() Low level API to enable access to color texture in RenderToTexture mode. It will return either nullptr if RenderToImage was never turned on or texture captured the last time RenderToImage was on. """ pass def GetCurrentPass(self): # real signature unknown; restored from __doc__ """ GetCurrentPass(self) -> int C++: virtual int GetCurrentPass() Mapper can have multiple passes and internally it will set the state. The state can not be set externally explicitly but can be set indirectly depending on the options set by the user. """ return 0 def GetDepthImage(self, im): # real signature unknown; restored from __doc__ """ GetDepthImage(self, im:vtkImageData) -> None C++: void GetDepthImage(vtkImageData *im) override; Low level API to export the depth texture as vtkImageData in RenderToImage mode. """ pass def GetDepthTexture(self): # real signature unknown; restored from __doc__ """ GetDepthTexture(self) -> vtkTextureObject C++: vtkTextureObject *GetDepthTexture() Low level API to enable access to depth texture in RenderToTexture mode. It will return either nullptr if RenderToImage was never turned on or texture captured the last time RenderToImage was on. """ 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) -> vtkOpenGLGPUVolumeRayCastMapper C++: vtkOpenGLGPUVolumeRayCastMapper *NewInstance() """ return vtkOpenGLGPUVolumeRayCastMapper def PreLoadData(self, ren, vol): # real signature unknown; restored from __doc__ """ PreLoadData(self, ren:vtkRenderer, vol:vtkVolume) -> bool C++: bool PreLoadData(vtkRenderer *ren, vtkVolume *vol) Load the volume texture into GPU memory. Actual loading occurs in vtkVolumeTexture::LoadVolume. The mapper by default loads data lazily (at render time), so it is most commonly not necessary to call this function. This method is only exposed in order to support on-site loading which is useful in cases where the user needs to know a-priori whether loading will succeed or not. """ return False def ReleaseGraphicsResources(self, window): # real signature unknown; restored from __doc__ """ ReleaseGraphicsResources(self, window:vtkWindow) -> None C++: void ReleaseGraphicsResources(vtkWindow *window) override; Delete OpenGL objects. \post done: this->OpenGLObjectsCreated==0 """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkOpenGLGPUVolumeRayCastMapper C++: static vtkOpenGLGPUVolumeRayCastMapper *SafeDownCast( vtkObjectBase *o) """ return vtkOpenGLGPUVolumeRayCastMapper def SetPartitions(self, x, y, z): # real signature unknown; restored from __doc__ """ SetPartitions(self, x:int, y:int, z:int) -> None C++: void SetPartitions(unsigned short x, unsigned short y, unsigned short z) Set a fixed number of partitions in which to split the volume during rendring. This will force by-block rendering without trying to compute an optimum number of partitions. """ pass def SetSharedDepthTexture(self, nt): # real signature unknown; restored from __doc__ """ SetSharedDepthTexture(self, nt:vtkTextureObject) -> None C++: void SetSharedDepthTexture(vtkTextureObject *nt) """ 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.""" DepthPass = 1 Passes = None # (!) real value is "" RenderPass = 0 __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkOpenGLGPUVolumeRayCastMapper', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'GetDepthTexture': , 'GetColorTexture': , 'GetDepthImage': , 'GetColorImage': , 'GetCurrentPass': , 'SetSharedDepthTexture': , 'SetPartitions': , 'PreLoadData': , 'ReleaseGraphicsResources': , 'Passes': , 'RenderPass': 0, 'DepthPass': 1, '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkOpenGLGPUVolumeRayCastMapper - OpenGL implementation of volume\\nrendering through ray-casting.\\n\\nSuperclass: vtkGPUVolumeRayCastMapper\\n\\n@section multi Multiple Inputs\\n\\n* When multiple inputs are rendered simultaneously, it is possible to\\n* composite overlapping areas correctly. Inputs are connected\\n directly to\\n* the mapper and their parameters (transfer functions,\\n transformations, etc.)\\n* are specified through standard vtkVolume instances. These vtkVolume\\n* instances are to be registered in a special vtkProp3D,\\n vtkMultiVolume.\\n*\\n* Structures related to a particular active input are stored in a\\n helper\\n* class (vtkVolumeInputHelper) and helper structures are kept in a\\n* port-referenced map (VolumeInputMap). The order of the inputs in\\n the\\n* map is important as it defines the order in which parameters are\\n* bound to uniform variables (transformation matrices, bias, scale\\n and every\\n* other required rendering parameter).\\n*\\n* A separate code path is used when rendering multiple-inputs in\\n order to\\n* facilitate the co-existance of these two modes (single/multiple),\\n due to\\n* current feature incompatibilities with multiple inputs (e.g.\\n texture-streaming,\\n* cropping, etc.).\\n*\\n*\\n\\note A limited set of the mapper features are currently supported for\\n* multiple inputs:\\n*\\n* - Blending\\n* - Composite (front-to-back)\\n*\\n* - Transfer functions (defined separately for per input)\\n* - 1D color\\n* - 1D scalar opacity\\n* - 1D gradient magnitude opacity\\n* - 2D scalar-gradient magnitude\\n*\\n* - Point and cell data\\n* - With the limitation that all of the inputs are assumed to share\\nthe same\\n* name/id.\\n*\\n* @sa vtkGPUVolumeRayCastMapper vtkVolumeInputHelper vtkVolumeTexture\\n* vtkMultiVolume\\n*\\n\\n'})" __vtkname__ = 'vtkOpenGLGPUVolumeRayCastMapper' class vtkOpenGLProjectedTetrahedraMapper(__vtkmodules_vtkRenderingVolume.vtkProjectedTetrahedraMapper): """ vtkOpenGLProjectedTetrahedraMapper - OpenGL implementation of PT Superclass: vtkProjectedTetrahedraMapper @bug This mapper relies highly on the implementation of the OpenGL pipeline. A typical hardware driver has lots of options and some settings can cause this mapper to produce artifacts. """ 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 GetUseFloatingPointFrameBuffer(self): # real signature unknown; restored from __doc__ """ GetUseFloatingPointFrameBuffer(self) -> bool C++: virtual bool GetUseFloatingPointFrameBuffer() """ 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 IsSupported(self, context): # real signature unknown; restored from __doc__ """ IsSupported(self, context:vtkRenderWindow) -> bool C++: bool IsSupported(vtkRenderWindow *context) override; Return true if the rendering context provides the nececessary functionality to use this class. """ 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) -> vtkOpenGLProjectedTetrahedraMapper C++: vtkOpenGLProjectedTetrahedraMapper *NewInstance() """ return vtkOpenGLProjectedTetrahedraMapper def ReleaseGraphicsResources(self, window): # real signature unknown; restored from __doc__ """ ReleaseGraphicsResources(self, window:vtkWindow) -> None C++: void ReleaseGraphicsResources(vtkWindow *window) override; WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE Release any graphics resources that are being consumed by this mapper. The parameter window could be used to determine which graphic resources to release. """ pass def Render(self, renderer, volume): # real signature unknown; restored from __doc__ """ Render(self, renderer:vtkRenderer, volume:vtkVolume) -> None C++: void Render(vtkRenderer *renderer, vtkVolume *volume) override; WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE DO NOT USE THIS METHOD OUTSIDE OF THE RENDERING PROCESS Render the volume """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkOpenGLProjectedTetrahedraMapper C++: static vtkOpenGLProjectedTetrahedraMapper *SafeDownCast( vtkObjectBase *o) """ return vtkOpenGLProjectedTetrahedraMapper def SetUseFloatingPointFrameBuffer(self, _arg): # real signature unknown; restored from __doc__ """ SetUseFloatingPointFrameBuffer(self, _arg:bool) -> None C++: virtual void SetUseFloatingPointFrameBuffer(bool _arg) Set/get whether to use floating-point rendering buffers rather than the default. """ pass def UseFloatingPointFrameBufferOff(self): # real signature unknown; restored from __doc__ """ UseFloatingPointFrameBufferOff(self) -> None C++: virtual void UseFloatingPointFrameBufferOff() """ pass def UseFloatingPointFrameBufferOn(self): # real signature unknown; restored from __doc__ """ UseFloatingPointFrameBufferOn(self) -> None C++: virtual void UseFloatingPointFrameBufferOn() """ 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__': 'vtkOpenGLProjectedTetrahedraMapper', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'ReleaseGraphicsResources': , 'Render': , 'SetUseFloatingPointFrameBuffer': , 'GetUseFloatingPointFrameBuffer': , 'UseFloatingPointFrameBufferOn': , 'UseFloatingPointFrameBufferOff': , 'IsSupported': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkOpenGLProjectedTetrahedraMapper - OpenGL implementation of PT\\n\\nSuperclass: vtkProjectedTetrahedraMapper\\n\\n@bug This mapper relies highly on the implementation of the OpenGL\\npipeline. A typical hardware driver has lots of options and some\\nsettings can cause this mapper to produce artifacts.\\n\\n'})" __vtkname__ = 'vtkOpenGLProjectedTetrahedraMapper' class vtkOpenGLRayCastImageDisplayHelper(__vtkmodules_vtkRenderingVolume.vtkRayCastImageDisplayHelper): """ vtkOpenGLRayCastImageDisplayHelper - OpenGL subclass that draws the image to the screen Superclass: vtkRayCastImageDisplayHelper This is the concrete implementation of a ray cast image display helper - a helper class responsible for drawing the image to the screen. @sa vtkRayCastImageDisplayHelper """ 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) -> vtkOpenGLRayCastImageDisplayHelper C++: vtkOpenGLRayCastImageDisplayHelper *NewInstance() """ return vtkOpenGLRayCastImageDisplayHelper def ReleaseGraphicsResources(self, win): # real signature unknown; restored from __doc__ """ ReleaseGraphicsResources(self, win:vtkWindow) -> None C++: void ReleaseGraphicsResources(vtkWindow *win) override; Derived class should implement this if needed """ pass def RenderTexture(self, vol, ren, imageMemorySize, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ RenderTexture(self, vol:vtkVolume, ren:vtkRenderer, imageMemorySize:[int, int], imageViewportSize:[int, int], imageInUseSize:[int, int], imageOrigin:[int, int], requestedDepth:float, image:[int, ...]) -> None C++: void RenderTexture(vtkVolume *vol, vtkRenderer *ren, int imageMemorySize[2], int imageViewportSize[2], int imageInUseSize[2], int imageOrigin[2], float requestedDepth, unsigned char *image) override; RenderTexture(self, vol:vtkVolume, ren:vtkRenderer, imageMemorySize:[int, int], imageViewportSize:[int, int], imageInUseSize:[int, int], imageOrigin:[int, int], requestedDepth:float, image:[int, ...]) -> None C++: void RenderTexture(vtkVolume *vol, vtkRenderer *ren, int imageMemorySize[2], int imageViewportSize[2], int imageInUseSize[2], int imageOrigin[2], float requestedDepth, unsigned short *image) override; RenderTexture(self, vol:vtkVolume, ren:vtkRenderer, image:vtkFixedPointRayCastImage, requestedDepth:float) -> None C++: void RenderTexture(vtkVolume *vol, vtkRenderer *ren, vtkFixedPointRayCastImage *image, float requestedDepth) override; """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkOpenGLRayCastImageDisplayHelper C++: static vtkOpenGLRayCastImageDisplayHelper *SafeDownCast( vtkObjectBase *o) """ return vtkOpenGLRayCastImageDisplayHelper 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__': 'vtkOpenGLRayCastImageDisplayHelper', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'RenderTexture': , 'ReleaseGraphicsResources': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkOpenGLRayCastImageDisplayHelper - OpenGL subclass that draws the\\nimage to the screen\\n\\nSuperclass: vtkRayCastImageDisplayHelper\\n\\nThis is the concrete implementation of a ray cast image display\\nhelper - a helper class responsible for drawing the image to the\\nscreen.\\n\\n@sa\\nvtkRayCastImageDisplayHelper\\n\\n'})" __vtkname__ = 'vtkOpenGLRayCastImageDisplayHelper' class vtkSmartVolumeMapper(__vtkmodules_vtkRenderingVolume.vtkVolumeMapper): """ vtkSmartVolumeMapper - Adaptive volume mapper Superclass: vtkVolumeMapper vtkSmartVolumeMapper is a volume mapper that will delegate to a specific volume mapper based on rendering parameters and available hardware. Use the SetRequestedRenderMode() method to control the behavior of the selection. The following options are available: @par vtkSmartVolumeMapper::DefaultRenderMode: Allow the vtkSmartVolumeMapper to select the best mapper based on rendering parameters and hardware support. If GPU ray casting is supported, the vtkGPUVolumeRayCastMapper mapper will be used for all rendering. If not, then the vtkFixedPointVolumeRayCastMapper will be used exclusively. This is the default requested render mode, and is generally the best option. When you use this option, your volume will always be rendered, but the method used to render it may vary based on parameters and platform. @par vtkSmartVolumeMapper::RayCastRenderMode: Use the vtkFixedPointVolumeRayCastMapper for both interactive and still rendering. When you use this option your volume will always be rendered with the vtkFixedPointVolumeRayCastMapper. @par vtkSmartVolumeMapper::GPURenderMode: Use the vtkGPUVolumeRayCastMapper, if supported, for both interactive and still rendering. If the GPU ray caster is not supported (due to hardware limitations or rendering parameters) then no image will be rendered. Use this option only if you have already checked for supported based on the current hardware, number of scalar components, and rendering parameters in the vtkVolumeProperty. @par vtkSmartVolumeMapper::GPURenderMode: You can adjust the contrast and brightness in the rendered image using the FinalColorWindow and FinalColorLevel ivars. By default the FinalColorWindow is set to 1.0, and the FinalColorLevel is set to 0.5, which applies no correction to the computed image. To apply the window / level operation to the computer image color, first a Scale and Bias value are computed: scale = 1.0 / this->FinalColorWindow bias = 0.5 - this->FinalColorLevel / this->FinalColorWindow To compute a new color (R', G', B', A') from an existing color (R,G,B,A) for a pixel, the following equation is used: R' = R*scale + bias*A G' = G*scale + bias*A B' = B*scale + bias*A A' = A Note that bias is multiplied by the alpha component before adding because the red, green, and blue component of the color are already pre-multiplied by alpha. Also note that the window / level operation leaves the alpha component unchanged - it only adjusts the RGB values. """ def AutoAdjustSampleDistancesOff(self): # real signature unknown; restored from __doc__ """ AutoAdjustSampleDistancesOff(self) -> None C++: virtual void AutoAdjustSampleDistancesOff() """ pass def AutoAdjustSampleDistancesOn(self): # real signature unknown; restored from __doc__ """ AutoAdjustSampleDistancesOn(self) -> None C++: virtual void AutoAdjustSampleDistancesOn() """ pass def CreateCanonicalView(self, ren, volume, volume2, image, blend_mode, viewDirection, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ CreateCanonicalView(self, ren:vtkRenderer, volume:vtkVolume, volume2:vtkVolume, image:vtkImageData, blend_mode:int, viewDirection:[float, float, float], viewUp:[float, float, float]) -> None C++: void CreateCanonicalView(vtkRenderer *ren, vtkVolume *volume, vtkVolume *volume2, vtkImageData *image, int blend_mode, double viewDirection[3], double viewUp[3]) This method can be used to render a representative view of the input data into the supplied image given the supplied blending mode, view direction, and view up vector. """ pass def GetAutoAdjustSampleDistances(self): # real signature unknown; restored from __doc__ """ GetAutoAdjustSampleDistances(self) -> int C++: virtual vtkTypeBool GetAutoAdjustSampleDistances() """ return 0 def GetAutoAdjustSampleDistancesMaxValue(self): # real signature unknown; restored from __doc__ """ GetAutoAdjustSampleDistancesMaxValue(self) -> int C++: virtual vtkTypeBool GetAutoAdjustSampleDistancesMaxValue() """ return 0 def GetAutoAdjustSampleDistancesMinValue(self): # real signature unknown; restored from __doc__ """ GetAutoAdjustSampleDistancesMinValue(self) -> int C++: virtual vtkTypeBool GetAutoAdjustSampleDistancesMinValue() """ return 0 def GetFinalColorLevel(self): # real signature unknown; restored from __doc__ """ GetFinalColorLevel(self) -> float C++: virtual float GetFinalColorLevel() Get the final color level. """ return 0.0 def GetFinalColorWindow(self): # real signature unknown; restored from __doc__ """ GetFinalColorWindow(self) -> float C++: virtual float GetFinalColorWindow() Get the final color window. Initial value is 1.0. """ return 0.0 def GetGlobalIlluminationReach(self): # real signature unknown; restored from __doc__ """ GetGlobalIlluminationReach(self) -> float C++: virtual float GetGlobalIlluminationReach() """ return 0.0 def GetGlobalIlluminationReachMaxValue(self): # real signature unknown; restored from __doc__ """ GetGlobalIlluminationReachMaxValue(self) -> float C++: virtual float GetGlobalIlluminationReachMaxValue() """ return 0.0 def GetGlobalIlluminationReachMinValue(self): # real signature unknown; restored from __doc__ """ GetGlobalIlluminationReachMinValue(self) -> float C++: virtual float GetGlobalIlluminationReachMinValue() """ return 0.0 def GetInteractiveAdjustSampleDistances(self): # real signature unknown; restored from __doc__ """ GetInteractiveAdjustSampleDistances(self) -> int C++: virtual vtkTypeBool GetInteractiveAdjustSampleDistances() """ return 0 def GetInteractiveAdjustSampleDistancesMaxValue(self): # real signature unknown; restored from __doc__ """ GetInteractiveAdjustSampleDistancesMaxValue(self) -> int C++: virtual vtkTypeBool GetInteractiveAdjustSampleDistancesMaxValue( ) """ return 0 def GetInteractiveAdjustSampleDistancesMinValue(self): # real signature unknown; restored from __doc__ """ GetInteractiveAdjustSampleDistancesMinValue(self) -> int C++: virtual vtkTypeBool GetInteractiveAdjustSampleDistancesMinValue( ) """ return 0 def GetInteractiveUpdateRate(self): # real signature unknown; restored from __doc__ """ GetInteractiveUpdateRate(self) -> float C++: virtual double GetInteractiveUpdateRate() Get the update rate at or above which this is considered an interactive render. Initial value is 1.0. """ return 0.0 def GetInteractiveUpdateRateMaxValue(self): # real signature unknown; restored from __doc__ """ GetInteractiveUpdateRateMaxValue(self) -> float C++: virtual double GetInteractiveUpdateRateMaxValue() """ return 0.0 def GetInteractiveUpdateRateMinValue(self): # real signature unknown; restored from __doc__ """ GetInteractiveUpdateRateMinValue(self) -> float C++: virtual double GetInteractiveUpdateRateMinValue() """ return 0.0 def GetInterpolationMode(self): # real signature unknown; restored from __doc__ """ GetInterpolationMode(self) -> int C++: virtual int GetInterpolationMode() """ return 0 def GetInterpolationModeMaxValue(self): # real signature unknown; restored from __doc__ """ GetInterpolationModeMaxValue(self) -> int C++: virtual int GetInterpolationModeMaxValue() """ return 0 def GetInterpolationModeMinValue(self): # real signature unknown; restored from __doc__ """ GetInterpolationModeMinValue(self) -> int C++: virtual int GetInterpolationModeMinValue() """ return 0 def GetLastUsedRenderMode(self): # real signature unknown; restored from __doc__ """ GetLastUsedRenderMode(self) -> int C++: int GetLastUsedRenderMode() This will return the render mode used during the previous call to Render(). """ return 0 def GetMaxMemoryFraction(self): # real signature unknown; restored from __doc__ """ GetMaxMemoryFraction(self) -> float C++: virtual float GetMaxMemoryFraction() """ return 0.0 def GetMaxMemoryFractionMaxValue(self): # real signature unknown; restored from __doc__ """ GetMaxMemoryFractionMaxValue(self) -> float C++: virtual float GetMaxMemoryFractionMaxValue() """ return 0.0 def GetMaxMemoryFractionMinValue(self): # real signature unknown; restored from __doc__ """ GetMaxMemoryFractionMinValue(self) -> float C++: virtual float GetMaxMemoryFractionMinValue() """ return 0.0 def GetMaxMemoryInBytes(self): # real signature unknown; restored from __doc__ """ GetMaxMemoryInBytes(self) -> int C++: virtual vtkIdType GetMaxMemoryInBytes() """ 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 GetRequestedRenderMode(self): # real signature unknown; restored from __doc__ """ GetRequestedRenderMode(self) -> int C++: virtual int GetRequestedRenderMode() Get the requested render mode. """ return 0 def GetSampleDistance(self): # real signature unknown; restored from __doc__ """ GetSampleDistance(self) -> float C++: virtual float GetSampleDistance() """ return 0.0 def GetTransfer2DYAxisArray(self): # real signature unknown; restored from __doc__ """ GetTransfer2DYAxisArray(self) -> str C++: virtual char *GetTransfer2DYAxisArray() Set/Get the transfer 2D Y axis array """ return "" def GetVectorComponent(self): # real signature unknown; restored from __doc__ """ GetVectorComponent(self) -> int C++: virtual int GetVectorComponent() """ return 0 def GetVectorComponentMaxValue(self): # real signature unknown; restored from __doc__ """ GetVectorComponentMaxValue(self) -> int C++: virtual int GetVectorComponentMaxValue() """ return 0 def GetVectorComponentMinValue(self): # real signature unknown; restored from __doc__ """ GetVectorComponentMinValue(self) -> int C++: virtual int GetVectorComponentMinValue() """ return 0 def GetVectorMode(self): # real signature unknown; restored from __doc__ """ GetVectorMode(self) -> int C++: virtual int GetVectorMode() """ return 0 def GetVolumetricScatteringBlending(self): # real signature unknown; restored from __doc__ """ GetVolumetricScatteringBlending(self) -> float C++: virtual float GetVolumetricScatteringBlending() """ return 0.0 def GetVolumetricScatteringBlendingMaxValue(self): # real signature unknown; restored from __doc__ """ GetVolumetricScatteringBlendingMaxValue(self) -> float C++: virtual float GetVolumetricScatteringBlendingMaxValue() """ return 0.0 def GetVolumetricScatteringBlendingMinValue(self): # real signature unknown; restored from __doc__ """ GetVolumetricScatteringBlendingMinValue(self) -> float C++: virtual float GetVolumetricScatteringBlendingMinValue() """ return 0.0 def InteractiveAdjustSampleDistancesOff(self): # real signature unknown; restored from __doc__ """ InteractiveAdjustSampleDistancesOff(self) -> None C++: virtual void InteractiveAdjustSampleDistancesOff() """ pass def InteractiveAdjustSampleDistancesOn(self): # real signature unknown; restored from __doc__ """ InteractiveAdjustSampleDistancesOn(self) -> None C++: virtual void InteractiveAdjustSampleDistancesOn() """ 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 NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkSmartVolumeMapper C++: vtkSmartVolumeMapper *NewInstance() """ return vtkSmartVolumeMapper def ReleaseGraphicsResources(self, __a): # real signature unknown; restored from __doc__ """ ReleaseGraphicsResources(self, __a:vtkWindow) -> None C++: void ReleaseGraphicsResources(vtkWindow *) override; WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE Release any graphics resources that are being consumed by this mapper. The parameter window could be used to determine which graphic resources to release. """ pass def Render(self, __a, __b): # real signature unknown; restored from __doc__ """ Render(self, __a:vtkRenderer, __b:vtkVolume) -> None C++: void Render(vtkRenderer *, vtkVolume *) override; WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE Initialize rendering for this volume. """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkSmartVolumeMapper C++: static vtkSmartVolumeMapper *SafeDownCast(vtkObjectBase *o) """ return vtkSmartVolumeMapper def SetAutoAdjustSampleDistances(self, _arg): # real signature unknown; restored from __doc__ """ SetAutoAdjustSampleDistances(self, _arg:int) -> None C++: virtual void SetAutoAdjustSampleDistances(vtkTypeBool _arg) If AutoAdjustSampleDistances is on, the ImageSampleDistance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use). Note that, this flag is ignored when InteractiveAdjustSampleDistances is enabled. To explicitly set and use this flag, one must disable InteractiveAdjustSampleDistances. """ pass def SetFinalColorLevel(self, _arg): # real signature unknown; restored from __doc__ """ SetFinalColorLevel(self, _arg:float) -> None C++: virtual void SetFinalColorLevel(float _arg) Set the final color level. The level controls the brightness of the image. The final color window will be centered at the final color level, and together represent a linear remapping of color values. The default value for the level is 0.5. """ pass def SetFinalColorWindow(self, _arg): # real signature unknown; restored from __doc__ """ SetFinalColorWindow(self, _arg:float) -> None C++: virtual void SetFinalColorWindow(float _arg) Set the final color window. This controls the contrast of the image. The default value is 1.0. The Window can be negative (this causes a "negative" effect on the image) Although Window can be set to 0.0, any value less than 0.00001 and greater than or equal to 0.0 will be set to 0.00001, and any value greater than -0.00001 but less than or equal to 0.0 will be set to -0.00001. Initial value is 1.0. """ pass def SetGlobalIlluminationReach(self, _arg): # real signature unknown; restored from __doc__ """ SetGlobalIlluminationReach(self, _arg:float) -> None C++: virtual void SetGlobalIlluminationReach(float _arg) @copydoc vtkGPUVolumeRayCastMapper::SetGlobalIlluminationReach(float) This parameter is only used when the underlying mapper is a vtkGPUVolumeRayCastMapper. """ pass def SetInteractiveAdjustSampleDistances(self, _arg): # real signature unknown; restored from __doc__ """ SetInteractiveAdjustSampleDistances(self, _arg:int) -> None C++: virtual void SetInteractiveAdjustSampleDistances( vtkTypeBool _arg) If the InteractiveAdjustSampleDistances flag is enabled, vtkSmartVolumeMapper interactively sets and resets the AutoAdjustSampleDistances flag on the internal volume mapper. This flag along with InteractiveUpdateRate is useful to adjust volume mapper sample distance based on whether the render is interactive or still. By default, InteractiveAdjustSampleDistances is enabled. """ pass def SetInteractiveUpdateRate(self, _arg): # real signature unknown; restored from __doc__ """ SetInteractiveUpdateRate(self, _arg:float) -> None C++: virtual void SetInteractiveUpdateRate(double _arg) If the DesiredUpdateRate of the vtkRenderWindow that caused the Render falls at or above this rate, the render is considered interactive and the mapper may be adjusted (depending on the render mode). Initial value is 1.0. """ pass def SetInterpolationMode(self, _arg): # real signature unknown; restored from __doc__ """ SetInterpolationMode(self, _arg:int) -> None C++: virtual void SetInterpolationMode(int _arg) Set interpolation mode for downsampling (lowres GPU) (initial value: cubic). """ pass def SetInterpolationModeToCubic(self): # real signature unknown; restored from __doc__ """ SetInterpolationModeToCubic(self) -> None C++: void SetInterpolationModeToCubic() """ pass def SetInterpolationModeToLinear(self): # real signature unknown; restored from __doc__ """ SetInterpolationModeToLinear(self) -> None C++: void SetInterpolationModeToLinear() """ pass def SetInterpolationModeToNearestNeighbor(self): # real signature unknown; restored from __doc__ """ SetInterpolationModeToNearestNeighbor(self) -> None C++: void SetInterpolationModeToNearestNeighbor() """ pass def SetMaxMemoryFraction(self, _arg): # real signature unknown; restored from __doc__ """ SetMaxMemoryFraction(self, _arg:float) -> None C++: virtual void SetMaxMemoryFraction(float _arg) Value passed to the GPU mapper. Ignored by other mappers. Maximum fraction of the MaxMemoryInBytes that should be used to hold the texture. Valid values are 0.1 to 1.0. """ pass def SetMaxMemoryInBytes(self, _arg): # real signature unknown; restored from __doc__ """ SetMaxMemoryInBytes(self, _arg:int) -> None C++: virtual void SetMaxMemoryInBytes(vtkIdType _arg) Value passed to the GPU mapper. Ignored by other mappers. Maximum size of the 3D texture in GPU memory. Will default to the size computed from the graphics card. Can be adjusted by the user. Useful if the automatic detection is defective or missing. """ pass def SetRequestedRenderMode(self, mode): # real signature unknown; restored from __doc__ """ SetRequestedRenderMode(self, mode:int) -> None C++: void SetRequestedRenderMode(int mode) Set the requested render mode. The default is vtkSmartVolumeMapper::DefaultRenderMode. """ pass def SetRequestedRenderModeToDefault(self): # real signature unknown; restored from __doc__ """ SetRequestedRenderModeToDefault(self) -> None C++: void SetRequestedRenderModeToDefault() Set the requested render mode to vtkSmartVolumeMapper::DefaultRenderMode. This is the best option for an application that must adapt to different data types, hardware, and rendering parameters. """ pass def SetRequestedRenderModeToGPU(self): # real signature unknown; restored from __doc__ """ SetRequestedRenderModeToGPU(self) -> None C++: void SetRequestedRenderModeToGPU() Set the requested render mode to vtkSmartVolumeMapper::GPURenderMode. This option will use hardware accelerated rendering exclusively. This is a good option if you know there is hardware acceleration. """ pass def SetRequestedRenderModeToOSPRay(self): # real signature unknown; restored from __doc__ """ SetRequestedRenderModeToOSPRay(self) -> None C++: void SetRequestedRenderModeToOSPRay() Set the requested render mode to vtkSmartVolumeMapper::OSPRayRenderMode. This option will use intel OSPRay to do software rendering exclusively. """ pass def SetRequestedRenderModeToRayCast(self): # real signature unknown; restored from __doc__ """ SetRequestedRenderModeToRayCast(self) -> None C++: void SetRequestedRenderModeToRayCast() Set the requested render mode to vtkSmartVolumeMapper::RayCastRenderMode. This option will use software rendering exclusively. This is a good option if you know there is no hardware acceleration. """ pass def SetSampleDistance(self, _arg): # real signature unknown; restored from __doc__ """ SetSampleDistance(self, _arg:float) -> None C++: virtual void SetSampleDistance(float _arg) Set/Get the distance between samples used for rendering when AutoAdjustSampleDistances is off, or when this mapper has more than 1 second allocated to it for rendering. If SampleDistance is negative, it will be computed based on the dataset spacing. Initial value is -1.0. """ pass def SetTransfer2DYAxisArray(self, _arg): # real signature unknown; restored from __doc__ """ SetTransfer2DYAxisArray(self, _arg:str) -> None C++: virtual void SetTransfer2DYAxisArray(const char *_arg) Set/Get the transfer 2D Y axis array """ pass def SetVectorComponent(self, _arg): # real signature unknown; restored from __doc__ """ SetVectorComponent(self, _arg:int) -> None C++: virtual void SetVectorComponent(int _arg) """ pass def SetVectorMode(self, mode): # real signature unknown; restored from __doc__ """ SetVectorMode(self, mode:int) -> None C++: void SetVectorMode(int mode) """ pass def SetVolumetricScatteringBlending(self, _arg): # real signature unknown; restored from __doc__ """ SetVolumetricScatteringBlending(self, _arg:float) -> None C++: virtual void SetVolumetricScatteringBlending(float _arg) @copydoc vtkGPUVolumeRayCastMapper::SetVolumetricScatteringBlending(float) This parameter is only used when the underlying mapper is a vtkGPUVolumeRayCastMapper. """ 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.""" COMPONENT = 1 DefaultRenderMode = 0 DISABLED = -1 GPURenderMode = 2 InvalidRenderMode = 5 MAGNITUDE = 0 OSPRayRenderMode = 3 RayCastRenderMode = 1 UndefinedRenderMode = 4 VectorModeType = None # (!) real value is "" __dict__ = None # (!) real value is 'mappingproxy({\'__vtkname__\': \'vtkSmartVolumeMapper\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'SetFinalColorWindow\': , \'GetFinalColorWindow\': , \'SetFinalColorLevel\': , \'GetFinalColorLevel\': , \'SetRequestedRenderMode\': , \'SetRequestedRenderModeToDefault\': , \'SetRequestedRenderModeToRayCast\': , \'SetRequestedRenderModeToGPU\': , \'SetRequestedRenderModeToOSPRay\': , \'GetRequestedRenderMode\': , \'GetLastUsedRenderMode\': , \'SetMaxMemoryInBytes\': , \'GetMaxMemoryInBytes\': , \'SetMaxMemoryFraction\': , \'GetMaxMemoryFractionMinValue\': , \'GetMaxMemoryFractionMaxValue\': , \'GetMaxMemoryFraction\': , \'SetInterpolationMode\': , \'GetInterpolationModeMinValue\': , \'GetInterpolationModeMaxValue\': , \'GetInterpolationMode\': , \'SetInterpolationModeToNearestNeighbor\': , \'SetInterpolationModeToLinear\': , \'SetInterpolationModeToCubic\': , \'CreateCanonicalView\': , \'SetInteractiveUpdateRate\': , \'GetInteractiveUpdateRateMinValue\': , \'GetInteractiveUpdateRateMaxValue\': , \'GetInteractiveUpdateRate\': , \'SetInteractiveAdjustSampleDistances\': , \'GetInteractiveAdjustSampleDistancesMinValue\': , \'GetInteractiveAdjustSampleDistancesMaxValue\': , \'GetInteractiveAdjustSampleDistances\': , \'InteractiveAdjustSampleDistancesOn\': , \'InteractiveAdjustSampleDistancesOff\': , \'SetAutoAdjustSampleDistances\': , \'GetAutoAdjustSampleDistancesMinValue\': , \'GetAutoAdjustSampleDistancesMaxValue\': , \'GetAutoAdjustSampleDistances\': , \'AutoAdjustSampleDistancesOn\': , \'AutoAdjustSampleDistancesOff\': , \'SetSampleDistance\': , \'GetSampleDistance\': , \'SetGlobalIlluminationReach\': , \'GetGlobalIlluminationReachMinValue\': , \'GetGlobalIlluminationReachMaxValue\': , \'GetGlobalIlluminationReach\': , \'SetVolumetricScatteringBlending\': , \'GetVolumetricScatteringBlendingMinValue\': , \'GetVolumetricScatteringBlendingMaxValue\': , \'GetVolumetricScatteringBlending\': , \'Render\': , \'ReleaseGraphicsResources\': , \'SetVectorMode\': , \'GetVectorMode\': , \'SetVectorComponent\': , \'GetVectorComponentMinValue\': , \'GetVectorComponentMaxValue\': , \'GetVectorComponent\': , \'SetTransfer2DYAxisArray\': , \'GetTransfer2DYAxisArray\': , \'VectorModeType\': , \'DefaultRenderMode\': 0, \'RayCastRenderMode\': 1, \'GPURenderMode\': 2, \'OSPRayRenderMode\': 3, \'UndefinedRenderMode\': 4, \'InvalidRenderMode\': 5, \'DISABLED\': -1, \'MAGNITUDE\': 0, \'COMPONENT\': 1, \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': "vtkSmartVolumeMapper - Adaptive volume mapper\\n\\nSuperclass: vtkVolumeMapper\\n\\nvtkSmartVolumeMapper is a volume mapper that will delegate to a\\nspecific volume mapper based on rendering parameters and available\\nhardware. Use the SetRequestedRenderMode() method to control the\\nbehavior of the selection. The following options are available:\\n\\n@par vtkSmartVolumeMapper::DefaultRenderMode:\\n Allow the vtkSmartVolumeMapper to select the best mapper\\nbased on\\n rendering parameters and hardware support. If GPU ray\\ncasting is\\n supported, the vtkGPUVolumeRayCastMapper mapper will be used\\nfor\\n all rendering. If not, then the\\nvtkFixedPointVolumeRayCastMapper\\n will be used exclusively. This is the default requested\\nrender\\n mode, and is generally the best option. When you use this\\noption,\\n your volume will always be rendered, but the method used to\\nrender\\n it may vary based on parameters and platform.\\n\\n@par vtkSmartVolumeMapper::RayCastRenderMode:\\n Use the vtkFixedPointVolumeRayCastMapper for both\\ninteractive and\\n still rendering. When you use this option your volume will\\nalways\\n be rendered with the vtkFixedPointVolumeRayCastMapper.\\n\\n@par vtkSmartVolumeMapper::GPURenderMode:\\n Use the vtkGPUVolumeRayCastMapper, if supported, for both\\n interactive and still rendering. If the GPU ray caster is\\nnot\\n supported (due to hardware limitations or rendering\\nparameters)\\n then no image will be rendered. Use this option only if you\\nhave\\n already checked for supported based on the current hardware,\\n number of scalar components, and rendering parameters in the\\n vtkVolumeProperty.\\n\\n@par vtkSmartVolumeMapper::GPURenderMode:\\n You can adjust the contrast and brightness in the rendered image\\nusing the\\n FinalColorWindow and FinalColorLevel ivars. By default the\\n FinalColorWindow is set to 1.0, and the FinalColorLevel is set to\\n0.5,\\n which applies no correction to the computed image. To apply the\\nwindow /\\n level operation to the computer image color, first a Scale and Bias\\n value are computed:\\n\\n\\n scale = 1.0 / this->FinalColorWindow\\n bias = 0.5 - this->FinalColorLevel / this->FinalColorWindow\\n \\n To compute a new color (R\', G\', B\', A\') from an existing color\\n(R,G,B,A)\\n for a pixel, the following equation is used:\\n\\n\\n R\' = R*scale + bias*A\\n G\' = G*scale + bias*A\\n B\' = B*scale + bias*A\\n A\' = A\\n Note that bias is multiplied by the alpha component before adding\\nbecause the red, green, and blue component of the color are already\\npre-multiplied by alpha. Also note that the window / level operation\\nleaves the alpha component unchanged - it only adjusts the RGB\\nvalues.\\n\\n"})' __vtkname__ = 'vtkSmartVolumeMapper' class vtkVolumeTexture(__vtkmodules_vtkCommonCore.vtkObject): """ vtkVolumeTexture - Creates and manages the volume texture rendered by vtkOpenGLGPUVolumeRayCastMapper. Superclass: vtkObject Wraps a vtkTextureObject for which it selects the appropriate format (depending on the input vtkDataArray type, number of components, etc.) and loads input data. The class maintains a set of members of interest to the parent mapper, such as: * Active vtkDataArray scalar range. * Volume's scale and bias (pixel transfer functions). * HandleLargeDataType flag. * Texture to data transformations. * Block extents * Block loaded bounds This class supports streaming the volume data in separate blocks to make it fit in graphics memory (sometimes referred to as bricking). The data is split into a user-defined number of blocks in such a way that a single sub-block (brick) fits completely into GPU memory. A stride is passed to OpenGL so that it can access the underlying vtkDataArray adequately for each of the blocks to be streamed into GPU memory (back-to-front for correct composition). Streaming the volume as separate texture bricks certainly imposes a performance trade-off but acts as a graphics memory expansion scheme for devices that would not be able to render higher resoulution volumes otherwise. @warning There are certain caveats when texture streaming is enabled, given the locality constraint that rendering a single block imposes. - Quality might suffer near the block seams with ShadeOn() (gradient computation at the boundaries needs adjustment). - Not all of the features supported by the mapper currently work correctly. This is a list of known issues: - Blending modes such as average and additive might compute a different value near the edges. - Future work will extend the API to be able to compute an ideal number of partitions and extents based on the platform capabilities. @warning This is an internal class of vtkOpenGLGPUVolumeRayCastMapper. It assumes there is an active OpenGL context in methods involving GL calls (MakeCurrent() is expected to be called in the mapper beforehand). """ def GetLoadedScalars(self): # real signature unknown; restored from __doc__ """ GetLoadedScalars(self) -> vtkDataArray C++: vtkDataArray *GetLoadedScalars() """ 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 GetPartitions(self): # real signature unknown; restored from __doc__ """ GetPartitions(self) -> vtkTuple_IiLi3EE C++: const Size3 &GetPartitions() """ pass def GetScaleAndBias(self, scalarType, scalarRange, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetScaleAndBias(scalarType:int, scalarRange:[float, ...], scale:float, bias:float) -> None C++: static void GetScaleAndBias(const int scalarType, float *scalarRange, float &scale, float &bias) Get the scale and bias values given a VTK scalar type and a finite range. The scale and bias values computed using this method can be useful for custom shader code. For example, when looking up color values through the transfer function texture, the scalar value must be scaled and offset. """ 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 LoadVolume(self, ren, data, scalars, isCell, interpolation): # real signature unknown; restored from __doc__ """ LoadVolume(self, ren:vtkRenderer, data:vtkDataSet, scalars:vtkDataArray, isCell:int, interpolation:int) -> bool C++: bool LoadVolume(vtkRenderer *ren, vtkDataSet *data, vtkDataArray *scalars, int const isCell, int const interpolation) Loads the data array into the texture in the case only a single block is is defined. Does not load when the input data is divided in multiple blocks (in which case they will be loaded into GPU memory by GetNextBlock()). Requires an active OpenGL context. """ return False def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkVolumeTexture C++: vtkVolumeTexture *NewInstance() """ return vtkVolumeTexture def ReleaseGraphicsResources(self, win): # real signature unknown; restored from __doc__ """ ReleaseGraphicsResources(self, win:vtkWindow) -> None C++: void ReleaseGraphicsResources(vtkWindow *win) Clean-up acquired graphics resources. """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkVolumeTexture C++: static vtkVolumeTexture *SafeDownCast(vtkObjectBase *o) """ return vtkVolumeTexture def SetPartitions(self, x, y, z): # real signature unknown; restored from __doc__ """ SetPartitions(self, x:int, y:int, z:int) -> None C++: void SetPartitions(int const x, int const y, int const z) Set a number of blocks per axis. """ pass def SortBlocksBackToFront(self, ren, volumeMat): # real signature unknown; restored from __doc__ """ SortBlocksBackToFront(self, ren:vtkRenderer, volumeMat:vtkMatrix4x4) -> None C++: void SortBlocksBackToFront(vtkRenderer *ren, vtkMatrix4x4 *volumeMat) If streaming the data array as separate blocks, sort them back to front. This method does nothing if there is a single block. """ pass def UpdateVolume(self, property): # real signature unknown; restored from __doc__ """ UpdateVolume(self, property:vtkVolumeProperty) -> None C++: void UpdateVolume(vtkVolumeProperty *property) It currently only calls SetInterpolation internally. Requires an active OpenGL context. """ 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__\': \'vtkVolumeTexture\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'SetPartitions\': , \'GetPartitions\': , \'LoadVolume\': , \'UpdateVolume\': , \'SortBlocksBackToFront\': , \'ReleaseGraphicsResources\': , \'GetScaleAndBias\': , \'GetLoadedScalars\': , \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': "vtkVolumeTexture - Creates and manages the volume texture rendered by\\nvtkOpenGLGPUVolumeRayCastMapper.\\n\\nSuperclass: vtkObject\\n\\nWraps a vtkTextureObject for which it selects the appropriate format\\n(depending on the input vtkDataArray type, number of components,\\netc.) and loads input data. The class maintains a set of members of\\ninterest to the parent mapper, such as:\\n\\n* Active vtkDataArray scalar range.\\n* Volume\'s scale and bias (pixel transfer functions).\\n* HandleLargeDataType flag.\\n* Texture to data transformations.\\n* Block extents\\n* Block loaded bounds\\n\\nThis class supports streaming the volume data in separate blocks to\\nmake it fit in graphics memory (sometimes referred to as bricking).\\nThe data is split into a user-defined number of blocks in such a way\\nthat a single sub-block (brick) fits completely into GPU memory. A\\nstride is passed to OpenGL so that it can access the underlying\\nvtkDataArray adequately for each of the blocks to be streamed into\\nGPU memory (back-to-front for correct composition).\\n\\nStreaming the volume as separate texture bricks certainly imposes a\\nperformance trade-off but acts as a graphics memory expansion scheme\\nfor devices that would not be able to render higher resoulution\\nvolumes otherwise.\\n\\n@warning There are certain caveats when texture streaming is enabled,\\ngiven\\nthe locality constraint that rendering a single block imposes.\\n\\n- Quality might suffer near the block seams with ShadeOn() (gradient\\n computation at the boundaries needs adjustment).\\n\\n- Not all of the features supported by the mapper currently work\\n correctly. This is a list of known issues:\\n- Blending modes such as average and additive might compute a\\n different value near the edges.\\n\\n- Future work will extend the API to be able to compute an ideal\\n number of partitions and extents based on the platform\\n capabilities.\\n\\n@warning This is an internal class of\\n vtkOpenGLGPUVolumeRayCastMapper. It\\nassumes there is an active OpenGL context in methods involving GL\\ncalls (MakeCurrent() is expected to be called in the mapper\\nbeforehand).\\n\\n"})' __vtkname__ = 'vtkVolumeTexture' # variables with complex values __loader__ = None # (!) real value is '<_frozen_importlib_external.ExtensionFileLoader object at 0x000002C547DFBC50>' __spec__ = None # (!) real value is "ModuleSpec(name='vtkmodules.vtkRenderingVolumeOpenGL2', loader=<_frozen_importlib_external.ExtensionFileLoader object at 0x000002C547DFBC50>, origin='C:\\\\Users\\\\xukai\\\\Downloads\\\\??2\\\\venv\\\\Lib\\\\site-packages\\\\vtkmodules\\\\vtkRenderingVolumeOpenGL2.cp311-win_amd64.pyd')"