# encoding: utf-8 # module vtkmodules.vtkRenderingOpenGL2 # from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\vtkmodules\vtkRenderingOpenGL2.cp311-win_amd64.pyd # by generator 1.147 # no doc # imports import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore import vtkmodules.vtkRenderingCore as __vtkmodules_vtkRenderingCore import vtkmodules.vtkRenderingHyperTreeGrid as __vtkmodules_vtkRenderingHyperTreeGrid class vtkOpenGLFluidMapper(__vtkmodules_vtkRenderingCore.vtkAbstractVolumeMapper): """ vtkOpenGLFluidMapper - Render fluid from position data (and color, if available) Superclass: vtkAbstractVolumeMapper An OpenGL mapper that display fluid volume using a screen space fluid rendering technique. Thanks to Nghia Truong for the algorithm and initial implementation. """ def GetAdditionalReflection(self): # real signature unknown; restored from __doc__ """ GetAdditionalReflection(self) -> float C++: virtual float GetAdditionalReflection() """ return 0.0 def GetAttenuationColor(self): # real signature unknown; restored from __doc__ """ GetAttenuationColor(self) -> (float, float, float) C++: virtual float *GetAttenuationColor() """ pass def GetAttenuationScale(self): # real signature unknown; restored from __doc__ """ GetAttenuationScale(self) -> float C++: virtual float GetAttenuationScale() """ return 0.0 def GetDisplayMode(self): # real signature unknown; restored from __doc__ """ GetDisplayMode(self) -> vtkOpenGLFluidMapper.FluidDisplayMode C++: virtual vtkOpenGLFluidMapper::FluidDisplayMode GetDisplayMode( ) """ pass def GetInput(self): # real signature unknown; restored from __doc__ """ GetInput(self) -> vtkPolyData C++: vtkPolyData *GetInput() """ 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 GetOpaqueColor(self): # real signature unknown; restored from __doc__ """ GetOpaqueColor(self) -> (float, float, float) C++: virtual float *GetOpaqueColor() """ pass def GetParticleColorPower(self): # real signature unknown; restored from __doc__ """ GetParticleColorPower(self) -> float C++: virtual float GetParticleColorPower() """ return 0.0 def GetParticleColorScale(self): # real signature unknown; restored from __doc__ """ GetParticleColorScale(self) -> float C++: virtual float GetParticleColorScale() """ return 0.0 def GetParticleRadius(self): # real signature unknown; restored from __doc__ """ GetParticleRadius(self) -> float C++: virtual float GetParticleRadius() """ return 0.0 def GetRefractionScale(self): # real signature unknown; restored from __doc__ """ GetRefractionScale(self) -> float C++: virtual float GetRefractionScale() """ return 0.0 def GetRefractiveIndex(self): # real signature unknown; restored from __doc__ """ GetRefractiveIndex(self) -> float C++: virtual float GetRefractiveIndex() """ return 0.0 def GetScalarVisibility(self): # real signature unknown; restored from __doc__ """ GetScalarVisibility(self) -> bool C++: virtual bool GetScalarVisibility() """ return False def GetSurfaceFilterMethod(self): # real signature unknown; restored from __doc__ """ GetSurfaceFilterMethod(self) -> vtkOpenGLFluidMapper.FluidSurfaceFilterMethod C++: virtual vtkOpenGLFluidMapper::FluidSurfaceFilterMethod GetSurfaceFilterMethod( ) """ pass def GetThicknessAndVolumeColorFilterRadius(self): # real signature unknown; restored from __doc__ """ GetThicknessAndVolumeColorFilterRadius(self) -> float C++: virtual float GetThicknessAndVolumeColorFilterRadius() """ 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) -> vtkOpenGLFluidMapper C++: vtkOpenGLFluidMapper *NewInstance() """ return vtkOpenGLFluidMapper def ReleaseGraphicsResources(self, w): # real signature unknown; restored from __doc__ """ ReleaseGraphicsResources(self, w:vtkWindow) -> None C++: void ReleaseGraphicsResources(vtkWindow *w) override; Release graphics resources and ask components to release their own resources. \pre w_exists: w!=0 """ pass def 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; This calls RenderPiece """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkOpenGLFluidMapper C++: static vtkOpenGLFluidMapper *SafeDownCast(vtkObjectBase *o) """ return vtkOpenGLFluidMapper def ScalarVisibilityOff(self): # real signature unknown; restored from __doc__ """ ScalarVisibilityOff(self) -> None C++: virtual void ScalarVisibilityOff() """ pass def ScalarVisibilityOn(self): # real signature unknown; restored from __doc__ """ ScalarVisibilityOn(self) -> None C++: virtual void ScalarVisibilityOn() """ pass def SetAdditionalReflection(self, _arg): # real signature unknown; restored from __doc__ """ SetAdditionalReflection(self, _arg:float) -> None C++: virtual void SetAdditionalReflection(float _arg) Get/Set the fluid surface additional reflection scale This value is in [0, 1], which 0 means using the reflection color computed from fresnel equation, and 1 means using reflection color as [1, 1, 1] Default value is 0 """ pass def SetAttenuationColor(self, _arg1, _arg2, _arg3): # real signature unknown; restored from __doc__ """ SetAttenuationColor(self, _arg1:float, _arg2:float, _arg3:float) -> None C++: virtual void SetAttenuationColor(float _arg1, float _arg2, float _arg3) SetAttenuationColor(self, _arg:(float, float, float)) -> None C++: virtual void SetAttenuationColor(const float _arg[3]) Get/Set the fluid attenuation color (color that will be absorpted exponentially when going through the fluid volume) """ pass def SetAttenuationScale(self, _arg): # real signature unknown; restored from __doc__ """ SetAttenuationScale(self, _arg:float) -> None C++: virtual void SetAttenuationScale(float _arg) Get/Set the fluid volume attenuation scale, which will be multiplied with attenuation color Default value is 1.0, and can be set to any non-negative number The larger attenuation scale, the darker fluid color """ pass def SetBilateralGaussianFilterParameter(self, sigmaDepth): # real signature unknown; restored from __doc__ """ SetBilateralGaussianFilterParameter(self, sigmaDepth:float) -> None C++: void SetBilateralGaussianFilterParameter(float sigmaDepth) Optional parameters, exclusively for bilateral gaussian filter The parameter is for controlling smoothing between surface depth values """ pass def SetDisplayMode(self, _arg): # real signature unknown; restored from __doc__ """ SetDisplayMode(self, _arg:vtkOpenGLFluidMapper.FluidDisplayMode) -> None C++: virtual void SetDisplayMode( vtkOpenGLFluidMapper::FluidDisplayMode _arg) Get/Set the display mode """ pass def SetInputData(self, in_): # real signature unknown; restored from __doc__ """ SetInputData(self, in_:vtkPolyData) -> None C++: void SetInputData(vtkPolyData *in) Specify the input data to map. """ pass def SetNarrowRangeFilterParameters(self, lambda_, mu): # real signature unknown; restored from __doc__ """ SetNarrowRangeFilterParameters(self, lambda_:float, mu:float) -> None C++: void SetNarrowRangeFilterParameters(float lambda, float mu) Optional parameters, exclusively for narrow range filter The first parameter is to control smoothing between surface depth values The second parameter is to control curvature of the surface edges """ pass def SetOpaqueColor(self, _arg1, _arg2, _arg3): # real signature unknown; restored from __doc__ """ SetOpaqueColor(self, _arg1:float, _arg2:float, _arg3:float) -> None C++: virtual void SetOpaqueColor(float _arg1, float _arg2, float _arg3) SetOpaqueColor(self, _arg:(float, float, float)) -> None C++: virtual void SetOpaqueColor(const float _arg[3]) Get/Set the fluid surface color if rendered in opaque surface mode without particle color """ pass def SetParticleColorPower(self, _arg): # real signature unknown; restored from __doc__ """ SetParticleColorPower(self, _arg:float) -> None C++: virtual void SetParticleColorPower(float _arg) Get/Set the power value for particle color if input data has particle color Default value is 0.1, and can be set to any non-negative number The particle color is then recomputed as newColor = pow(oldColor, power) * scale """ pass def SetParticleColorScale(self, _arg): # real signature unknown; restored from __doc__ """ SetParticleColorScale(self, _arg:float) -> None C++: virtual void SetParticleColorScale(float _arg) Get/Set the scale value for particle color if input data has particle color Default value is 1.0, and can be set to any non-negative number The particle color is then recomputed as newColor = pow(oldColor, power) * scale """ pass def SetParticleRadius(self, _arg): # real signature unknown; restored from __doc__ """ SetParticleRadius(self, _arg:float) -> None C++: virtual void SetParticleRadius(float _arg) Set/Get the particle radius, must be explicitly set by user To fuse the gaps between particles and obtain a smooth surface, this parameter need to be slightly larger than the actual particle radius, (particle radius is the half distance between two consecutive particles in regular pattern sampling) """ pass def SetRefractionScale(self, _arg): # real signature unknown; restored from __doc__ """ SetRefractionScale(self, _arg:float) -> None C++: virtual void SetRefractionScale(float _arg) Get/Set the scale value for refraction This is needed for tweak refraction of volumes with different size scales For example, fluid volume having diameter of 100.0 will refract light much more than volume with diameter 1.0 This value is in [0, 1], default value is 1.0 """ pass def SetRefractiveIndex(self, _arg): # real signature unknown; restored from __doc__ """ SetRefractiveIndex(self, _arg:float) -> None C++: virtual void SetRefractiveIndex(float _arg) Get/Set the fluid refraction index. The default value is 1.33 (water) """ pass def SetScalarVisibility(self, _arg): # real signature unknown; restored from __doc__ """ SetScalarVisibility(self, _arg:bool) -> None C++: virtual void SetScalarVisibility(bool _arg) Turn on/off flag to control whether scalar data is used to color objects. """ pass def SetSurfaceFilterMethod(self, _arg): # real signature unknown; restored from __doc__ """ SetSurfaceFilterMethod(self, _arg:vtkOpenGLFluidMapper.FluidSurfaceFilterMethod) -> None C++: virtual void SetSurfaceFilterMethod( vtkOpenGLFluidMapper::FluidSurfaceFilterMethod _arg) Get/Set the filter method for filtering fluid surface """ pass def SetThicknessAndVolumeColorFilterRadius(self, _arg): # real signature unknown; restored from __doc__ """ SetThicknessAndVolumeColorFilterRadius(self, _arg:float) -> None C++: virtual void SetThicknessAndVolumeColorFilterRadius( float _arg) Get/Set the filter radius to filter the volume thickness and particle color This is an optional parameter, default value is 10 (pixels) """ 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.""" BilateralGaussian = 0 FilteredOpaqueSurface = 1 FilteredSurfaceNormal = 3 FluidDisplayMode = None # (!) real value is "" FluidSurfaceFilterMethod = None # (!) real value is "" NarrowRange = 1 NumDisplayModes = 5 NumFilterMethods = 2 TransparentFluidVolume = 4 UnfilteredOpaqueSurface = 0 UnfilteredSurfaceNormal = 2 __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkOpenGLFluidMapper', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'SetInputData': , 'GetInput': , 'SetScalarVisibility': , 'GetScalarVisibility': , 'ScalarVisibilityOn': , 'ScalarVisibilityOff': , 'SetParticleRadius': , 'GetParticleRadius': , 'SetThicknessAndVolumeColorFilterRadius': , 'GetThicknessAndVolumeColorFilterRadius': , 'SetSurfaceFilterMethod': , 'GetSurfaceFilterMethod': , 'SetNarrowRangeFilterParameters': , 'SetBilateralGaussianFilterParameter': , 'SetDisplayMode': , 'GetDisplayMode': , 'SetAttenuationColor': , 'GetAttenuationColor': , 'SetOpaqueColor': , 'GetOpaqueColor': , 'SetParticleColorPower': , 'GetParticleColorPower': , 'SetParticleColorScale': , 'GetParticleColorScale': , 'SetAttenuationScale': , 'GetAttenuationScale': , 'SetAdditionalReflection': , 'GetAdditionalReflection': , 'SetRefractionScale': , 'GetRefractionScale': , 'SetRefractiveIndex': , 'GetRefractiveIndex': , 'Render': , 'ReleaseGraphicsResources': , 'FluidSurfaceFilterMethod': , 'FluidDisplayMode': , 'BilateralGaussian': 0, 'NarrowRange': 1, 'NumFilterMethods': 2, 'UnfilteredOpaqueSurface': 0, 'FilteredOpaqueSurface': 1, 'UnfilteredSurfaceNormal': 2, 'FilteredSurfaceNormal': 3, 'TransparentFluidVolume': 4, 'NumDisplayModes': 5, '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkOpenGLFluidMapper - Render fluid from position data (and color, if\\navailable)\\n\\nSuperclass: vtkAbstractVolumeMapper\\n\\nAn OpenGL mapper that display fluid volume using a screen space fluid\\nrendering technique. Thanks to Nghia Truong for the algorithm and\\ninitial implementation.\\n\\n'})" __vtkname__ = 'vtkOpenGLFluidMapper'