# encoding: utf-8 # module vtkmodules.vtkRenderingLICOpenGL2 # from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\vtkmodules\vtkRenderingLICOpenGL2.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.vtkRenderingOpenGL2 as __vtkmodules_vtkRenderingOpenGL2 # no functions # classes class vtkCompositeSurfaceLICMapper(__vtkmodules_vtkRenderingOpenGL2.vtkCompositePolyDataMapper2): """ vtkCompositeSurfaceLICMapper - mapper for composite dataset Superclass: vtkCompositePolyDataMapper2 vtkCompositeSurfaceLICMapper is similar to vtkGenericCompositeSurfaceLICMapper but requires that its inputs all have the same properties (normals, tcoord, scalars, etc) It will only draw polys and it does not support edge flags. The advantage to using this class is that it generally should be faster """ def GetLICInterface(self): # real signature unknown; restored from __doc__ """ GetLICInterface(self) -> vtkSurfaceLICInterface C++: vtkSurfaceLICInterface *GetLICInterface() Get the vtkSurfaceLICInterface used by this mapper """ return vtkSurfaceLICInterface 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) -> vtkCompositeSurfaceLICMapper C++: vtkCompositeSurfaceLICMapper *NewInstance() """ return vtkCompositeSurfaceLICMapper def Render(self, ren, act): # real signature unknown; restored from __doc__ """ Render(self, ren:vtkRenderer, act:vtkActor) -> None C++: void Render(vtkRenderer *ren, vtkActor *act) override; Lots of LIC setup code """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkCompositeSurfaceLICMapper C++: static vtkCompositeSurfaceLICMapper *SafeDownCast( vtkObjectBase *o) """ return vtkCompositeSurfaceLICMapper 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__': 'vtkCompositeSurfaceLICMapper', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'GetLICInterface': , 'Render': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkCompositeSurfaceLICMapper - mapper for composite dataset\\n\\nSuperclass: vtkCompositePolyDataMapper2\\n\\nvtkCompositeSurfaceLICMapper is similar to\\nvtkGenericCompositeSurfaceLICMapper but requires that its inputs all\\nhave the same properties (normals, tcoord, scalars, etc) It will only\\ndraw polys and it does not support edge flags. The advantage to using\\nthis class is that it generally should be faster\\n\\n'})" __vtkname__ = 'vtkCompositeSurfaceLICMapper' class vtkImageDataLIC2D(__vtkmodules_vtkCommonExecutionModel.vtkImageAlgorithm): """ vtkImageDataLIC2D - GPU implementation of a Line Integral Convolution, a technique for imaging vector fields. Superclass: vtkImageAlgorithm The input on port 0 is an vtkImageData with extents of a 2D image. It needs a vector field on point data. This filter only works on point vectors. One can use a vtkCellDataToPointData filter to convert cell vectors to point vectors. Port 1 is a special port for customized noise input. It is an optional port. If noise input is not specified, then the filter using vtkImageNoiseSource to generate a 128x128 noise texture. @sa vtkSurfaceLICPainter vtkLineIntegralConvolution2D """ def GetContext(self): # real signature unknown; restored from __doc__ """ GetContext(self) -> vtkRenderWindow C++: vtkRenderWindow *GetContext() """ pass def GetMagnification(self): # real signature unknown; restored from __doc__ """ GetMagnification(self) -> int C++: virtual int GetMagnification() """ 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 GetOpenGLExtensionsSupported(self): # real signature unknown; restored from __doc__ """ GetOpenGLExtensionsSupported(self) -> int C++: virtual int GetOpenGLExtensionsSupported() Check if the required OpenGL extensions / GPU are supported. """ return 0 def GetSteps(self): # real signature unknown; restored from __doc__ """ GetSteps(self) -> int C++: virtual int GetSteps() """ return 0 def GetStepSize(self): # real signature unknown; restored from __doc__ """ GetStepSize(self) -> float C++: virtual double GetStepSize() """ 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) -> vtkImageDataLIC2D C++: vtkImageDataLIC2D *NewInstance() """ return vtkImageDataLIC2D def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkImageDataLIC2D C++: static vtkImageDataLIC2D *SafeDownCast(vtkObjectBase *o) """ return vtkImageDataLIC2D def SetContext(self, context): # real signature unknown; restored from __doc__ """ SetContext(self, context:vtkRenderWindow) -> int C++: int SetContext(vtkRenderWindow *context) Get/Set the context. Context must be a vtkOpenGLRenderWindow. This does not increase the reference count of the context to avoid reference loops. SetContext() may raise an error if the OpenGL context does not support the required OpenGL extensions. Return 0 upon failure and 1 upon success. """ return 0 def SetMagnification(self, _arg): # real signature unknown; restored from __doc__ """ SetMagnification(self, _arg:int) -> None C++: virtual void SetMagnification(int _arg) The magnification factor. Default is 1 """ pass def SetSteps(self, _arg): # real signature unknown; restored from __doc__ """ SetSteps(self, _arg:int) -> None C++: virtual void SetSteps(int _arg) Number of steps. Initial value is 20. class invariant: Steps>0. In term of visual quality, the greater the better. """ pass def SetStepSize(self, _arg): # real signature unknown; restored from __doc__ """ SetStepSize(self, _arg:float) -> None C++: virtual void SetStepSize(double _arg) Step size. Specify the step size as a unit of the cell length of the input vector field. Cell length is the length of the diagonal of a cell. Initial value is 1.0. class invariant: StepSize>0.0. In term of visual quality, the smaller the better. The type for the interface is double as VTK interface is double but GPU only supports float. This value will be converted to float in the execution of the algorithm. """ pass def TranslateInputExtent(self, inExt, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ TranslateInputExtent(self, inExt:(int, ...), inWholeExtent:(int, ...), outExt:[int, ...]) -> None C++: void TranslateInputExtent(const int *inExt, const int *inWholeExtent, int *outExt) """ 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__': 'vtkImageDataLIC2D', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'SetContext': , 'GetContext': , 'SetSteps': , 'GetSteps': , 'SetStepSize': , 'GetStepSize': , 'SetMagnification': , 'GetMagnification': , 'GetOpenGLExtensionsSupported': , 'TranslateInputExtent': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkImageDataLIC2D - GPU implementation of a Line Integral\\nConvolution, a technique for\\n imaging vector fields.\\n\\nSuperclass: vtkImageAlgorithm\\n\\nThe input on port 0 is an vtkImageData with extents of a 2D image. It\\nneeds\\n a vector field on point data. This filter only works on point\\nvectors. One\\n can use a vtkCellDataToPointData filter to convert cell vectors to\\npoint\\n vectors.\\n\\n\\n Port 1 is a special port for customized noise input. It is an\\noptional port.\\n If noise input is not specified, then the filter using\\nvtkImageNoiseSource to\\n generate a 128x128 noise texture.\\n\\n@sa\\n vtkSurfaceLICPainter vtkLineIntegralConvolution2D\\n\\n'})" __vtkname__ = 'vtkImageDataLIC2D' class vtkLineIntegralConvolution2D(__vtkmodules_vtkCommonCore.vtkObject): """ vtkLineIntegralConvolution2D - GPU-based implementation of Line Integral Convolution (LIC) Superclass: vtkObject This class resorts to GLSL to implement GPU-based Line Integral Convolution (LIC) for visualizing a 2D vector field that may be obtained by projecting an original 3D vector field onto a surface (such that the resulting 2D vector at each grid point on the surface is tangential to the local normal, as done in vtkSurfaceLICPainter). As an image-based technique, 2D LIC works by (1) integrating a bidirectional streamline from the center of each pixel (of the LIC output image), (2) locating the pixels along / hit by this streamline as the correlated pixels of the starting pixel (seed point / pixel), (3) indexing a (usually white) noise texture (another input to LIC, in addition to the 2D vector field, usually with the same size as that of the 2D vector field) to determine the values (colors) of these pixels (the starting and the correlated pixels), typically through bi-linear interpolation, and (4) performing convolution (weighted averaging) on these values, by adopting a low-pass filter (such as box, ramp, and Hanning kernels), to obtain the result value (color) that is then assigned to the seed pixel. The GLSL-based GPU implementation herein maps the aforementioned pipeline to fragment shaders and a box kernel is employed. Both the white noise and the vector field are provided to the GPU as texture objects (supported by the multi-texturing capability). In addition, there are four texture objects (color buffers) allocated to constitute two pairs that work in a ping-pong fashion, with one as the read buffers and the other as the write / render targets. Maintained by a frame buffer object (GL_EXT_framebuffer_object), each pair employs one buffer to store the current (dynamically updated) position (by means of the texture coordinate that keeps being warped by the underlying vector) of the (virtual) particle initially released from each fragment while using the bother buffer to store the current (dynamically updated too) accumulated texture value that each seed fragment (before the 'mesh' is warped) collects. Given NumberOfSteps integration steps in each direction, there are a total of (2 * NumberOfSteps + 1) fragments (including the seed fragment) are convolved and each contributes 1 / (2 * NumberOfSteps + 1) of the associated texture value to fulfill the box filter. One pass of LIC (basic LIC) tends to produce low-contrast / blurred images and vtkLineIntegralConvolution2D provides an option for creating enhanced LIC images. Enhanced LIC improves image quality by increasing inter-streamline contrast while suppressing artifacts. It performs two passes of LIC, with a 3x3 Laplacian high-pass filter in between that processes the output of pass #1 LIC and forwards the result as the input 'noise' to pass #2 LIC. vtkLineIntegralConvolution2D applies masking to zero-vector fragments so that un-filtered white noise areas are made totally transparent by class vtkSurfaceLICPainter to show the underlying geometry surface. The convolution process tends to decrease both contrast and dynamic range, sometimes leading to dull dark images. In order to counteract this, optional contrast ehnancement stages have been added. These increase the dynamic range and contrast and sharpen streaking patterns that emerge from the LIC process. Under some circumstances, typically depending on the contrast and dynamic range and graininess of the noise texture, jagged or pixelated patterns emerge in the LIC. These can be reduced by enabling the optional anti-aliasing pass. The internal pipeline is as follows, with optional stages denoted by () nested optional stages depend on their parent stage. noise texture | [ LIC ((CE) HPF LIC) (AA) (CE) ] | | vector field LIC'd image where LIC is the LIC stage, HPF is the high-pass filter stage, CE is the contrast ehnacement stage, and AA is the antialias stage. @sa vtkImageDataLIC2D vtkStructuredGridLIC2D """ def AntiAliasOff(self): # real signature unknown; restored from __doc__ """ AntiAliasOff(self) -> None C++: virtual void AntiAliasOff() """ pass def AntiAliasOn(self): # real signature unknown; restored from __doc__ """ AntiAliasOn(self) -> None C++: virtual void AntiAliasOn() """ pass def EnhanceContrastOff(self): # real signature unknown; restored from __doc__ """ EnhanceContrastOff(self) -> None C++: virtual void EnhanceContrastOff() """ pass def EnhanceContrastOn(self): # real signature unknown; restored from __doc__ """ EnhanceContrastOn(self) -> None C++: virtual void EnhanceContrastOn() """ pass def EnhancedLICOff(self): # real signature unknown; restored from __doc__ """ EnhancedLICOff(self) -> None C++: virtual void EnhancedLICOff() """ pass def EnhancedLICOn(self): # real signature unknown; restored from __doc__ """ EnhancedLICOn(self) -> None C++: virtual void EnhancedLICOn() """ pass def Execute(self, vectorTex, noiseTex): # real signature unknown; restored from __doc__ """ Execute(self, vectorTex:vtkTextureObject, noiseTex:vtkTextureObject) -> vtkTextureObject C++: vtkTextureObject *Execute(vtkTextureObject *vectorTex, vtkTextureObject *noiseTex) Execute(self, extent:(int, int, int, int), vectorTex:vtkTextureObject, noiseTex:vtkTextureObject) -> vtkTextureObject C++: vtkTextureObject *Execute(const int extent[4], vtkTextureObject *vectorTex, vtkTextureObject *noiseTex) Compute the lic on the entire vector field texture. """ pass def GetAntiAlias(self): # real signature unknown; restored from __doc__ """ GetAntiAlias(self) -> int C++: virtual int GetAntiAlias() """ return 0 def GetAntiAliasMaxValue(self): # real signature unknown; restored from __doc__ """ GetAntiAliasMaxValue(self) -> int C++: virtual int GetAntiAliasMaxValue() """ return 0 def GetAntiAliasMinValue(self): # real signature unknown; restored from __doc__ """ GetAntiAliasMinValue(self) -> int C++: virtual int GetAntiAliasMinValue() """ return 0 def GetComponentIds(self): # real signature unknown; restored from __doc__ """ GetComponentIds(self) -> (int, int) C++: virtual int *GetComponentIds() """ pass def GetContext(self): # real signature unknown; restored from __doc__ """ GetContext(self) -> vtkOpenGLRenderWindow C++: vtkOpenGLRenderWindow *GetContext() """ pass def GetEnhanceContrast(self): # real signature unknown; restored from __doc__ """ GetEnhanceContrast(self) -> int C++: virtual int GetEnhanceContrast() """ return 0 def GetEnhanceContrastMaxValue(self): # real signature unknown; restored from __doc__ """ GetEnhanceContrastMaxValue(self) -> int C++: virtual int GetEnhanceContrastMaxValue() """ return 0 def GetEnhanceContrastMinValue(self): # real signature unknown; restored from __doc__ """ GetEnhanceContrastMinValue(self) -> int C++: virtual int GetEnhanceContrastMinValue() """ return 0 def GetEnhancedLIC(self): # real signature unknown; restored from __doc__ """ GetEnhancedLIC(self) -> int C++: virtual int GetEnhancedLIC() """ return 0 def GetEnhancedLICMaxValue(self): # real signature unknown; restored from __doc__ """ GetEnhancedLICMaxValue(self) -> int C++: virtual int GetEnhancedLICMaxValue() """ return 0 def GetEnhancedLICMinValue(self): # real signature unknown; restored from __doc__ """ GetEnhancedLICMinValue(self) -> int C++: virtual int GetEnhancedLICMinValue() """ return 0 def GetHighContrastEnhancementFactor(self): # real signature unknown; restored from __doc__ """ GetHighContrastEnhancementFactor(self) -> float C++: virtual double GetHighContrastEnhancementFactor() """ return 0.0 def GetHighContrastEnhancementFactorMaxValue(self): # real signature unknown; restored from __doc__ """ GetHighContrastEnhancementFactorMaxValue(self) -> float C++: virtual double GetHighContrastEnhancementFactorMaxValue() """ return 0.0 def GetHighContrastEnhancementFactorMinValue(self): # real signature unknown; restored from __doc__ """ GetHighContrastEnhancementFactorMinValue(self) -> float C++: virtual double GetHighContrastEnhancementFactorMinValue() """ return 0.0 def GetLowContrastEnhancementFactor(self): # real signature unknown; restored from __doc__ """ GetLowContrastEnhancementFactor(self) -> float C++: virtual double GetLowContrastEnhancementFactor() """ return 0.0 def GetLowContrastEnhancementFactorMaxValue(self): # real signature unknown; restored from __doc__ """ GetLowContrastEnhancementFactorMaxValue(self) -> float C++: virtual double GetLowContrastEnhancementFactorMaxValue() """ return 0.0 def GetLowContrastEnhancementFactorMinValue(self): # real signature unknown; restored from __doc__ """ GetLowContrastEnhancementFactorMinValue(self) -> float C++: virtual double GetLowContrastEnhancementFactorMinValue() """ return 0.0 def GetMaskThreshold(self): # real signature unknown; restored from __doc__ """ GetMaskThreshold(self) -> float C++: virtual double GetMaskThreshold() """ return 0.0 def GetMaskThresholdMaxValue(self): # real signature unknown; restored from __doc__ """ GetMaskThresholdMaxValue(self) -> float C++: virtual double GetMaskThresholdMaxValue() """ return 0.0 def GetMaskThresholdMinValue(self): # real signature unknown; restored from __doc__ """ GetMaskThresholdMinValue(self) -> float C++: virtual double GetMaskThresholdMinValue() """ return 0.0 def GetMaxNoiseValue(self): # real signature unknown; restored from __doc__ """ GetMaxNoiseValue(self) -> float C++: virtual double GetMaxNoiseValue() """ return 0.0 def GetMaxNoiseValueMaxValue(self): # real signature unknown; restored from __doc__ """ GetMaxNoiseValueMaxValue(self) -> float C++: virtual double GetMaxNoiseValueMaxValue() """ return 0.0 def GetMaxNoiseValueMinValue(self): # real signature unknown; restored from __doc__ """ GetMaxNoiseValueMinValue(self) -> float C++: virtual double GetMaxNoiseValueMinValue() """ return 0.0 def GetNormalizeVectors(self): # real signature unknown; restored from __doc__ """ GetNormalizeVectors(self) -> int C++: virtual int GetNormalizeVectors() """ 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 GetNumberOfSteps(self): # real signature unknown; restored from __doc__ """ GetNumberOfSteps(self) -> int C++: virtual int GetNumberOfSteps() """ return 0 def GetNumberOfStepsMaxValue(self): # real signature unknown; restored from __doc__ """ GetNumberOfStepsMaxValue(self) -> int C++: virtual int GetNumberOfStepsMaxValue() """ return 0 def GetNumberOfStepsMinValue(self): # real signature unknown; restored from __doc__ """ GetNumberOfStepsMinValue(self) -> int C++: virtual int GetNumberOfStepsMinValue() """ return 0 def GetStepSize(self): # real signature unknown; restored from __doc__ """ GetStepSize(self) -> float C++: virtual double GetStepSize() """ return 0.0 def GetStepSizeMaxValue(self): # real signature unknown; restored from __doc__ """ GetStepSizeMaxValue(self) -> float C++: virtual double GetStepSizeMaxValue() """ return 0.0 def GetStepSizeMinValue(self): # real signature unknown; restored from __doc__ """ GetStepSizeMinValue(self) -> float C++: virtual double GetStepSizeMinValue() """ return 0.0 def GetTransformVectors(self): # real signature unknown; restored from __doc__ """ GetTransformVectors(self) -> int C++: virtual int GetTransformVectors() """ return 0 def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsSupported(self, renWin): # real signature unknown; restored from __doc__ """ IsSupported(renWin:vtkRenderWindow) -> bool C++: static bool IsSupported(vtkRenderWindow *renWin) Returns if the context supports the required extensions. """ 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) -> vtkLineIntegralConvolution2D C++: vtkLineIntegralConvolution2D *NewInstance() """ return vtkLineIntegralConvolution2D def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkLineIntegralConvolution2D C++: static vtkLineIntegralConvolution2D *SafeDownCast( vtkObjectBase *o) """ return vtkLineIntegralConvolution2D def SetAntiAlias(self, _arg): # real signature unknown; restored from __doc__ """ SetAntiAlias(self, _arg:int) -> None C++: virtual void SetAntiAlias(int _arg) Enable/Disable the anti-aliasing pass. This optional pass (disabled by default) can be enabled to reduce jagged patterns in the final LIC image. Values greater than 0 control the number of iterations, one is typically sufficient. """ pass def SetComponentIds(self, c0, c1): # real signature unknown; restored from __doc__ """ SetComponentIds(self, c0:int, c1:int) -> None C++: void SetComponentIds(int c0, int c1) SetComponentIds(self, c:[int, int]) -> None C++: void SetComponentIds(int c[2]) If VectorField has >= 3 components, we must choose which 2 components form the (X, Y) components for the vector field. Must be in the range [0, 3]. """ pass def SetContext(self, context): # real signature unknown; restored from __doc__ """ SetContext(self, context:vtkOpenGLRenderWindow) -> None C++: void SetContext(vtkOpenGLRenderWindow *context) Set/Get the rendering context. A reference is not explicitly held, thus reference to the context must be held externally. """ pass def SetEnhanceContrast(self, _arg): # real signature unknown; restored from __doc__ """ SetEnhanceContrast(self, _arg:int) -> None C++: virtual void SetEnhanceContrast(int _arg) """ pass def SetEnhancedLIC(self, _arg): # real signature unknown; restored from __doc__ """ SetEnhancedLIC(self, _arg:int) -> None C++: virtual void SetEnhancedLIC(int _arg) EnhancedLIC mean compute the LIC twice with the second pass using the edge-enhanced result of the first pass as a noise texture. Edge enhancedment is made by a simple Laplace convolution. """ pass def SetHighContrastEnhancementFactor(self, _arg): # real signature unknown; restored from __doc__ """ SetHighContrastEnhancementFactor(self, _arg:float) -> None C++: virtual void SetHighContrastEnhancementFactor(double _arg) """ pass def SetLowContrastEnhancementFactor(self, _arg): # real signature unknown; restored from __doc__ """ SetLowContrastEnhancementFactor(self, _arg:float) -> None C++: virtual void SetLowContrastEnhancementFactor(double _arg) This feature is used to fine tune the contrast enhancement. Values are provided indicating the fraction of the range to adjust m and M by during contrast enahncement histogram stretching. M and m are the intensity/lightness values that map to 1 and 0. (see EnhanceContrast for an explanation of the mapping procedure). m and M are computed using the factors as follows: * m = min(C) - mFactor * (max(C) - min(C)) * M = max(C) - MFactor * (max(C) - min(C)) * the default values for mFactor and MFactor are 0 which result in * m = min(C), M = max(C), where C is all of the colors in the image. Adjusting * mFactor and MFactor above zero provide a means to control the saturation of * normalization. These settings only affect the final normalization, the * normalization that occurs on the input to the high-pass filter always uses * the min and max. """ pass def SetMaskThreshold(self, _arg): # real signature unknown; restored from __doc__ """ SetMaskThreshold(self, _arg:float) -> None C++: virtual void SetMaskThreshold(double _arg) The MaskThreshold controls blanking of the LIC texture. For fragments with |V| None C++: virtual void SetMaxNoiseValue(double _arg) Set the max noise value for use during LIC integration normalization. The integration normalization factor is the max noise value times the number of steps taken. The default value is 1. """ pass def SetNoiseTexParameters(self, noise): # real signature unknown; restored from __doc__ """ SetNoiseTexParameters(noise:vtkTextureObject) -> None C++: static void SetNoiseTexParameters(vtkTextureObject *noise) """ pass def SetNormalizeVectors(self, val): # real signature unknown; restored from __doc__ """ SetNormalizeVectors(self, val:int) -> None C++: void SetNormalizeVectors(int val) Normalize vectors during integration. When set(the default) the input vector field is normalized during integration, and each integration occurs over the same arclength. When not set each integration occurs over an arc length proportional to the field magnitude as is customary in traditional numerical methods. See, "Imaging Vector Fields Using Line Integral Convolution" for an axample where normalization is used. See, "Image Space Based Visualization of Unsteady Flow on Surfaces" for an example of where no normalization is used. """ pass def SetNumberOfSteps(self, _arg): # real signature unknown; restored from __doc__ """ SetNumberOfSteps(self, _arg:int) -> None C++: virtual void SetNumberOfSteps(int _arg) Number of streamline integration steps (initial value is 1). In term of visual quality, the greater (within some range) the better. """ pass def SetStepSize(self, _arg): # real signature unknown; restored from __doc__ """ SetStepSize(self, _arg:float) -> None C++: virtual void SetStepSize(double _arg) Get/Set the streamline integration step size (0.01 by default). This is the length of each step in normalized image space i.e. in range [0, FLOAT_MAX]. In term of visual quality, the smaller the better. The type for the interface is double as VTK interface is, but GPU only supports float. Thus it will be converted to float in the execution of the algorithm. """ pass def SetTransformVectors(self, val): # real signature unknown; restored from __doc__ """ SetTransformVectors(self, val:int) -> None C++: void SetTransformVectors(int val) This class performs LIC in the normalized image space. Hence, by default it transforms the input vectors to the normalized image space (using the GridSpacings and input vector field dimensions). Set this to 0 to disable transformation if the vectors are already transformed. """ pass def SetVectorTexParameters(self, vectors): # real signature unknown; restored from __doc__ """ SetVectorTexParameters(vectors:vtkTextureObject) -> None C++: static void SetVectorTexParameters(vtkTextureObject *vectors) Convenience functions to ensure that the input textures are configured correctly. """ pass def WriteTimerLog(self, __a): # real signature unknown; restored from __doc__ """ WriteTimerLog(self, __a:str) -> None C++: virtual void WriteTimerLog(const char *) Methods used for parallel benchmarks. Use cmake to define vtkLineIntegralConviolution2DTIME to enable benchmarks. During each update timing information is stored, it can be written to disk by calling WriteLog. """ 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.""" ENHANCE_CONTRAST_OFF = 0 ENHANCE_CONTRAST_ON = 1 __dict__ = None # (!) real value is 'mappingproxy({\'__vtkname__\': \'vtkLineIntegralConvolution2D\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'IsSupported\': , \'SetContext\': , \'GetContext\': , \'SetEnhancedLIC\': , \'GetEnhancedLICMinValue\': , \'GetEnhancedLICMaxValue\': , \'GetEnhancedLIC\': , \'EnhancedLICOn\': , \'EnhancedLICOff\': , \'SetEnhanceContrast\': , \'GetEnhanceContrastMinValue\': , \'GetEnhanceContrastMaxValue\': , \'GetEnhanceContrast\': , \'EnhanceContrastOn\': , \'EnhanceContrastOff\': , \'SetLowContrastEnhancementFactor\': , \'GetLowContrastEnhancementFactorMinValue\': , \'GetLowContrastEnhancementFactorMaxValue\': , \'GetLowContrastEnhancementFactor\': , \'SetHighContrastEnhancementFactor\': , \'GetHighContrastEnhancementFactorMinValue\': , \'GetHighContrastEnhancementFactorMaxValue\': , \'GetHighContrastEnhancementFactor\': , \'SetAntiAlias\': , \'GetAntiAliasMinValue\': , \'GetAntiAliasMaxValue\': , \'GetAntiAlias\': , \'AntiAliasOn\': , \'AntiAliasOff\': , \'SetNumberOfSteps\': , \'GetNumberOfStepsMinValue\': , \'GetNumberOfStepsMaxValue\': , \'GetNumberOfSteps\': , \'SetStepSize\': , \'GetStepSizeMinValue\': , \'GetStepSizeMaxValue\': , \'GetStepSize\': , \'SetComponentIds\': , \'GetComponentIds\': , \'SetMaxNoiseValue\': , \'GetMaxNoiseValueMinValue\': , \'GetMaxNoiseValueMaxValue\': , \'GetMaxNoiseValue\': , \'SetTransformVectors\': , \'GetTransformVectors\': , \'SetNormalizeVectors\': , \'GetNormalizeVectors\': , \'SetMaskThreshold\': , \'GetMaskThresholdMinValue\': , \'GetMaskThresholdMaxValue\': , \'GetMaskThreshold\': , \'Execute\': , \'SetVectorTexParameters\': , \'SetNoiseTexParameters\': , \'WriteTimerLog\': , \'ENHANCE_CONTRAST_OFF\': 0, \'ENHANCE_CONTRAST_ON\': 1, \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': "vtkLineIntegralConvolution2D - GPU-based implementation of Line\\n Integral Convolution (LIC)\\n\\nSuperclass: vtkObject\\n\\nThis class resorts to GLSL to implement GPU-based Line Integral\\nConvolution\\n (LIC) for visualizing a 2D vector field that may be obtained by\\nprojecting\\n an original 3D vector field onto a surface (such that the resulting\\n2D\\n vector at each grid point on the surface is tangential to the local\\nnormal,\\n as done in vtkSurfaceLICPainter).\\n\\n\\n As an image-based technique, 2D LIC works by (1) integrating a\\nbidirectional\\n streamline from the center of each pixel (of the LIC output image),\\n(2)\\n locating the pixels along / hit by this streamline as the correlated\\npixels\\n of the starting pixel (seed point / pixel), (3) indexing a (usually\\nwhite)\\n noise texture (another input to LIC, in addition to the 2D vector\\nfield,\\n usually with the same size as that of the 2D vector field) to\\ndetermine the\\n values (colors) of these pixels (the starting and the correlated\\npixels),\\n typically through bi-linear interpolation, and (4) performing\\nconvolution\\n (weighted averaging) on these values, by adopting a low-pass filter\\n(such\\n as box, ramp, and Hanning kernels), to obtain the result value\\n(color) that\\n is then assigned to the seed pixel.\\n\\n\\n The GLSL-based GPU implementation herein maps the aforementioned\\npipeline to\\n fragment shaders and a box kernel is employed. Both the white noise\\nand the\\n vector field are provided to the GPU as texture objects (supported\\nby the\\n multi-texturing capability). In addition, there are four texture\\nobjects\\n (color buffers) allocated to constitute two pairs that work in a\\nping-pong\\n fashion, with one as the read buffers and the other as the write /\\nrender\\n targets. Maintained by a frame buffer object\\n(GL_EXT_framebuffer_object),\\n each pair employs one buffer to store the current (dynamically\\nupdated)\\n position (by means of the texture coordinate that keeps being warped\\nby the\\n underlying vector) of the (virtual) particle initially released from\\neach\\n fragment while using the bother buffer to store the current\\n(dynamically\\n updated too) accumulated texture value that each seed fragment\\n(before the\\n \'mesh\' is warped) collects. Given NumberOfSteps integration steps in\\neach\\n direction, there are a total of (2 * NumberOfSteps + 1) fragments\\n(including\\n the seed fragment) are convolved and each contributes 1 / (2 *\\nNumberOfSteps\\n + 1) of the associated texture value to fulfill the box filter.\\n\\n\\n One pass of LIC (basic LIC) tends to produce low-contrast / blurred\\nimages and\\n vtkLineIntegralConvolution2D provides an option for creating\\nenhanced LIC\\n images. Enhanced LIC improves image quality by increasing\\ninter-streamline\\n contrast while suppressing artifacts. It performs two passes of LIC,\\nwith a\\n 3x3 Laplacian high-pass filter in between that processes the output\\nof pass\\n#1 LIC and forwards the result as the input \'noise\' to pass #2 LIC.\\n\\n\\n vtkLineIntegralConvolution2D applies masking to zero-vector\\nfragments so\\n that un-filtered white noise areas are made totally transparent by\\nclass\\n vtkSurfaceLICPainter to show the underlying geometry surface.\\n\\n\\n The convolution process tends to decrease both contrast and dynamic\\nrange,\\n sometimes leading to dull dark images. In order to counteract this,\\noptional\\n contrast ehnancement stages have been added. These increase the\\ndynamic range and\\n contrast and sharpen streaking patterns that emerge from the LIC\\nprocess.\\n\\n\\n Under some circumstances, typically depending on the contrast and\\ndynamic\\n range and graininess of the noise texture, jagged or pixelated\\npatterns emerge\\n in the LIC. These can be reduced by enabling the optional\\nanti-aliasing pass.\\n\\n\\n The internal pipeline is as follows, with optional stages denoted by\\n()\\n nested optional stages depend on their parent stage.\\n\\n\\n noise texture\\n |\\n [ LIC ((CE) HPF LIC) (AA) (CE) ]\\n | |\\n vector field LIC\'d image \\n where LIC is the LIC stage, HPF is the high-pass filter stage, CE is\\nthe\\n contrast ehnacement stage, and AA is the antialias stage.\\n\\n@sa\\n vtkImageDataLIC2D vtkStructuredGridLIC2D\\n\\n"})' __vtkname__ = 'vtkLineIntegralConvolution2D' class vtkPainterCommunicator(object): """ vtkPainterCommunicator() -> vtkPainterCommunicator C++: vtkPainterCommunicator() vtkPainterCommunicator(other:vtkPainterCommunicator) -> vtkPainterCommunicator C++: vtkPainterCommunicator(const vtkPainterCommunicator &other) vtkPainterCommunicator - A communicator that can safely be used inside a painter. A simple container holding a handle to an MPI communicator. This API is sufficient to allow for control flow with/without MPI. The parallel parts of the code should use the derived class vtkPPainterCommunicator. """ def GetIsNull(self): # real signature unknown; restored from __doc__ """ GetIsNull(self) -> bool C++: virtual bool GetIsNull() """ return False def GetMPIFinalized(self): # real signature unknown; restored from __doc__ """ GetMPIFinalized(self) -> bool C++: virtual bool GetMPIFinalized() """ return False def GetMPIInitialized(self): # real signature unknown; restored from __doc__ """ GetMPIInitialized(self) -> bool C++: virtual bool GetMPIInitialized() Query MPI about its state. """ return False def GetRank(self): # real signature unknown; restored from __doc__ """ GetRank(self) -> int C++: virtual int GetRank() Query MPI about the communicator. """ return 0 def GetSize(self): # real signature unknown; restored from __doc__ """ GetSize(self) -> int C++: virtual int GetSize() """ return 0 def GetWorldRank(self): # real signature unknown; restored from __doc__ """ GetWorldRank(self) -> int C++: virtual int GetWorldRank() Query MPI about the world communicator. """ return 0 def GetWorldSize(self): # real signature unknown; restored from __doc__ """ GetWorldSize(self) -> int C++: virtual int GetWorldSize() """ return 0 def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __hash__(self, *args, **kwargs): # real signature unknown """ Return hash(self). """ pass def __init__(self): # real signature unknown; restored from __doc__ 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 class vtkStructuredGridLIC2D(__vtkmodules_vtkCommonExecutionModel.vtkStructuredGridAlgorithm): """ vtkStructuredGridLIC2D - GPU implementation of a Line Integral Convolution, a technique for imaging vector fields. Superclass: vtkStructuredGridAlgorithm The input on port 0 is an 2D vtkStructuredGrid. It needs a vector field on point data. Port 1 is a special port for customized noise input. It is an optional port. If not present, noise is generated by the filter. Even if none-power-of-two texture are supported, giving a power-of-two image may result in faster execution on the GPU. Please refer to Forssell, L. K., "Visualizing flow over curvilinear grid surfaces using line integral convolution", Visualization 94 Conference Proceedings, pages 240-247, IEEE Computer Society, 1994 for details of the algorithm. @par Required OpenGL Extensions: GL_ARB_texture_non_power_of_two GL_VERSION_2_0 GL_ARB_texture_float GL_ARB_draw_buffers GL_EXT_framebuffer_object GL_ARB_pixel_buffer_object """ def GetContext(self): # real signature unknown; restored from __doc__ """ GetContext(self) -> vtkRenderWindow C++: vtkRenderWindow *GetContext() """ pass def GetFBOSuccess(self): # real signature unknown; restored from __doc__ """ GetFBOSuccess(self) -> int C++: int GetFBOSuccess() Check if FBO is started properly. """ return 0 def GetLICSuccess(self): # real signature unknown; restored from __doc__ """ GetLICSuccess(self) -> int C++: int GetLICSuccess() Check if LIC runs properly. """ return 0 def GetMagnification(self): # real signature unknown; restored from __doc__ """ GetMagnification(self) -> int C++: virtual int GetMagnification() """ return 0 def GetMagnificationMaxValue(self): # real signature unknown; restored from __doc__ """ GetMagnificationMaxValue(self) -> int C++: virtual int GetMagnificationMaxValue() """ return 0 def GetMagnificationMinValue(self): # real signature unknown; restored from __doc__ """ GetMagnificationMinValue(self) -> int C++: virtual int GetMagnificationMinValue() """ 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 GetSteps(self): # real signature unknown; restored from __doc__ """ GetSteps(self) -> int C++: virtual int GetSteps() """ return 0 def GetStepSize(self): # real signature unknown; restored from __doc__ """ GetStepSize(self) -> float C++: virtual double GetStepSize() """ 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) -> vtkStructuredGridLIC2D C++: vtkStructuredGridLIC2D *NewInstance() """ return vtkStructuredGridLIC2D def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkStructuredGridLIC2D C++: static vtkStructuredGridLIC2D *SafeDownCast(vtkObjectBase *o) """ return vtkStructuredGridLIC2D def SetContext(self, context): # real signature unknown; restored from __doc__ """ SetContext(self, context:vtkRenderWindow) -> int C++: int SetContext(vtkRenderWindow *context) Get/Set the context. Context must be a vtkOpenGLRenderWindow. This does not increase the reference count of the context to avoid reference loops. SetContext() may raise an error if the OpenGL context does not support the required OpenGL extensions. Return 0 upon failure and 1 upon success. """ return 0 def SetMagnification(self, _arg): # real signature unknown; restored from __doc__ """ SetMagnification(self, _arg:int) -> None C++: virtual void SetMagnification(int _arg) The magnification factor. Default is 1 """ pass def SetSteps(self, _arg): # real signature unknown; restored from __doc__ """ SetSteps(self, _arg:int) -> None C++: virtual void SetSteps(int _arg) Number of steps. Initial value is 1. class invariant: Steps>0. In term of visual quality, the greater the better. """ pass def SetStepSize(self, _arg): # real signature unknown; restored from __doc__ """ SetStepSize(self, _arg:float) -> None C++: virtual void SetStepSize(double _arg) Step size. WE ARE NOT SURE YET about the space where we define the step. If the image data has different spacing in each dimension, it is an issue. Initial value is 1.0. class invariant: StepSize>0.0. In term of visual quality, the smaller the better. The type for the interface is double as VTK interface is double but GPU only supports float. This value will be converted to float in the execution of the algorithm. """ pass def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is 'mappingproxy({\'__vtkname__\': \'vtkStructuredGridLIC2D\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'SetContext\': , \'GetContext\': , \'SetSteps\': , \'GetSteps\': , \'SetStepSize\': , \'GetStepSize\': , \'SetMagnification\': , \'GetMagnificationMinValue\': , \'GetMagnificationMaxValue\': , \'GetMagnification\': , \'GetFBOSuccess\': , \'GetLICSuccess\': , \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': \'vtkStructuredGridLIC2D - GPU implementation of a Line Integral\\nConvolution, a technique for imaging vector fields.\\n\\nSuperclass: vtkStructuredGridAlgorithm\\n\\nThe input on port 0 is an 2D vtkStructuredGrid. It needs a vector\\nfield on point data. Port 1 is a special port for customized noise\\ninput. It is an optional port. If not present, noise is generated by\\nthe filter. Even if none-power-of-two texture are supported, giving a\\npower-of-two image may result in faster execution on the GPU.\\n\\nPlease refer to Forssell, L. K., "Visualizing flow over curvilinear\\ngrid surfaces using line integral convolution", Visualization 94\\nConference Proceedings, pages 240-247, IEEE Computer Society, 1994\\nfor details of the algorithm.\\n\\n@par Required OpenGL Extensions: GL_ARB_texture_non_power_of_two\\nGL_VERSION_2_0 GL_ARB_texture_float GL_ARB_draw_buffers\\nGL_EXT_framebuffer_object GL_ARB_pixel_buffer_object\\n\\n\'})' __vtkname__ = 'vtkStructuredGridLIC2D' class vtkSurfaceLICComposite(__vtkmodules_vtkCommonCore.vtkObject): """ vtkSurfaceLICComposite - This class decomposes the image space and shuffles image space data onto the new decomposition with the necessary guard cells to prevent artifacts at the decomposition boundaries. Superclass: vtkObject After the image LIC is computed on the new decomposition this class will un-shuffle the computed LIC back onto the original decomposition """ def BuildProgram(self, __a, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ BuildProgram(self, __a:[float, ...]) -> int C++: virtual int BuildProgram(float *) Build programs to move data to the new decomp In parallel THIS IS A COLLECTIVE OPERATION """ pass def GetCompositeExtent(self, i=0): # real signature unknown; restored from __doc__ """ GetCompositeExtent(self, i:int=0) -> vtkPixelExtent C++: const vtkPixelExtent &GetCompositeExtent(int i=0) Get the extent of the domain over which to compute the LIC. This can be querried only after the Composite takes place. """ pass def GetContext(self): # real signature unknown; restored from __doc__ """ GetContext(self) -> vtkOpenGLRenderWindow C++: virtual vtkOpenGLRenderWindow *GetContext() """ pass def GetDataSetExtent(self): # real signature unknown; restored from __doc__ """ GetDataSetExtent(self) -> vtkPixelExtent C++: const vtkPixelExtent &GetDataSetExtent() Get the whole dataset extent (all blocks). """ pass def GetDisjointGuardExtent(self, i=0): # real signature unknown; restored from __doc__ """ GetDisjointGuardExtent(self, i:int=0) -> vtkPixelExtent C++: const vtkPixelExtent &GetDisjointGuardExtent(int i=0) Get the extent of the domain over which to compute the LIC. This can be querried only after the Composite takes place. """ pass def GetGuardExtent(self, i=0): # real signature unknown; restored from __doc__ """ GetGuardExtent(self, i:int=0) -> vtkPixelExtent C++: const vtkPixelExtent &GetGuardExtent(int i=0) Get the extent of the domain over which to compute the LIC. This can be querried only after the Composite takes place. """ pass def GetNumberOfCompositeExtents(self): # real signature unknown; restored from __doc__ """ GetNumberOfCompositeExtents(self) -> int C++: int GetNumberOfCompositeExtents() Get the number of new extents assigned to this rank after the decomposition. """ 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 GetStrategy(self): # real signature unknown; restored from __doc__ """ GetStrategy(self) -> int C++: int GetStrategy() """ return 0 def GetWindowExtent(self): # real signature unknown; restored from __doc__ """ GetWindowExtent(self) -> vtkPixelExtent C++: const vtkPixelExtent &GetWindowExtent() Get the whole window extent. """ pass def InitializeCompositeExtents(self, vectors, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InitializeCompositeExtents(self, vectors:[float, ...]) -> int C++: int InitializeCompositeExtents(float *vectors) Set up for a serial run, makes the decomp disjoint and adds requisite guard pixles. """ 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) -> vtkSurfaceLICComposite C++: vtkSurfaceLICComposite *NewInstance() """ return vtkSurfaceLICComposite def RestoreDefaultCommunicator(self): # real signature unknown; restored from __doc__ """ RestoreDefaultCommunicator(self) -> None C++: virtual void RestoreDefaultCommunicator() Set the communicator to the default communicator """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkSurfaceLICComposite C++: static vtkSurfaceLICComposite *SafeDownCast(vtkObjectBase *o) """ return vtkSurfaceLICComposite def SetContext(self, __a): # real signature unknown; restored from __doc__ """ SetContext(self, __a:vtkOpenGLRenderWindow) -> None C++: virtual void SetContext(vtkOpenGLRenderWindow *) Set the rendering context. Must set prior to use. Reference is not held, so caller must ensure the renderer is not destroyed during use. """ pass def SetStrategy(self, val): # real signature unknown; restored from __doc__ """ SetStrategy(self, val:int) -> None C++: void SetStrategy(int val) """ 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.""" COMPOSITE_AUTO = 3 COMPOSITE_BALANCED = 2 COMPOSITE_INPLACE = 0 COMPOSITE_INPLACE_DISJOINT = 1 __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkSurfaceLICComposite', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'SetStrategy': , 'GetStrategy': , 'GetNumberOfCompositeExtents': , 'GetGuardExtent': , 'GetDisjointGuardExtent': , 'GetCompositeExtent': , 'GetDataSetExtent': , 'GetWindowExtent': , 'InitializeCompositeExtents': , 'SetContext': , 'GetContext': , 'RestoreDefaultCommunicator': , 'BuildProgram': , 'COMPOSITE_INPLACE': 0, 'COMPOSITE_INPLACE_DISJOINT': 1, 'COMPOSITE_BALANCED': 2, 'COMPOSITE_AUTO': 3, '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkSurfaceLICComposite - This class decomposes the image space and\\nshuffles image space data onto the new decomposition with the\\nnecessary guard cells to prevent artifacts at the decomposition\\nboundaries.\\n\\nSuperclass: vtkObject\\n\\nAfter the image LIC is computed on the new decomposition this class\\nwill un-shuffle the computed LIC back onto the original decomposition\\n\\n'})" __vtkname__ = 'vtkSurfaceLICComposite' class vtkSurfaceLICInterface(__vtkmodules_vtkCommonCore.vtkObject): """ vtkSurfaceLICInterface - public API for surface lic parameters arbitrary geometry. Superclass: vtkObject vtkSurfaceLICInterface performs LIC on the surface of arbitrary geometry. Point vectors are used as the vector field for generating the LIC. The implementation was originallu based on "Image Space Based Visualization on Unsteady Flow on Surfaces" by Laramee, Jobard and Hauser appeared in proceedings of IEEE Visualization '03, pages 131-138. Internal pipeline: noise | [ PROJ (GAT) (COMP) LIC2D (SCAT) SHADE (CCE) DEP] | | vectors surface LIC PROj - project vectors onto surface GAT - gather data for compositing and guard pixel generation (parallel only) COMP - composite gathered data LIC2D - line intengral convolution, see vtkLineIntegralConvolution2D. SCAT - scatter result (parallel only, not all compositors use it) SHADE - combine LIC and scalar colors CCE - color contrast enhancement (optional) DEP - depth test and copy to back buffer The result of each stage is cached in a texture so that during interaction a stage may be skipped if the user has not modified its parameters or input data. The parallel parts of algorithm are implemented in vtkPSurfaceLICInterface. Note that for MPI enabled builds this class will be automatically created by the object factory. @sa vtkLineIntegralConvolution2D """ def AntiAliasOff(self): # real signature unknown; restored from __doc__ """ AntiAliasOff(self) -> None C++: virtual void AntiAliasOff() """ pass def AntiAliasOn(self): # real signature unknown; restored from __doc__ """ AntiAliasOn(self) -> None C++: virtual void AntiAliasOn() """ pass def ApplyLIC(self): # real signature unknown; restored from __doc__ """ ApplyLIC(self) -> None C++: void ApplyLIC() """ pass def CanRenderSurfaceLIC(self, actor): # real signature unknown; restored from __doc__ """ CanRenderSurfaceLIC(self, actor:vtkActor) -> bool C++: bool CanRenderSurfaceLIC(vtkActor *actor) Returns true when rendering LIC is possible. """ return False def CombineColorsAndLIC(self): # real signature unknown; restored from __doc__ """ CombineColorsAndLIC(self) -> None C++: void CombineColorsAndLIC() """ pass def CompletedGeometry(self): # real signature unknown; restored from __doc__ """ CompletedGeometry(self) -> None C++: void CompletedGeometry() """ pass def CopyToScreen(self): # real signature unknown; restored from __doc__ """ CopyToScreen(self) -> None C++: void CopyToScreen() """ pass def CreateCommunicator(self, __a, __b, data): # real signature unknown; restored from __doc__ """ CreateCommunicator(self, __a:vtkRenderer, __b:vtkActor, data:vtkDataObject) -> None C++: void CreateCommunicator(vtkRenderer *, vtkActor *, vtkDataObject *data) Creates a new communicator for internal use based on this rank's visible data. """ pass def EnableOff(self): # real signature unknown; restored from __doc__ """ EnableOff(self) -> None C++: virtual void EnableOff() """ pass def EnableOn(self): # real signature unknown; restored from __doc__ """ EnableOn(self) -> None C++: virtual void EnableOn() """ pass def EnhancedLICOff(self): # real signature unknown; restored from __doc__ """ EnhancedLICOff(self) -> None C++: virtual void EnhancedLICOff() """ pass def EnhancedLICOn(self): # real signature unknown; restored from __doc__ """ EnhancedLICOn(self) -> None C++: virtual void EnhancedLICOn() """ pass def GatherVectors(self): # real signature unknown; restored from __doc__ """ GatherVectors(self) -> None C++: void GatherVectors() """ pass def GetAntiAlias(self): # real signature unknown; restored from __doc__ """ GetAntiAlias(self) -> int C++: virtual int GetAntiAlias() """ return 0 def GetColorMode(self): # real signature unknown; restored from __doc__ """ GetColorMode(self) -> int C++: virtual int GetColorMode() """ return 0 def GetCompositeStrategy(self): # real signature unknown; restored from __doc__ """ GetCompositeStrategy(self) -> int C++: virtual int GetCompositeStrategy() """ return 0 def GetEnable(self): # real signature unknown; restored from __doc__ """ GetEnable(self) -> int C++: virtual int GetEnable() """ return 0 def GetEnhanceContrast(self): # real signature unknown; restored from __doc__ """ GetEnhanceContrast(self) -> int C++: virtual int GetEnhanceContrast() """ return 0 def GetEnhancedLIC(self): # real signature unknown; restored from __doc__ """ GetEnhancedLIC(self) -> int C++: virtual int GetEnhancedLIC() """ return 0 def GetGenerateNoiseTexture(self): # real signature unknown; restored from __doc__ """ GetGenerateNoiseTexture(self) -> int C++: virtual int GetGenerateNoiseTexture() """ return 0 def GetHasVectors(self): # real signature unknown; restored from __doc__ """ GetHasVectors(self) -> bool C++: bool GetHasVectors() """ return False def GetHighColorContrastEnhancementFactor(self): # real signature unknown; restored from __doc__ """ GetHighColorContrastEnhancementFactor(self) -> float C++: virtual double GetHighColorContrastEnhancementFactor() """ return 0.0 def GetHighLICContrastEnhancementFactor(self): # real signature unknown; restored from __doc__ """ GetHighLICContrastEnhancementFactor(self) -> float C++: virtual double GetHighLICContrastEnhancementFactor() """ return 0.0 def GetImpulseNoiseBackgroundValue(self): # real signature unknown; restored from __doc__ """ GetImpulseNoiseBackgroundValue(self) -> float C++: virtual double GetImpulseNoiseBackgroundValue() """ return 0.0 def GetImpulseNoiseProbability(self): # real signature unknown; restored from __doc__ """ GetImpulseNoiseProbability(self) -> float C++: virtual double GetImpulseNoiseProbability() """ return 0.0 def GetLICIntensity(self): # real signature unknown; restored from __doc__ """ GetLICIntensity(self) -> float C++: virtual double GetLICIntensity() """ return 0.0 def GetLowColorContrastEnhancementFactor(self): # real signature unknown; restored from __doc__ """ GetLowColorContrastEnhancementFactor(self) -> float C++: virtual double GetLowColorContrastEnhancementFactor() """ return 0.0 def GetLowLICContrastEnhancementFactor(self): # real signature unknown; restored from __doc__ """ GetLowLICContrastEnhancementFactor(self) -> float C++: virtual double GetLowLICContrastEnhancementFactor() This feature is used to fine tune the contrast enhancement. There are two modes AUTOMATIC and MANUAL.In AUTOMATIC mode values are provided indicating the fraction of the range to adjust M and m by, during contrast enahncement histogram stretching. M and m are the intensity/lightness values that map to 1 and 0. (see EnhanceContrast for an explanation of the mapping procedure). m and M are computed using the factors as follows: * m = min(C) + mFactor * (max(C) - min(C)) * M = max(C) - MFactor * (max(C) - min(C)) * the default values for mFactor and MFactor are 0 which result in * m = min(C), M = max(C), taken over the entire image. Modifying mFactor and * MFactor above or below zero provide control over the saturation/ * de-saturation during contrast enhancement. """ return 0.0 def GetMapModeBias(self): # real signature unknown; restored from __doc__ """ GetMapModeBias(self) -> float C++: virtual double GetMapModeBias() """ return 0.0 def GetMaskColor(self): # real signature unknown; restored from __doc__ """ GetMaskColor(self) -> (float, float, float) C++: virtual double *GetMaskColor() """ pass def GetMaskIntensity(self): # real signature unknown; restored from __doc__ """ GetMaskIntensity(self) -> float C++: virtual double GetMaskIntensity() """ return 0.0 def GetMaskOnSurface(self): # real signature unknown; restored from __doc__ """ GetMaskOnSurface(self) -> int C++: virtual int GetMaskOnSurface() """ return 0 def GetMaskThreshold(self): # real signature unknown; restored from __doc__ """ GetMaskThreshold(self) -> float C++: virtual double GetMaskThreshold() """ return 0.0 def GetMaxNoiseValue(self): # real signature unknown; restored from __doc__ """ GetMaxNoiseValue(self) -> float C++: virtual double GetMaxNoiseValue() """ return 0.0 def GetMinNoiseValue(self): # real signature unknown; restored from __doc__ """ GetMinNoiseValue(self) -> float C++: virtual double GetMinNoiseValue() """ return 0.0 def GetNoiseDataSet(self): # real signature unknown; restored from __doc__ """ GetNoiseDataSet(self) -> vtkImageData C++: vtkImageData *GetNoiseDataSet() """ pass def GetNoiseGeneratorSeed(self): # real signature unknown; restored from __doc__ """ GetNoiseGeneratorSeed(self) -> int C++: virtual int GetNoiseGeneratorSeed() """ return 0 def GetNoiseGrainSize(self): # real signature unknown; restored from __doc__ """ GetNoiseGrainSize(self) -> int C++: virtual int GetNoiseGrainSize() """ return 0 def GetNoiseTextureSize(self): # real signature unknown; restored from __doc__ """ GetNoiseTextureSize(self) -> int C++: virtual int GetNoiseTextureSize() """ return 0 def GetNoiseType(self): # real signature unknown; restored from __doc__ """ GetNoiseType(self) -> int C++: virtual int GetNoiseType() """ return 0 def GetNormalizeVectors(self): # real signature unknown; restored from __doc__ """ GetNormalizeVectors(self) -> int C++: virtual int GetNormalizeVectors() """ 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 GetNumberOfNoiseLevels(self): # real signature unknown; restored from __doc__ """ GetNumberOfNoiseLevels(self) -> int C++: virtual int GetNumberOfNoiseLevels() """ return 0 def GetNumberOfSteps(self): # real signature unknown; restored from __doc__ """ GetNumberOfSteps(self) -> int C++: virtual int GetNumberOfSteps() """ return 0 def GetStepSize(self): # real signature unknown; restored from __doc__ """ GetStepSize(self) -> float C++: virtual double GetStepSize() """ return 0.0 def InitializeResources(self): # real signature unknown; restored from __doc__ """ InitializeResources(self) -> None C++: void InitializeResources() resoucre allocators """ 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 IsSupported(self, context): # real signature unknown; restored from __doc__ """ IsSupported(context:vtkRenderWindow) -> bool C++: static bool IsSupported(vtkRenderWindow *context) Returns true if the rendering context supports extensions needed by this painter. """ 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 MaskOnSurfaceOff(self): # real signature unknown; restored from __doc__ """ MaskOnSurfaceOff(self) -> None C++: virtual void MaskOnSurfaceOff() """ pass def MaskOnSurfaceOn(self): # real signature unknown; restored from __doc__ """ MaskOnSurfaceOn(self) -> None C++: virtual void MaskOnSurfaceOn() """ pass def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkSurfaceLICInterface C++: vtkSurfaceLICInterface *NewInstance() """ return vtkSurfaceLICInterface def NormalizeVectorsOff(self): # real signature unknown; restored from __doc__ """ NormalizeVectorsOff(self) -> None C++: virtual void NormalizeVectorsOff() """ pass def NormalizeVectorsOn(self): # real signature unknown; restored from __doc__ """ NormalizeVectorsOn(self) -> None C++: virtual void NormalizeVectorsOn() """ pass def PrepareForGeometry(self): # real signature unknown; restored from __doc__ """ PrepareForGeometry(self) -> None C++: void PrepareForGeometry() """ pass def ReleaseGraphicsResources(self, win): # real signature unknown; restored from __doc__ """ ReleaseGraphicsResources(self, win:vtkWindow) -> None C++: virtual void ReleaseGraphicsResources(vtkWindow *win) Release any graphics resources that are being consumed by this mapper. The parameter window could be used to determine which graphic resources to release. In this case, releases the display lists. """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkSurfaceLICInterface C++: static vtkSurfaceLICInterface *SafeDownCast(vtkObjectBase *o) """ return vtkSurfaceLICInterface def SetAntiAlias(self, val): # real signature unknown; restored from __doc__ """ SetAntiAlias(self, val:int) -> None C++: void SetAntiAlias(int val) Enable/Disable the anti-aliasing pass. This optional pass (disabled by default) can be enabled to reduce jagged patterns in the final LIC image. Values greater than 0 control the number of iterations, 1 is typically sufficient. """ pass def SetColorMode(self, val): # real signature unknown; restored from __doc__ """ SetColorMode(self, val:int) -> None C++: void SetColorMode(int val) """ pass def SetCompositeStrategy(self, val): # real signature unknown; restored from __doc__ """ SetCompositeStrategy(self, val:int) -> None C++: void SetCompositeStrategy(int val) """ pass def SetEnable(self, _arg): # real signature unknown; restored from __doc__ """ SetEnable(self, _arg:int) -> None C++: virtual void SetEnable(int _arg) Enable/Disable LIC. """ pass def SetEnhanceContrast(self, val): # real signature unknown; restored from __doc__ """ SetEnhanceContrast(self, val:int) -> None C++: void SetEnhanceContrast(int val) """ pass def SetEnhancedLIC(self, val): # real signature unknown; restored from __doc__ """ SetEnhancedLIC(self, val:int) -> None C++: void SetEnhancedLIC(int val) EnhancedLIC mean compute the LIC twice with the second pass using the edge-enhanced result of the first pass as a noise texture. Edge enhancedment is made by a simple Laplace convolution. """ pass def SetGenerateNoiseTexture(self, shouldGenerate): # real signature unknown; restored from __doc__ """ SetGenerateNoiseTexture(self, shouldGenerate:int) -> None C++: void SetGenerateNoiseTexture(int shouldGenerate) Set/Get the noise texture source. When not set the default 200x200 white noise texture is used (see VTKData/Data/Data/noise.png). When set a noise texture is generated based on the following parameters: * NoiseType - select noise type. Gaussian, Uniform, etc * NoiseTextureSize - number of pixels in square noise texture(side) * NoiseGrainSize - number of pixels each noise value spans(side) * MinNoiseValue - minimum noise color >=0 && < MaxNoiseValue * MaxNoiseValue - maximum noise color <=1 ** > MinNoiseValue * NumberOfNoiseLevels - number of discrete noise colors * ImpulseNoiseProbability - impulse noise is generated when < 1 * ImpulseNoiseBackgroundValue - the background color for untouched pixels * NoiseGeneratorSeed - seed the random number generators * Changing the noise texture gives one greater control over the look of the * final image. The default is 0 which results in the use of a static 200x200 * Gaussian noise texture. See VTKData/Data/Data/noise.png. """ pass def SetHasVectors(self, val): # real signature unknown; restored from __doc__ """ SetHasVectors(self, val:bool) -> None C++: void SetHasVectors(bool val) Does the data have vectors which we require """ pass def SetHighColorContrastEnhancementFactor(self, val): # real signature unknown; restored from __doc__ """ SetHighColorContrastEnhancementFactor(self, val:float) -> None C++: void SetHighColorContrastEnhancementFactor(double val) """ pass def SetHighLICContrastEnhancementFactor(self, val): # real signature unknown; restored from __doc__ """ SetHighLICContrastEnhancementFactor(self, val:float) -> None C++: void SetHighLICContrastEnhancementFactor(double val) """ pass def SetImpulseNoiseBackgroundValue(self, val): # real signature unknown; restored from __doc__ """ SetImpulseNoiseBackgroundValue(self, val:float) -> None C++: void SetImpulseNoiseBackgroundValue(double val) The color to use for untouched pixels when impulse noise probability < 1. """ pass def SetImpulseNoiseProbability(self, val): # real signature unknown; restored from __doc__ """ SetImpulseNoiseProbability(self, val:float) -> None C++: void SetImpulseNoiseProbability(double val) Control the density of the noise. A value of 1.0 produces uniform random noise while values < 1.0 produce impulse noise with the given probability. """ pass def SetLICIntensity(self, val): # real signature unknown; restored from __doc__ """ SetLICIntensity(self, val:float) -> None C++: void SetLICIntensity(double val) Factor used when blend mode is set to COLOR_MODE_BLEND. This controls the contribution of the LIC in the final output image as follows: * c = LIC * LICIntensity + scalar * (1 - LICIntensity); * 0.0 produces same result as disabling LIC altogether, while 1.0 implies * show LIC result alone. """ pass def SetLowColorContrastEnhancementFactor(self, val): # real signature unknown; restored from __doc__ """ SetLowColorContrastEnhancementFactor(self, val:float) -> None C++: void SetLowColorContrastEnhancementFactor(double val) """ pass def SetLowLICContrastEnhancementFactor(self, val): # real signature unknown; restored from __doc__ """ SetLowLICContrastEnhancementFactor(self, val:float) -> None C++: void SetLowLICContrastEnhancementFactor(double val) """ pass def SetMapModeBias(self, val): # real signature unknown; restored from __doc__ """ SetMapModeBias(self, val:float) -> None C++: void SetMapModeBias(double val) Factor used when blend mode is set to COLOR_MODE_MAP. This adds a bias to the LIC image. The purpose of this is to adjust the brightness when a brighter image is desired. The default of 0.0 results in no change. Values gretaer than 0.0 will brighten the image while values less than 0.0 darken the image. """ pass def SetMaskColor(self, val, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ SetMaskColor(self, val:[float, ...]) -> None C++: void SetMaskColor(double *val) SetMaskColor(self, r:float, g:float, b:float) -> None C++: void SetMaskColor(double r, double g, double b) The MaskColor is used on masked fragments. The default of (0.5, 0.5, 0.5) makes the masked fragments look similar to the LIC'd fragments. The mask color is applied only when MaskIntensity > 0. """ pass def SetMaskIntensity(self, val): # real signature unknown; restored from __doc__ """ SetMaskIntensity(self, val:float) -> None C++: void SetMaskIntensity(double val) The MaskIntensity controls the blending of the mask color and the geometry color. The color of masked fragments is given by: * c = maskColor * maskIntensity + geomColor * (1 - maskIntensity) * The default value of 0.0 results in the geometry color being used. """ pass def SetMaskOnSurface(self, val): # real signature unknown; restored from __doc__ """ SetMaskOnSurface(self, val:int) -> None C++: void SetMaskOnSurface(int val) When set MaskOnSurface computes |V| for use in the fragment masking tests on the surface. When not set the original un-projected un-transformed |V| is used. """ pass def SetMaskThreshold(self, val): # real signature unknown; restored from __doc__ """ SetMaskThreshold(self, val:float) -> None C++: void SetMaskThreshold(double val) The MaskThreshold controls the rendering of fragments in stagnant regions of flow. // In these regions LIC noise texture will be masked, where |V| < MaskThreshold is satisfied. The masking process blends a the MaskColor with the scalar color of the surface proportional to MaskIntesnsity. See MaskIntensity for more information on the blending algorithm. This blending allows one control over the masking process so that masked fragments may be: highlighted (by setting a unique mask color and mask intensity > 0), made invisible with and without passing the un-convolved noise texture (by setting mask intensity 0), made to blend into the LIC. * MaskThreshold units are in the original vector space. Note that the * threshold can be applied to the original vector field or to the surface * projected vector field. See MaskOnSurface. """ pass def SetMaxNoiseValue(self, val): # real signature unknown; restored from __doc__ """ SetMaxNoiseValue(self, val:float) -> None C++: void SetMaxNoiseValue(double val) """ pass def SetMinNoiseValue(self, val): # real signature unknown; restored from __doc__ """ SetMinNoiseValue(self, val:float) -> None C++: void SetMinNoiseValue(double val) Set/Get the minimum and mximum gray scale values that the generated noise can take on. The generated noise will be in the range of MinNoiseValue to MaxNoiseValue. Values are clamped within 0 to 1. MinNoiseValue must be less than MaxNoiseValue. """ pass def SetNoiseDataSet(self, data): # real signature unknown; restored from __doc__ """ SetNoiseDataSet(self, data:vtkImageData) -> None C++: void SetNoiseDataSet(vtkImageData *data) Set the data containing a noise array as active scalars. Active scalars array will be converted into a texture for use as noise in the LIC process. Noise datasets are expected to be gray scale. """ pass def SetNoiseGeneratorSeed(self, val): # real signature unknown; restored from __doc__ """ SetNoiseGeneratorSeed(self, val:int) -> None C++: void SetNoiseGeneratorSeed(int val) Set/Get the seed value used by the random number generator. """ pass def SetNoiseGrainSize(self, val): # real signature unknown; restored from __doc__ """ SetNoiseGrainSize(self, val:int) -> None C++: void SetNoiseGrainSize(int val) Each noise value will be length^2 pixels in area. """ pass def SetNoiseTextureSize(self, length): # real signature unknown; restored from __doc__ """ SetNoiseTextureSize(self, length:int) -> None C++: void SetNoiseTextureSize(int length) Set/Get the side length in pixels of the noise texture. The texture will be length^2 pixels in area. """ pass def SetNoiseType(self, type): # real signature unknown; restored from __doc__ """ SetNoiseType(self, type:int) -> None C++: void SetNoiseType(int type) """ pass def SetNormalizeVectors(self, val): # real signature unknown; restored from __doc__ """ SetNormalizeVectors(self, val:int) -> None C++: void SetNormalizeVectors(int val) Normalize vectors during integration. When set(the default) the input vector field is normalized during integration, and each integration occurs over the same arclength. When not set each integration occurs over an arc length proportional to the field magnitude as is customary in traditional numerical methods. See, "Imaging Vector Fields Using Line Integral Convolution" for an axample where normalization is used. See, "Image Space Based Visualization of Unsteady Flow on Surfaces" for an example of where no normalization is used. """ pass def SetNumberOfNoiseLevels(self, val): # real signature unknown; restored from __doc__ """ SetNumberOfNoiseLevels(self, val:int) -> None C++: void SetNumberOfNoiseLevels(int val) Set/Get the number of discrete values a noise pixel may take on. Default 1024. """ pass def SetNumberOfSteps(self, val): # real signature unknown; restored from __doc__ """ SetNumberOfSteps(self, val:int) -> None C++: void SetNumberOfSteps(int val) Get/Set the number of integration steps in each direction. """ pass def SetStepSize(self, val): # real signature unknown; restored from __doc__ """ SetStepSize(self, val:float) -> None C++: void SetStepSize(double val) Get/Set the step size (in pixels). """ pass def ShallowCopy(self, m): # real signature unknown; restored from __doc__ """ ShallowCopy(self, m:vtkSurfaceLICInterface) -> None C++: void ShallowCopy(vtkSurfaceLICInterface *m) Make a shallow copy of this interface """ pass def UpdateCommunicator(self, renderer, actor, data): # real signature unknown; restored from __doc__ """ UpdateCommunicator(self, renderer:vtkRenderer, actor:vtkActor, data:vtkDataObject) -> None C++: void UpdateCommunicator(vtkRenderer *renderer, vtkActor *actor, vtkDataObject *data) Called from a mapper, does what is needed to make sure the communicators are ready """ pass def ValidateContext(self, renderer): # real signature unknown; restored from __doc__ """ ValidateContext(self, renderer:vtkRenderer) -> None C++: void ValidateContext(vtkRenderer *renderer) Look for changes that would trigger stage updates """ pass def WriteTimerLog(self, __a): # real signature unknown; restored from __doc__ """ WriteTimerLog(self, __a:str) -> None C++: virtual void WriteTimerLog(const char *) Methods used for parallel benchmarks. Use cmake to define vtkSurfaceLICMapperTIME to enable benchmarks. During each update timing information is stored, it can be written to disk by calling WriteLog. """ 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.""" COLOR_MODE_BLEND = 0 COLOR_MODE_MAP = 1 COMPOSITE_AUTO = 3 COMPOSITE_BALANCED = 2 COMPOSITE_INPLACE = 0 COMPOSITE_INPLACE_DISJOINT = 1 ENHANCE_CONTRAST_BOTH = 4 ENHANCE_CONTRAST_COLOR = 3 ENHANCE_CONTRAST_LIC = 1 ENHANCE_CONTRAST_OFF = 0 NOISE_TYPE_GAUSSIAN = 1 NOISE_TYPE_PERLIN = 2 NOISE_TYPE_UNIFORM = 0 __dict__ = None # (!) real value is 'mappingproxy({\'__vtkname__\': \'vtkSurfaceLICInterface\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'SetNumberOfSteps\': , \'GetNumberOfSteps\': , \'SetStepSize\': , \'GetStepSize\': , \'SetNormalizeVectors\': , \'NormalizeVectorsOn\': , \'NormalizeVectorsOff\': , \'GetNormalizeVectors\': , \'SetMaskOnSurface\': , \'MaskOnSurfaceOn\': , \'MaskOnSurfaceOff\': , \'GetMaskOnSurface\': , \'SetMaskThreshold\': , \'GetMaskThreshold\': , \'SetMaskColor\': , \'GetMaskColor\': , \'SetMaskIntensity\': , \'GetMaskIntensity\': , \'SetEnhancedLIC\': , \'GetEnhancedLIC\': , \'EnhancedLICOn\': , \'EnhancedLICOff\': , \'SetEnhanceContrast\': , \'GetEnhanceContrast\': , \'GetLowLICContrastEnhancementFactor\': , \'GetHighLICContrastEnhancementFactor\': , \'SetLowLICContrastEnhancementFactor\': , \'SetHighLICContrastEnhancementFactor\': , \'GetLowColorContrastEnhancementFactor\': , \'GetHighColorContrastEnhancementFactor\': , \'SetLowColorContrastEnhancementFactor\': , \'SetHighColorContrastEnhancementFactor\': , \'SetAntiAlias\': , \'AntiAliasOn\': , \'AntiAliasOff\': , \'GetAntiAlias\': , \'SetColorMode\': , \'GetColorMode\': , \'SetLICIntensity\': , \'GetLICIntensity\': , \'SetMapModeBias\': , \'GetMapModeBias\': , \'SetNoiseDataSet\': , \'GetNoiseDataSet\': , \'SetGenerateNoiseTexture\': , \'GetGenerateNoiseTexture\': , \'SetNoiseType\': , \'GetNoiseType\': , \'SetNoiseTextureSize\': , \'GetNoiseTextureSize\': , \'SetNoiseGrainSize\': , \'GetNoiseGrainSize\': , \'SetMinNoiseValue\': , \'SetMaxNoiseValue\': , \'GetMinNoiseValue\': , \'GetMaxNoiseValue\': , \'SetNumberOfNoiseLevels\': , \'GetNumberOfNoiseLevels\': , \'SetImpulseNoiseProbability\': , \'GetImpulseNoiseProbability\': , \'SetImpulseNoiseBackgroundValue\': , \'GetImpulseNoiseBackgroundValue\': , \'SetNoiseGeneratorSeed\': , \'GetNoiseGeneratorSeed\': , \'SetCompositeStrategy\': , \'GetCompositeStrategy\': , \'IsSupported\': , \'WriteTimerLog\': , \'ShallowCopy\': , \'ReleaseGraphicsResources\': , \'CanRenderSurfaceLIC\': , \'ValidateContext\': , \'CreateCommunicator\': , \'UpdateCommunicator\': , \'SetHasVectors\': , \'GetHasVectors\': , \'InitializeResources\': , \'PrepareForGeometry\': , \'CompletedGeometry\': , \'GatherVectors\': , \'ApplyLIC\': , \'CombineColorsAndLIC\': , \'CopyToScreen\': , \'SetEnable\': , \'GetEnable\': , \'EnableOn\': , \'EnableOff\': , \'ENHANCE_CONTRAST_OFF\': 0, \'ENHANCE_CONTRAST_LIC\': 1, \'ENHANCE_CONTRAST_COLOR\': 3, \'ENHANCE_CONTRAST_BOTH\': 4, \'COLOR_MODE_BLEND\': 0, \'COLOR_MODE_MAP\': 1, \'NOISE_TYPE_UNIFORM\': 0, \'NOISE_TYPE_GAUSSIAN\': 1, \'NOISE_TYPE_PERLIN\': 2, \'COMPOSITE_INPLACE\': 0, \'COMPOSITE_INPLACE_DISJOINT\': 1, \'COMPOSITE_BALANCED\': 2, \'COMPOSITE_AUTO\': 3, \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': \'vtkSurfaceLICInterface - public API for surface lic parameters\\n arbitrary geometry.\\n\\nSuperclass: vtkObject\\n\\nvtkSurfaceLICInterface performs LIC on the surface of arbitrary\\n geometry. Point vectors are used as the vector field for generating\\nthe LIC.\\n The implementation was originallu based on "Image Space Based\\nVisualization\\n on Unsteady Flow on Surfaces" by Laramee, Jobard and Hauser appeared\\nin\\n proceedings of IEEE Visualization \\\'03, pages 131-138.\\n\\n\\n Internal pipeline:\\n\\nnoise\\n |\\n [ PROJ (GAT) (COMP) LIC2D (SCAT) SHADE (CCE) DEP]\\n | | vectors \\n surface LIC PROj - project vectors\\nonto surface GAT - gather data for compositing and guard pixel\\ngeneration (parallel only) COMP - composite gathered data LIC2D -\\nline intengral convolution, see vtkLineIntegralConvolution2D. SCAT -\\nscatter result (parallel only, not all compositors use it) SHADE -\\ncombine LIC and scalar colors CCE - color contrast enhancement\\n(optional) DEP - depth test and copy to back buffer\\n\\nThe result of each stage is cached in a texture so that during\\ninteraction a stage may be skipped if the user has not modified its\\nparameters or input data.\\n\\nThe parallel parts of algorithm are implemented in\\nvtkPSurfaceLICInterface. Note that for MPI enabled builds this class\\nwill be automatically created by the object factory.\\n\\n@sa\\nvtkLineIntegralConvolution2D\\n\\n\'})' __vtkname__ = 'vtkSurfaceLICInterface' class vtkSurfaceLICMapper(__vtkmodules_vtkRenderingOpenGL2.vtkOpenGLPolyDataMapper): """ vtkSurfaceLICMapper - mapper that performs LIC on the surface of arbitrary geometry. Superclass: vtkOpenGLPolyDataMapper vtkSurfaceLICMapper performs LIC on the surface of arbitrary geometry. Point vectors are used as the vector field for generating the LIC. The implementation was originallu based on "Image Space Based Visualization on Unsteady Flow on Surfaces" by Laramee, Jobard and Hauser appeared in proceedings of IEEE Visualization '03, pages 131-138. Internal pipeline: noise | [ PROJ (GAT) (COMP) LIC2D (SCAT) SHADE (CCE) DEP] | | vectors surface LIC PROj - project vectors onto surface GAT - gather data for compositing and guard pixel generation (parallel only) COMP - composite gathered data LIC2D - line intengral convolution, see vtkLineIntegralConvolution2D. SCAT - scatter result (parallel only, not all compositors use it) SHADE - combine LIC and scalar colors CCE - color contrast enhancement (optional) DEP - depth test and copy to back buffer The result of each stage is cached in a texture so that during interaction a stage may be skipped if the user has not modified its parameters or input data. The parallel parts of algorithm are implemented in vtkPSurfaceLICMapper. Note that for MPI enabled builds this class will be automatically created by the object factory. @sa vtkLineIntegralConvolution2D """ def GetLICInterface(self): # real signature unknown; restored from __doc__ """ GetLICInterface(self) -> vtkSurfaceLICInterface C++: virtual vtkSurfaceLICInterface *GetLICInterface() Get the vtkSurfaceLICInterface used by this mapper """ return vtkSurfaceLICInterface 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) -> vtkSurfaceLICMapper C++: vtkSurfaceLICMapper *NewInstance() """ return vtkSurfaceLICMapper def ReleaseGraphicsResources(self, win): # real signature unknown; restored from __doc__ """ ReleaseGraphicsResources(self, win:vtkWindow) -> None C++: void ReleaseGraphicsResources(vtkWindow *win) override; Release any graphics resources that are being consumed by this mapper. The parameter window could be used to determine which graphic resources to release. In this case, releases the display lists. """ pass def RenderPiece(self, ren, act): # real signature unknown; restored from __doc__ """ RenderPiece(self, ren:vtkRenderer, act:vtkActor) -> None C++: void RenderPiece(vtkRenderer *ren, vtkActor *act) override; Implemented by sub classes. Actual rendering is done here. """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkSurfaceLICMapper C++: static vtkSurfaceLICMapper *SafeDownCast(vtkObjectBase *o) """ return vtkSurfaceLICMapper def ShallowCopy(self, __a): # real signature unknown; restored from __doc__ """ ShallowCopy(self, __a:vtkAbstractMapper) -> None C++: void ShallowCopy(vtkAbstractMapper *) override; Shallow copy of an actor. """ 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__\': \'vtkSurfaceLICMapper\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'ReleaseGraphicsResources\': , \'RenderPiece\': , \'ShallowCopy\': , \'GetLICInterface\': , \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': \'vtkSurfaceLICMapper - mapper that performs LIC on the surface of\\n arbitrary geometry.\\n\\nSuperclass: vtkOpenGLPolyDataMapper\\n\\nvtkSurfaceLICMapper performs LIC on the surface of arbitrary\\n geometry. Point vectors are used as the vector field for generating\\nthe LIC.\\n The implementation was originallu based on "Image Space Based\\nVisualization\\n on Unsteady Flow on Surfaces" by Laramee, Jobard and Hauser appeared\\nin\\n proceedings of IEEE Visualization \\\'03, pages 131-138.\\n\\n\\n Internal pipeline:\\n\\nnoise\\n |\\n [ PROJ (GAT) (COMP) LIC2D (SCAT) SHADE (CCE) DEP]\\n | | vectors \\n surface LIC PROj - project vectors\\nonto surface GAT - gather data for compositing and guard pixel\\ngeneration (parallel only) COMP - composite gathered data LIC2D -\\nline intengral convolution, see vtkLineIntegralConvolution2D. SCAT -\\nscatter result (parallel only, not all compositors use it) SHADE -\\ncombine LIC and scalar colors CCE - color contrast enhancement\\n(optional) DEP - depth test and copy to back buffer\\n\\nThe result of each stage is cached in a texture so that during\\ninteraction a stage may be skipped if the user has not modified its\\nparameters or input data.\\n\\nThe parallel parts of algorithm are implemented in\\nvtkPSurfaceLICMapper. Note that for MPI enabled builds this class\\nwill be automatically created by the object factory.\\n\\n@sa\\nvtkLineIntegralConvolution2D\\n\\n\'})' __vtkname__ = 'vtkSurfaceLICMapper' class vtkTextureIO(object): """ vtkTextureIO() -> vtkTextureIO C++: vtkTextureIO() vtkTextureIO(__a:vtkTextureIO) -> vtkTextureIO C++: vtkTextureIO(const &vtkTextureIO) vtkTextureIO - A small collection of I/O routines that write vtkTextureObject to disk for debugging. """ def Write(self, filename, texture, subset, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ Write(filename:str, texture:vtkTextureObject, subset:(int, ...) =..., origin:(float, ...)=...) -> None C++: static void Write(std::string filename, vtkTextureObject *texture, const unsigned int *subset=nullptr, const double *origin=nullptr) Write(filename:str, texture:vtkTextureObject, subset:vtkPixelExtent, origin:(float, ...)=...) -> None C++: static void Write(std::string filename, vtkTextureObject *texture, const vtkPixelExtent &subset, const double *origin=nullptr) Write to disk as image data with subset(optional) at dataset origin(optional) """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __hash__(self, *args, **kwargs): # real signature unknown """ Return hash(self). """ pass def __init__(self): # real signature unknown; restored from __doc__ 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 # variables with complex values __loader__ = None # (!) real value is '<_frozen_importlib_external.ExtensionFileLoader object at 0x0000021E999ABC50>' __spec__ = None # (!) real value is "ModuleSpec(name='vtkmodules.vtkRenderingLICOpenGL2', loader=<_frozen_importlib_external.ExtensionFileLoader object at 0x0000021E999ABC50>, origin='C:\\\\Users\\\\xukai\\\\Downloads\\\\??2\\\\venv\\\\Lib\\\\site-packages\\\\vtkmodules\\\\vtkRenderingLICOpenGL2.cp311-win_amd64.pyd')"