# encoding: utf-8 # module vtkmodules.vtkRenderingVolume # from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\vtkmodules\vtkRenderingVolume.cp311-win_amd64.pyd # by generator 1.147 # no doc # imports import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore import vtkmodules.vtkCommonExecutionModel as __vtkmodules_vtkCommonExecutionModel import vtkmodules.vtkRenderingCore as __vtkmodules_vtkRenderingCore class vtkVolumeMapper(__vtkmodules_vtkRenderingCore.vtkAbstractVolumeMapper): """ vtkVolumeMapper - Abstract class for a volume mapper Superclass: vtkAbstractVolumeMapper vtkVolumeMapper is the abstract definition of a volume mapper for regular rectilinear data (vtkImageData). Several basic types of volume mappers are supported. """ def ComputeNormalFromOpacityOff(self): # real signature unknown; restored from __doc__ """ ComputeNormalFromOpacityOff(self) -> None C++: virtual void ComputeNormalFromOpacityOff() """ pass def ComputeNormalFromOpacityOn(self): # real signature unknown; restored from __doc__ """ ComputeNormalFromOpacityOn(self) -> None C++: virtual void ComputeNormalFromOpacityOn() """ pass def CroppingOff(self): # real signature unknown; restored from __doc__ """ CroppingOff(self) -> None C++: virtual void CroppingOff() """ pass def CroppingOn(self): # real signature unknown; restored from __doc__ """ CroppingOn(self) -> None C++: virtual void CroppingOn() """ pass def GetAverageIPScalarRange(self): # real signature unknown; restored from __doc__ """ GetAverageIPScalarRange(self) -> (float, float) C++: virtual double *GetAverageIPScalarRange() """ pass def GetBlendMode(self): # real signature unknown; restored from __doc__ """ GetBlendMode(self) -> int C++: virtual int GetBlendMode() """ return 0 def GetComputeNormalFromOpacity(self): # real signature unknown; restored from __doc__ """ GetComputeNormalFromOpacity(self) -> bool C++: virtual bool GetComputeNormalFromOpacity() """ return False def GetCropping(self): # real signature unknown; restored from __doc__ """ GetCropping(self) -> int C++: virtual vtkTypeBool GetCropping() """ return 0 def GetCroppingMaxValue(self): # real signature unknown; restored from __doc__ """ GetCroppingMaxValue(self) -> int C++: virtual vtkTypeBool GetCroppingMaxValue() """ return 0 def GetCroppingMinValue(self): # real signature unknown; restored from __doc__ """ GetCroppingMinValue(self) -> int C++: virtual vtkTypeBool GetCroppingMinValue() """ return 0 def GetCroppingRegionFlags(self): # real signature unknown; restored from __doc__ """ GetCroppingRegionFlags(self) -> int C++: virtual int GetCroppingRegionFlags() """ return 0 def GetCroppingRegionFlagsMaxValue(self): # real signature unknown; restored from __doc__ """ GetCroppingRegionFlagsMaxValue(self) -> int C++: virtual int GetCroppingRegionFlagsMaxValue() """ return 0 def GetCroppingRegionFlagsMinValue(self): # real signature unknown; restored from __doc__ """ GetCroppingRegionFlagsMinValue(self) -> int C++: virtual int GetCroppingRegionFlagsMinValue() """ return 0 def GetCroppingRegionPlanes(self): # real signature unknown; restored from __doc__ """ GetCroppingRegionPlanes(self) -> (float, float, float, float, float, float) C++: virtual double *GetCroppingRegionPlanes() """ pass def GetInput(self): # real signature unknown; restored from __doc__ """ GetInput(self) -> vtkDataSet C++: virtual vtkDataSet *GetInput() GetInput(self, port:int) -> vtkDataSet C++: virtual vtkDataSet *GetInput(const int port) """ 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 GetVoxelCroppingRegionPlanes(self): # real signature unknown; restored from __doc__ """ GetVoxelCroppingRegionPlanes(self) -> (float, float, float, float, float, float) C++: virtual double *GetVoxelCroppingRegionPlanes() Get the cropping region planes in voxels. Only valid during the rendering process """ 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) -> vtkVolumeMapper C++: vtkVolumeMapper *NewInstance() """ return vtkVolumeMapper 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, ren, vol): # real signature unknown; restored from __doc__ """ Render(self, ren:vtkRenderer, vol:vtkVolume) -> None C++: void Render(vtkRenderer *ren, vtkVolume *vol) override = 0; 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) -> vtkVolumeMapper C++: static vtkVolumeMapper *SafeDownCast(vtkObjectBase *o) """ return vtkVolumeMapper def SetAverageIPScalarRange(self, _arg1, _arg2): # real signature unknown; restored from __doc__ """ SetAverageIPScalarRange(self, _arg1:float, _arg2:float) -> None C++: virtual void SetAverageIPScalarRange(double _arg1, double _arg2) SetAverageIPScalarRange(self, _arg:(float, float)) -> None C++: void SetAverageIPScalarRange(const double _arg[2]) Set/Get the scalar range to be considered for average intensity projection blend mode. Only scalar values between this range will be averaged during ray casting. This can be useful when volume rendering CT datasets where the areas occupied by air would deviate the final rendering. By default, the range is set to (VTK_FLOAT_MIN, VTK_FLOAT_MAX). \sa SetBlendModeToAverageIntensity() """ pass def SetBlendMode(self, _arg): # real signature unknown; restored from __doc__ """ SetBlendMode(self, _arg:int) -> None C++: virtual void SetBlendMode(int _arg) Set/Get the blend mode. The default mode is Composite where the scalar values are sampled through the volume and composited in a front-to-back scheme through alpha blending. The final color and opacity is determined using the color and opacity transfer functions. Maximum and minimum intensity blend modes use the maximum and minimum scalar values, respectively, along the sampling ray. The final color and opacity is determined by passing the resultant value through the color and opacity transfer functions. Additive blend mode accumulates scalar values by passing each value through the opacity transfer function and then adding up the product of the value and its opacity. In other words, the scalar values are scaled using the opacity transfer function and summed to derive the final color. Note that the resulting image is always grayscale i.e. aggregated values are not passed through the color transfer function. This is because the final value is a derived value and not a real data value along the sampling ray. Average intensity blend mode works similar to the additive blend mode where the scalar values are multiplied by opacity calculated from the opacity transfer function and then added. The additional step here is to divide the sum by the number of samples taken through the volume. One can control the scalar range by setting the AverageIPScalarRange ivar to disregard scalar values, not in the range of interest, from the average computation. As is the case with the additive intensity projection, the final image will always be grayscale i.e. the aggregated values are not passed through the color transfer function. This is because the resultant value is a derived value and not a real data value along the sampling ray. IsoSurface blend mode uses contour values defined by the user in order to display scalar values only when the ray crosses the contour. It supports opacity the ... [Truncated] """ pass def SetBlendModeToAdditive(self): # real signature unknown; restored from __doc__ """ SetBlendModeToAdditive(self) -> None C++: void SetBlendModeToAdditive() """ pass def SetBlendModeToAverageIntensity(self): # real signature unknown; restored from __doc__ """ SetBlendModeToAverageIntensity(self) -> None C++: void SetBlendModeToAverageIntensity() """ pass def SetBlendModeToComposite(self): # real signature unknown; restored from __doc__ """ SetBlendModeToComposite(self) -> None C++: void SetBlendModeToComposite() """ pass def SetBlendModeToIsoSurface(self): # real signature unknown; restored from __doc__ """ SetBlendModeToIsoSurface(self) -> None C++: void SetBlendModeToIsoSurface() """ pass def SetBlendModeToMaximumIntensity(self): # real signature unknown; restored from __doc__ """ SetBlendModeToMaximumIntensity(self) -> None C++: void SetBlendModeToMaximumIntensity() """ pass def SetBlendModeToMinimumIntensity(self): # real signature unknown; restored from __doc__ """ SetBlendModeToMinimumIntensity(self) -> None C++: void SetBlendModeToMinimumIntensity() """ pass def SetBlendModeToSlice(self): # real signature unknown; restored from __doc__ """ SetBlendModeToSlice(self) -> None C++: void SetBlendModeToSlice() """ pass def SetComputeNormalFromOpacity(self, _arg): # real signature unknown; restored from __doc__ """ SetComputeNormalFromOpacity(self, _arg:bool) -> None C++: virtual void SetComputeNormalFromOpacity(bool _arg) If enabled, the volume(s) whose shading is enabled will use the gradient of opacity instead of the scalar gradient to estimate the surface's normal when applying the shading model. The opacity considered for the gradient is then the scalars converted to opacity by the transfer function(s). For now it is only supported in vtkGPUVolumeRayCastMapper. In vtkSmartVolumeMapper and in vtkMultiBlockVolumeMapper, this parameter is used when the GPU mapper is effectively used. Note that enabling it might affect performances, especially when using a 2D TF or a gradient opacity. It is disabled by default. """ pass def SetCropping(self, _arg): # real signature unknown; restored from __doc__ """ SetCropping(self, _arg:int) -> None C++: virtual void SetCropping(vtkTypeBool _arg) Turn On/Off orthogonal cropping. (Clipping planes are perpendicular to the coordinate axes.) """ pass def SetCroppingRegionFlags(self, _arg): # real signature unknown; restored from __doc__ """ SetCroppingRegionFlags(self, _arg:int) -> None C++: virtual void SetCroppingRegionFlags(int _arg) Set the flags for the cropping regions. The clipping planes divide the volume into 27 regions - there is one bit for each region. The regions start from the one containing voxel (0,0,0), moving along the x axis fastest, the y axis next, and the z axis slowest. These are represented from the lowest bit to bit number 27 in the integer containing the flags. There are several convenience functions to set some common configurations - subvolume (the default), fence (between any of the clip plane pairs), inverted fence, cross (between any two of the clip plane pairs) and inverted cross. """ pass def SetCroppingRegionFlagsToCross(self): # real signature unknown; restored from __doc__ """ SetCroppingRegionFlagsToCross(self) -> None C++: void SetCroppingRegionFlagsToCross() """ pass def SetCroppingRegionFlagsToFence(self): # real signature unknown; restored from __doc__ """ SetCroppingRegionFlagsToFence(self) -> None C++: void SetCroppingRegionFlagsToFence() """ pass def SetCroppingRegionFlagsToInvertedCross(self): # real signature unknown; restored from __doc__ """ SetCroppingRegionFlagsToInvertedCross(self) -> None C++: void SetCroppingRegionFlagsToInvertedCross() """ pass def SetCroppingRegionFlagsToInvertedFence(self): # real signature unknown; restored from __doc__ """ SetCroppingRegionFlagsToInvertedFence(self) -> None C++: void SetCroppingRegionFlagsToInvertedFence() """ pass def SetCroppingRegionFlagsToSubVolume(self): # real signature unknown; restored from __doc__ """ SetCroppingRegionFlagsToSubVolume(self) -> None C++: void SetCroppingRegionFlagsToSubVolume() """ 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++: virtual void SetCroppingRegionPlanes(double _arg1, double _arg2, double _arg3, double _arg4, double _arg5, double _arg6) SetCroppingRegionPlanes(self, _arg:(float, float, float, float, float, float)) -> None C++: virtual void SetCroppingRegionPlanes(const double _arg[6]) Set/Get the Cropping Region Planes ( xmin, xmax, ymin, ymax, zmin, zmax ) These planes are defined in volume coordinates - spacing and origin are considered. """ pass def SetInputData(self, __a): # real signature unknown; restored from __doc__ """ SetInputData(self, __a:vtkImageData) -> None C++: virtual void SetInputData(vtkImageData *) SetInputData(self, __a:vtkDataSet) -> None C++: virtual void SetInputData(vtkDataSet *) SetInputData(self, __a:vtkRectilinearGrid) -> None C++: virtual void SetInputData(vtkRectilinearGrid *) Set/Get the input data """ 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.""" ADDITIVE_BLEND = 4 AVERAGE_INTENSITY_BLEND = 3 BlendModes = None # (!) real value is "" COMPOSITE_BLEND = 0 ISOSURFACE_BLEND = 5 MAXIMUM_INTENSITY_BLEND = 1 MINIMUM_INTENSITY_BLEND = 2 SLICE_BLEND = 6 __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkVolumeMapper', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'SetInputData': , 'GetInput': , 'SetBlendMode': , 'SetBlendModeToComposite': , 'SetBlendModeToMaximumIntensity': , 'SetBlendModeToMinimumIntensity': , 'SetBlendModeToAverageIntensity': , 'SetBlendModeToAdditive': , 'SetBlendModeToIsoSurface': , 'SetBlendModeToSlice': , 'GetBlendMode': , 'SetAverageIPScalarRange': , 'GetAverageIPScalarRange': , 'SetCropping': , 'GetCroppingMinValue': , 'GetCroppingMaxValue': , 'GetCropping': , 'CroppingOn': , 'CroppingOff': , 'SetCroppingRegionPlanes': , 'GetCroppingRegionPlanes': , 'GetVoxelCroppingRegionPlanes': , 'SetComputeNormalFromOpacity': , 'GetComputeNormalFromOpacity': , 'ComputeNormalFromOpacityOn': , 'ComputeNormalFromOpacityOff': , 'SetCroppingRegionFlags': , 'GetCroppingRegionFlagsMinValue': , 'GetCroppingRegionFlagsMaxValue': , 'GetCroppingRegionFlags': , 'SetCroppingRegionFlagsToSubVolume': , 'SetCroppingRegionFlagsToFence': , 'SetCroppingRegionFlagsToInvertedFence': , 'SetCroppingRegionFlagsToCross': , 'SetCroppingRegionFlagsToInvertedCross': , 'Render': , 'ReleaseGraphicsResources': , 'BlendModes': , 'COMPOSITE_BLEND': 0, 'MAXIMUM_INTENSITY_BLEND': 1, 'MINIMUM_INTENSITY_BLEND': 2, 'AVERAGE_INTENSITY_BLEND': 3, 'ADDITIVE_BLEND': 4, 'ISOSURFACE_BLEND': 5, 'SLICE_BLEND': 6, '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkVolumeMapper - Abstract class for a volume mapper\\n\\nSuperclass: vtkAbstractVolumeMapper\\n\\nvtkVolumeMapper is the abstract definition of a volume mapper for\\nregular rectilinear data (vtkImageData). Several basic types of\\nvolume mappers are supported.\\n\\n'})" __vtkname__ = 'vtkVolumeMapper'