# encoding: utf-8 # module vtkmodules.vtkCommonTransforms # from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\vtkmodules\vtkCommonTransforms.cp311-win_amd64.pyd # by generator 1.147 # no doc # imports import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore # Variables with simple values VTK_LANDMARK_AFFINE = 12 VTK_LANDMARK_RIGIDBODY = 6 VTK_LANDMARK_SIMILARITY = 7 VTK_RBF_CUSTOM = 0 VTK_RBF_R = 1 VTK_RBF_R2LOGR = 2 # no functions # classes class vtkAbstractTransform(__vtkmodules_vtkCommonCore.vtkObject): """ vtkTransformConcatenationStack - Store a stack of concatenations. Superclass: vtkObject A helper class (not derived from vtkObject) to store a stack of concatenations. """ def CircuitCheck(self, transform): # real signature unknown; restored from __doc__ """ CircuitCheck(self, transform:vtkAbstractTransform) -> int C++: virtual int CircuitCheck(vtkAbstractTransform *transform) Check for self-reference. Will return true if concatenating with the specified transform, setting it to be our inverse, or setting it to be our input will create a circular reference. CircuitCheck is automatically called by SetInput(), SetInverse(), and Concatenate(vtkXTransform *). Avoid using this function, it is experimental. """ return 0 def DeepCopy(self, __a): # real signature unknown; restored from __doc__ """ DeepCopy(self, __a:vtkAbstractTransform) -> None C++: void DeepCopy(vtkAbstractTransform *) Copy this transform from another of the same type. """ pass def GetInverse(self): # real signature unknown; restored from __doc__ """ GetInverse(self) -> vtkAbstractTransform C++: vtkAbstractTransform *GetInverse() Get the inverse of this transform. If you modify this transform, the returned inverse transform will automatically update. If you want the inverse of a vtkTransform, you might want to use GetLinearInverse() instead which will type cast the result from vtkAbstractTransform to vtkLinearTransform. """ return vtkAbstractTransform def GetMTime(self): # real signature unknown; restored from __doc__ """ GetMTime(self) -> int C++: vtkMTimeType GetMTime() override; Override GetMTime necessary because of inverse transforms. """ 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 InternalTransformDerivative(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InternalTransformDerivative(self, in_:(float, float, float), out:[float, float, float], derivative:[[float, float, float], [float, float, float], [float, float, float]]) -> None C++: virtual void InternalTransformDerivative(const double in[3], double out[3], double derivative[3][3]) """ pass def InternalTransformPoint(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InternalTransformPoint(self, in_:(float, float, float), out:[float, float, float]) -> None C++: virtual void InternalTransformPoint(const double in[3], double out[3]) """ pass def Inverse(self): # real signature unknown; restored from __doc__ """ Inverse(self) -> None C++: virtual void Inverse() Invert the transformation. """ 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 MakeTransform(self): # real signature unknown; restored from __doc__ """ MakeTransform(self) -> vtkAbstractTransform C++: virtual vtkAbstractTransform *MakeTransform() Make another transform of the same type. """ return vtkAbstractTransform def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkAbstractTransform C++: vtkAbstractTransform *NewInstance() """ return vtkAbstractTransform def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkAbstractTransform C++: static vtkAbstractTransform *SafeDownCast(vtkObjectBase *o) """ return vtkAbstractTransform def SetInverse(self, transform): # real signature unknown; restored from __doc__ """ SetInverse(self, transform:vtkAbstractTransform) -> None C++: void SetInverse(vtkAbstractTransform *transform) Set a transformation that this transform will be the inverse of. This transform will automatically update to agree with the inverse transform that you set. """ pass def TransformDoubleNormalAtPoint(self, point, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ TransformDoubleNormalAtPoint(self, point:(float, float, float), normal:(float, float, float)) -> (float, float, float) C++: double *TransformDoubleNormalAtPoint(const double point[3], const double normal[3]) Apply the transformation to a double-precision normal at the specified vertex. If the transformation is a vtkLinearTransform, you can use TransformDoubleNormal() instead. """ pass def TransformDoublePoint(self, x, y, z): # real signature unknown; restored from __doc__ """ TransformDoublePoint(self, x:float, y:float, z:float) -> (float, float, float) C++: double *TransformDoublePoint(double x, double y, double z) TransformDoublePoint(self, point:(float, float, float)) -> (float, float, float) C++: double *TransformDoublePoint(const double point[3]) Apply the transformation to a double-precision (x,y,z) coordinate. Use this if you are programming in Python or Java. """ pass def TransformDoubleVectorAtPoint(self, point, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ TransformDoubleVectorAtPoint(self, point:(float, float, float), vector:(float, float, float)) -> (float, float, float) C++: double *TransformDoubleVectorAtPoint(const double point[3], const double vector[3]) Apply the transformation to a double-precision vector at the specified vertex. If the transformation is a vtkLinearTransform, you can use TransformDoubleVector() instead. """ pass def TransformFloatNormalAtPoint(self, point, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ TransformFloatNormalAtPoint(self, point:(float, float, float), normal:(float, float, float)) -> (float, float, float) C++: float *TransformFloatNormalAtPoint(const float point[3], const float normal[3]) Apply the transformation to a single-precision normal at the specified vertex. If the transformation is a vtkLinearTransform, you can use TransformFloatNormal() instead. """ pass def TransformFloatPoint(self, x, y, z): # real signature unknown; restored from __doc__ """ TransformFloatPoint(self, x:float, y:float, z:float) -> (float, float, float) C++: float *TransformFloatPoint(float x, float y, float z) TransformFloatPoint(self, point:(float, float, float)) -> (float, float, float) C++: float *TransformFloatPoint(const float point[3]) Apply the transformation to an (x,y,z) coordinate. Use this if you are programming in Python or Java. """ pass def TransformFloatVectorAtPoint(self, point, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ TransformFloatVectorAtPoint(self, point:(float, float, float), vector:(float, float, float)) -> (float, float, float) C++: float *TransformFloatVectorAtPoint(const float point[3], const float vector[3]) Apply the transformation to a single-precision vector at the specified vertex. If the transformation is a vtkLinearTransform, you can use TransformFloatVector() instead. """ pass def TransformNormalAtPoint(self, point, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ TransformNormalAtPoint(self, point:(float, float, float), in_:( float, float, float), out:[float, float, float]) -> None C++: void TransformNormalAtPoint(const double point[3], const double in[3], double out[3]) TransformNormalAtPoint(self, point:(float, float, float), normal:( float, float, float)) -> (float, float, float) C++: double *TransformNormalAtPoint(const double point[3], const double normal[3]) """ pass def TransformPoint(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ TransformPoint(self, in_:(float, float, float), out:[float, float, float]) -> None C++: void TransformPoint(const double in[3], double out[3]) TransformPoint(self, x:float, y:float, z:float) -> (float, float, float) C++: double *TransformPoint(double x, double y, double z) TransformPoint(self, point:(float, float, float)) -> (float, float, float) C++: double *TransformPoint(const double point[3]) Apply the transformation to a double-precision coordinate. You can use the same array to store both the input and output point. """ pass def TransformPoints(self, inPts, outPts): # real signature unknown; restored from __doc__ """ TransformPoints(self, inPts:vtkPoints, outPts:vtkPoints) -> None C++: virtual void TransformPoints(vtkPoints *inPts, vtkPoints *outPts) Apply the transformation to a series of points, and append the results to outPts. """ pass def TransformVectorAtPoint(self, point, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ TransformVectorAtPoint(self, point:(float, float, float), in_:( float, float, float), out:[float, float, float]) -> None C++: void TransformVectorAtPoint(const double point[3], const double in[3], double out[3]) TransformVectorAtPoint(self, point:(float, float, float), vector:( float, float, float)) -> (float, float, float) C++: double *TransformVectorAtPoint(const double point[3], const double vector[3]) """ pass def Update(self): # real signature unknown; restored from __doc__ """ Update(self) -> None C++: void Update() Update the transform to account for any changes which have been made. You do not have to call this method yourself, it is called automatically whenever the transform needs an update. """ 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__': 'vtkAbstractTransform', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'TransformPoint': , 'TransformFloatPoint': , 'TransformDoublePoint': , 'TransformNormalAtPoint': , 'TransformDoubleNormalAtPoint': , 'TransformFloatNormalAtPoint': , 'TransformVectorAtPoint': , 'TransformDoubleVectorAtPoint': , 'TransformFloatVectorAtPoint': , 'TransformPoints': , 'GetInverse': , 'SetInverse': , 'Inverse': , 'DeepCopy': , 'Update': , 'InternalTransformPoint': , 'InternalTransformDerivative': , 'MakeTransform': , 'CircuitCheck': , 'GetMTime': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkTransformConcatenationStack - Store a stack of concatenations.\\n\\nSuperclass: vtkObject\\n\\nA helper class (not derived from vtkObject) to store a stack of\\nconcatenations.\\n\\n'})" __vtkname__ = 'vtkAbstractTransform' class vtkWarpTransform(vtkAbstractTransform): """ vtkWarpTransform - superclass for nonlinear geometric transformations Superclass: vtkAbstractTransform vtkWarpTransform provides a generic interface for nonlinear warp transformations. @sa vtkThinPlateSplineTransform vtkGridTransform vtkGeneralTransform """ def GetInverseFlag(self): # real signature unknown; restored from __doc__ """ GetInverseFlag(self) -> int C++: virtual int GetInverseFlag() Get the inverse flag of the transformation. This flag is set to zero when the transformation is first created, and is flipped each time Inverse() is called. """ return 0 def GetInverseIterations(self): # real signature unknown; restored from __doc__ """ GetInverseIterations(self) -> int C++: virtual int GetInverseIterations() """ return 0 def GetInverseTolerance(self): # real signature unknown; restored from __doc__ """ GetInverseTolerance(self) -> float C++: virtual double GetInverseTolerance() """ return 0.0 def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def InternalTransformDerivative(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InternalTransformDerivative(self, in_:(float, float, float), out:[float, float, float], derivative:[[float, float, float], [float, float, float], [float, float, float]]) -> None C++: void InternalTransformDerivative(const double in[3], double out[3], double derivative[3][3]) override; """ pass def InternalTransformPoint(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InternalTransformPoint(self, in_:(float, float, float), out:[float, float, float]) -> None C++: void InternalTransformPoint(const double in[3], double out[3]) override; """ pass def Inverse(self): # real signature unknown; restored from __doc__ """ Inverse(self) -> None C++: void Inverse() override; Invert the transformation. Warp transformations are usually inverted using an iterative technique such as Newton's method. The inverse transform is usually around five or six times as computationally expensive as the forward transform. """ 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) -> vtkWarpTransform C++: vtkWarpTransform *NewInstance() """ return vtkWarpTransform def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkWarpTransform C++: static vtkWarpTransform *SafeDownCast(vtkObjectBase *o) """ return vtkWarpTransform def SetInverseIterations(self, _arg): # real signature unknown; restored from __doc__ """ SetInverseIterations(self, _arg:int) -> None C++: virtual void SetInverseIterations(int _arg) Set the maximum number of iterations for the inverse transformation. The default is 500, but usually only 2 to 5 iterations are used. The inversion method is fairly robust, and it should converge for nearly all smooth transformations that do not fold back on themselves. """ pass def SetInverseTolerance(self, _arg): # real signature unknown; restored from __doc__ """ SetInverseTolerance(self, _arg:float) -> None C++: virtual void SetInverseTolerance(double _arg) Set the tolerance for inverse transformation. The default is 0.001. """ pass def TemplateTransformInverse(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ TemplateTransformInverse(self, in_:(float, float, float), out:[float, float, float]) -> None C++: void TemplateTransformInverse(const double in[3], double out[3]) TemplateTransformInverse(self, in_:(float, float, float), out:[float, float, float], derivative:[[float, float, float], [float, float, float], [float, float, float]]) -> None C++: void TemplateTransformInverse(const double in[3], double out[3], double derivative[3][3]) """ pass def TemplateTransformPoint(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ TemplateTransformPoint(self, in_:(float, float, float), out:[float, float, float]) -> None C++: void TemplateTransformPoint(const double in[3], double out[3]) TemplateTransformPoint(self, in_:(float, float, float), out:[float, float, float], derivative:[[float, float, float], [float, float, float], [float, float, float]]) -> None C++: void TemplateTransformPoint(const double in[3], double out[3], double derivative[3][3]) """ 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__': 'vtkWarpTransform', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'Inverse': , 'GetInverseFlag': , 'SetInverseTolerance': , 'GetInverseTolerance': , 'SetInverseIterations': , 'GetInverseIterations': , 'InternalTransformPoint': , 'InternalTransformDerivative': , 'TemplateTransformPoint': , 'TemplateTransformInverse': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkWarpTransform - superclass for nonlinear geometric transformations\\n\\nSuperclass: vtkAbstractTransform\\n\\nvtkWarpTransform provides a generic interface for nonlinear warp\\ntransformations.\\n@sa\\nvtkThinPlateSplineTransform vtkGridTransform vtkGeneralTransform\\n\\n'})" __vtkname__ = 'vtkWarpTransform' class vtkCylindricalTransform(vtkWarpTransform): """ vtkCylindricalTransform - cylindrical to rectangular coords and back Superclass: vtkWarpTransform vtkCylindricalTransform will convert (r,theta,z) coordinates to (x,y,z) coordinates and back again. The angles are given in radians. By default, it converts cylindrical coordinates to rectangular, but GetInverse() returns a transform that will do the opposite. The equation that is used is x = r*cos(theta), y = r*sin(theta), z = z. @warning This transform is not well behaved along the line x=y=0 (i.e. along the z-axis) @sa vtkSphericalTransform vtkGeneralTransform """ 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 MakeTransform(self): # real signature unknown; restored from __doc__ """ MakeTransform(self) -> vtkAbstractTransform C++: vtkAbstractTransform *MakeTransform() override; Make another transform of the same type. """ return vtkAbstractTransform def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkCylindricalTransform C++: vtkCylindricalTransform *NewInstance() """ return vtkCylindricalTransform def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkCylindricalTransform C++: static vtkCylindricalTransform *SafeDownCast( vtkObjectBase *o) """ return vtkCylindricalTransform 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__': 'vtkCylindricalTransform', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'MakeTransform': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkCylindricalTransform - cylindrical to rectangular coords and back\\n\\nSuperclass: vtkWarpTransform\\n\\nvtkCylindricalTransform will convert (r,theta,z) coordinates to\\n(x,y,z) coordinates and back again. The angles are given in radians.\\nBy default, it converts cylindrical coordinates to rectangular, but\\nGetInverse() returns a transform that will do the opposite. The\\nequation that is used is x = r*cos(theta), y = r*sin(theta), z = z.\\n@warning\\nThis transform is not well behaved along the line x=y=0 (i.e. along\\nthe z-axis)\\n@sa\\nvtkSphericalTransform vtkGeneralTransform\\n\\n'})" __vtkname__ = 'vtkCylindricalTransform' class vtkGeneralTransform(vtkAbstractTransform): """ vtkGeneralTransform - allows operations on any transforms Superclass: vtkAbstractTransform vtkGeneralTransform is like vtkTransform and vtkPerspectiveTransform, but it will work with any vtkAbstractTransform as input. It is not as efficient as the other two, however, because arbitrary transformations cannot be concatenated by matrix multiplication. Transform concatenation is simulated by passing each input point through each transform in turn. @sa vtkTransform vtkPerspectiveTransform """ def CircuitCheck(self, transform): # real signature unknown; restored from __doc__ """ CircuitCheck(self, transform:vtkAbstractTransform) -> int C++: int CircuitCheck(vtkAbstractTransform *transform) override; Check for self-reference. Will return true if concatenating with the specified transform, setting it to be our inverse, or setting it to be our input will create a circular reference. CircuitCheck is automatically called by SetInput(), SetInverse(), and Concatenate(vtkXTransform *). Avoid using this function, it is experimental. """ return 0 def Concatenate(self, matrix): # real signature unknown; restored from __doc__ """ Concatenate(self, matrix:vtkMatrix4x4) -> None C++: void Concatenate(vtkMatrix4x4 *matrix) Concatenate(self, elements:(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float)) -> None C++: void Concatenate(const double elements[16]) Concatenate(self, transform:vtkAbstractTransform) -> None C++: void Concatenate(vtkAbstractTransform *transform) Concatenates the matrix with the current transformation according to PreMultiply or PostMultiply semantics. """ pass def GetConcatenatedTransform(self, i): # real signature unknown; restored from __doc__ """ GetConcatenatedTransform(self, i:int) -> vtkAbstractTransform C++: vtkAbstractTransform *GetConcatenatedTransform(int i) Get one of the concatenated transformations as a vtkAbstractTransform. These transformations are applied, in series, every time the transformation of a coordinate occurs. This method is provided to make it possible to decompose a transformation into its constituents, for example to save a transformation to a file. """ return vtkAbstractTransform def GetInput(self): # real signature unknown; restored from __doc__ """ GetInput(self) -> vtkAbstractTransform C++: vtkAbstractTransform *GetInput() """ return vtkAbstractTransform def GetInverseFlag(self): # real signature unknown; restored from __doc__ """ GetInverseFlag(self) -> int C++: int GetInverseFlag() Get the inverse flag of the transformation. This controls whether it is the Input or the inverse of the Input that is used as the base transformation. The InverseFlag is flipped every time Inverse() is called. The InverseFlag is off when a transform is first created. """ return 0 def GetMTime(self): # real signature unknown; restored from __doc__ """ GetMTime(self) -> int C++: vtkMTimeType GetMTime() override; Override GetMTime to account for input and concatenation. """ return 0 def GetNumberOfConcatenatedTransforms(self): # real signature unknown; restored from __doc__ """ GetNumberOfConcatenatedTransforms(self) -> int C++: int GetNumberOfConcatenatedTransforms() Get the total number of transformations that are linked into this one via Concatenate() operations or via SetInput(). """ 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 Identity(self): # real signature unknown; restored from __doc__ """ Identity(self) -> None C++: void Identity() Set this transformation to the identity transformation. If the transform has an Input, then the transformation will be reset so that it is the same as the Input. """ pass def InternalTransformDerivative(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InternalTransformDerivative(self, in_:(float, float, float), out:[float, float, float], derivative:[[float, float, float], [float, float, float], [float, float, float]]) -> None C++: void InternalTransformDerivative(const double in[3], double out[3], double derivative[3][3]) override; """ pass def InternalTransformPoint(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InternalTransformPoint(self, in_:(float, float, float), out:[float, float, float]) -> None C++: void InternalTransformPoint(const double in[3], double out[3]) override; """ pass def Inverse(self): # real signature unknown; restored from __doc__ """ Inverse(self) -> None C++: void Inverse() override; Invert the transformation. This will also set a flag so that the transformation will use the inverse of its Input, if an Input has been set. """ 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 MakeTransform(self): # real signature unknown; restored from __doc__ """ MakeTransform(self) -> vtkAbstractTransform C++: vtkAbstractTransform *MakeTransform() override; Make another transform of the same type. """ return vtkAbstractTransform def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkGeneralTransform C++: vtkGeneralTransform *NewInstance() """ return vtkGeneralTransform def Pop(self): # real signature unknown; restored from __doc__ """ Pop(self) -> None C++: void Pop() Deletes the transformation on the top of the stack and sets the top to the next transformation on the stack. """ pass def PostMultiply(self): # real signature unknown; restored from __doc__ """ PostMultiply(self) -> None C++: void PostMultiply() Sets the internal state of the transform to PostMultiply. All subsequent operations will occur after those already represented in the current transformation. In homogeneous matrix notation, M = A*M where M is the current transformation matrix and A is the applied matrix. The default is PreMultiply. """ pass def PreMultiply(self): # real signature unknown; restored from __doc__ """ PreMultiply(self) -> None C++: void PreMultiply() Sets the internal state of the transform to PreMultiply. All subsequent operations will occur before those already represented in the current transformation. In homogeneous matrix notation, M = M*A where M is the current transformation matrix and A is the applied matrix. The default is PreMultiply. """ pass def Push(self): # real signature unknown; restored from __doc__ """ Push(self) -> None C++: void Push() Pushes the current transformation onto the transformation stack. """ pass def RotateWXYZ(self, angle, x, y, z): # real signature unknown; restored from __doc__ """ RotateWXYZ(self, angle:float, x:float, y:float, z:float) -> None C++: void RotateWXYZ(double angle, double x, double y, double z) RotateWXYZ(self, angle:float, axis:(float, float, float)) -> None C++: void RotateWXYZ(double angle, const double axis[3]) Create a rotation matrix and concatenate it with the current transformation according to PreMultiply or PostMultiply semantics. The angle is in degrees, and (x,y,z) specifies the axis that the rotation will be performed around. """ pass def RotateX(self, angle): # real signature unknown; restored from __doc__ """ RotateX(self, angle:float) -> None C++: void RotateX(double angle) Create a rotation matrix about the X, Y, or Z axis and concatenate it with the current transformation according to PreMultiply or PostMultiply semantics. The angle is expressed in degrees. """ pass def RotateY(self, angle): # real signature unknown; restored from __doc__ """ RotateY(self, angle:float) -> None C++: void RotateY(double angle) """ pass def RotateZ(self, angle): # real signature unknown; restored from __doc__ """ RotateZ(self, angle:float) -> None C++: void RotateZ(double angle) """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkGeneralTransform C++: static vtkGeneralTransform *SafeDownCast(vtkObjectBase *o) """ return vtkGeneralTransform def Scale(self, x, y, z): # real signature unknown; restored from __doc__ """ Scale(self, x:float, y:float, z:float) -> None C++: void Scale(double x, double y, double z) Scale(self, s:(float, float, float)) -> None C++: void Scale(const double s[3]) Create a scale matrix (i.e. set the diagonal elements to x, y, z) and concatenate it with the current transformation according to PreMultiply or PostMultiply semantics. """ pass def SetInput(self, input): # real signature unknown; restored from __doc__ """ SetInput(self, input:vtkAbstractTransform) -> None C++: void SetInput(vtkAbstractTransform *input) Set the input for this transformation. This will be used as the base transformation if it is set. This method allows you to build a transform pipeline: if the input is modified, then this transformation will automatically update accordingly. Note that the InverseFlag, controlled via Inverse(), determines whether this transformation will use the Input or the inverse of the Input. """ pass def Translate(self, x, y, z): # real signature unknown; restored from __doc__ """ Translate(self, x:float, y:float, z:float) -> None C++: void Translate(double x, double y, double z) Translate(self, x:(float, float, float)) -> None C++: void Translate(const double x[3]) Create a translation matrix and concatenate it with the current transformation according to PreMultiply or PostMultiply semantics. """ 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__': 'vtkGeneralTransform', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'Identity': , 'Inverse': , 'Translate': , 'RotateWXYZ': , 'RotateX': , 'RotateY': , 'RotateZ': , 'Scale': , 'Concatenate': , 'PreMultiply': , 'PostMultiply': , 'GetNumberOfConcatenatedTransforms': , 'GetConcatenatedTransform': , 'SetInput': , 'GetInput': , 'GetInverseFlag': , 'Push': , 'Pop': , 'InternalTransformPoint': , 'InternalTransformDerivative': , 'CircuitCheck': , 'MakeTransform': , 'GetMTime': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkGeneralTransform - allows operations on any transforms\\n\\nSuperclass: vtkAbstractTransform\\n\\nvtkGeneralTransform is like vtkTransform and vtkPerspectiveTransform,\\nbut it will work with any vtkAbstractTransform as input. It is not\\nas efficient as the other two, however, because arbitrary\\ntransformations cannot be concatenated by matrix multiplication.\\nTransform concatenation is simulated by passing each input point\\nthrough each transform in turn.\\n@sa\\nvtkTransform vtkPerspectiveTransform\\n\\n'})" __vtkname__ = 'vtkGeneralTransform' class vtkHomogeneousTransform(vtkAbstractTransform): """ vtkHomogeneousTransform - superclass for homogeneous transformations Superclass: vtkAbstractTransform vtkHomogeneousTransform provides a generic interface for homogeneous transformations, i.e. transformations which can be represented by multiplying a 4x4 matrix with a homogeneous coordinate. @sa vtkPerspectiveTransform vtkLinearTransform vtkIdentityTransform """ def GetHomogeneousInverse(self): # real signature unknown; restored from __doc__ """ GetHomogeneousInverse(self) -> vtkHomogeneousTransform C++: vtkHomogeneousTransform *GetHomogeneousInverse() Just like GetInverse(), but includes typecast to vtkHomogeneousTransform. """ return vtkHomogeneousTransform def GetMatrix(self, m): # real signature unknown; restored from __doc__ """ GetMatrix(self, m:vtkMatrix4x4) -> None C++: void GetMatrix(vtkMatrix4x4 *m) GetMatrix(self) -> vtkMatrix4x4 C++: vtkMatrix4x4 *GetMatrix() Get a copy of the internal transformation matrix. The transform is Updated first, to guarantee that the matrix is valid. """ pass def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def InternalTransformDerivative(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InternalTransformDerivative(self, in_:(float, float, float), out:[float, float, float], derivative:[[float, float, float], [float, float, float], [float, float, float]]) -> None C++: void InternalTransformDerivative(const double in[3], double out[3], double derivative[3][3]) override; """ pass def InternalTransformPoint(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InternalTransformPoint(self, in_:(float, float, float), out:[float, float, float]) -> None C++: void InternalTransformPoint(const double in[3], double out[3]) override; """ 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) -> vtkHomogeneousTransform C++: vtkHomogeneousTransform *NewInstance() """ return vtkHomogeneousTransform def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkHomogeneousTransform C++: static vtkHomogeneousTransform *SafeDownCast( vtkObjectBase *o) """ return vtkHomogeneousTransform def TransformPoints(self, inPts, outPts): # real signature unknown; restored from __doc__ """ TransformPoints(self, inPts:vtkPoints, outPts:vtkPoints) -> None C++: void TransformPoints(vtkPoints *inPts, vtkPoints *outPts) override; Apply the transformation to a series of points, and append the results to outPts. """ 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__': 'vtkHomogeneousTransform', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'TransformPoints': , 'GetMatrix': , 'GetHomogeneousInverse': , 'InternalTransformPoint': , 'InternalTransformDerivative': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkHomogeneousTransform - superclass for homogeneous transformations\\n\\nSuperclass: vtkAbstractTransform\\n\\nvtkHomogeneousTransform provides a generic interface for homogeneous\\ntransformations, i.e. transformations which can be represented by\\nmultiplying a 4x4 matrix with a homogeneous coordinate.\\n@sa\\nvtkPerspectiveTransform vtkLinearTransform vtkIdentityTransform\\n\\n'})" __vtkname__ = 'vtkHomogeneousTransform' class vtkLinearTransform(vtkHomogeneousTransform): """ vtkLinearTransform - abstract superclass for linear transformations Superclass: vtkHomogeneousTransform vtkLinearTransform provides a generic interface for linear (affine or 12 degree-of-freedom) geometric transformations. @warning Portions of this class (i.e., when transforming arrays of points and/or associated attributes such as normals and vectors) has been threaded with vtkSMPTools. Using TBB or other non-sequential type (set in the CMake variable VTK_SMP_IMPLEMENTATION_TYPE) may improve performance significantly. @sa vtkTransform vtkIdentityTransform """ def GetLinearInverse(self): # real signature unknown; restored from __doc__ """ GetLinearInverse(self) -> vtkLinearTransform C++: vtkLinearTransform *GetLinearInverse() Just like GetInverse, but it includes a typecast to vtkLinearTransform. """ return vtkLinearTransform 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 InternalTransformDerivative(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InternalTransformDerivative(self, in_:(float, float, float), out:[float, float, float], derivative:[[float, float, float], [float, float, float], [float, float, float]]) -> None C++: void InternalTransformDerivative(const double in[3], double out[3], double derivative[3][3]) override; """ pass def InternalTransformNormal(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InternalTransformNormal(self, in_:(float, float, float), out:[float, float, float]) -> None C++: virtual void InternalTransformNormal(const double in[3], double out[3]) """ pass def InternalTransformPoint(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InternalTransformPoint(self, in_:(float, float, float), out:[float, float, float]) -> None C++: void InternalTransformPoint(const double in[3], double out[3]) override; """ pass def InternalTransformVector(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InternalTransformVector(self, in_:(float, float, float), out:[float, float, float]) -> None C++: virtual void InternalTransformVector(const double in[3], double out[3]) """ 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) -> vtkLinearTransform C++: vtkLinearTransform *NewInstance() """ return vtkLinearTransform def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkLinearTransform C++: static vtkLinearTransform *SafeDownCast(vtkObjectBase *o) """ return vtkLinearTransform def TransformDoubleNormal(self, x, y, z): # real signature unknown; restored from __doc__ """ TransformDoubleNormal(self, x:float, y:float, z:float) -> (float, float, float) C++: double *TransformDoubleNormal(double x, double y, double z) TransformDoubleNormal(self, normal:(float, float, float)) -> ( float, float, float) C++: double *TransformDoubleNormal(const double normal[3]) Apply the transformation to a double-precision (x,y,z) normal. Use this if you are programming in python or Java. """ pass def TransformDoubleVector(self, x, y, z): # real signature unknown; restored from __doc__ """ TransformDoubleVector(self, x:float, y:float, z:float) -> (float, float, float) C++: double *TransformDoubleVector(double x, double y, double z) TransformDoubleVector(self, vec:(float, float, float)) -> (float, float, float) C++: double *TransformDoubleVector(const double vec[3]) Apply the transformation to a double-precision (x,y,z) vector. Use this if you are programming in python or Java. """ pass def TransformFloatNormal(self, x, y, z): # real signature unknown; restored from __doc__ """ TransformFloatNormal(self, x:float, y:float, z:float) -> (float, float, float) C++: float *TransformFloatNormal(float x, float y, float z) TransformFloatNormal(self, normal:(float, float, float)) -> ( float, float, float) C++: float *TransformFloatNormal(const float normal[3]) Apply the transformation to an (x,y,z) normal. Use this if you are programming in python or Java. """ pass def TransformFloatVector(self, x, y, z): # real signature unknown; restored from __doc__ """ TransformFloatVector(self, x:float, y:float, z:float) -> (float, float, float) C++: float *TransformFloatVector(float x, float y, float z) TransformFloatVector(self, vec:(float, float, float)) -> (float, float, float) C++: float *TransformFloatVector(const float vec[3]) Apply the transformation to an (x,y,z) vector. Use this if you are programming in python or Java. """ pass def TransformNormal(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ TransformNormal(self, in_:(float, float, float), out:[float, float, float]) -> None C++: void TransformNormal(const double in[3], double out[3]) TransformNormal(self, x:float, y:float, z:float) -> (float, float, float) C++: double *TransformNormal(double x, double y, double z) TransformNormal(self, normal:(float, float, float)) -> (float, float, float) C++: double *TransformNormal(const double normal[3]) Apply the transformation to a double-precision normal. You can use the same array to store both the input and output. """ pass def TransformNormals(self, inNms, outNms): # real signature unknown; restored from __doc__ """ TransformNormals(self, inNms:vtkDataArray, outNms:vtkDataArray) -> None C++: virtual void TransformNormals(vtkDataArray *inNms, vtkDataArray *outNms) Apply the transformation to a series of normals, and append the results to outNms. """ pass def TransformPoints(self, inPts, outPts): # real signature unknown; restored from __doc__ """ TransformPoints(self, inPts:vtkPoints, outPts:vtkPoints) -> None C++: void TransformPoints(vtkPoints *inPts, vtkPoints *outPts) override; Apply the transformation to a series of points, and append the results to outPts. """ pass def TransformVector(self, x, y, z): # real signature unknown; restored from __doc__ """ TransformVector(self, x:float, y:float, z:float) -> (float, float, float) C++: double *TransformVector(double x, double y, double z) TransformVector(self, normal:(float, float, float)) -> (float, float, float) C++: double *TransformVector(const double normal[3]) TransformVector(self, in_:(float, float, float), out:[float, float, float]) -> None C++: void TransformVector(const double in[3], double out[3]) Synonymous with TransformDoubleVector(x,y,z). Use this if you are programming in python or Java. """ pass def TransformVectors(self, inVrs, outVrs): # real signature unknown; restored from __doc__ """ TransformVectors(self, inVrs:vtkDataArray, outVrs:vtkDataArray) -> None C++: virtual void TransformVectors(vtkDataArray *inVrs, vtkDataArray *outVrs) Apply the transformation to a series of vectors, and append the results to outVrs. """ 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__': 'vtkLinearTransform', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'TransformNormal': , 'TransformFloatNormal': , 'TransformDoubleNormal': , 'TransformVector': , 'TransformFloatVector': , 'TransformDoubleVector': , 'TransformPoints': , 'TransformNormals': , 'TransformVectors': , 'GetLinearInverse': , 'InternalTransformPoint': , 'InternalTransformNormal': , 'InternalTransformVector': , 'InternalTransformDerivative': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkLinearTransform - abstract superclass for linear transformations\\n\\nSuperclass: vtkHomogeneousTransform\\n\\nvtkLinearTransform provides a generic interface for linear (affine or\\n12 degree-of-freedom) geometric transformations.\\n\\n@warning\\nPortions of this class (i.e., when transforming arrays of points\\nand/or associated attributes such as normals and vectors) has been\\nthreaded with vtkSMPTools. Using TBB or other non-sequential type\\n(set in the CMake variable VTK_SMP_IMPLEMENTATION_TYPE) may improve\\nperformance significantly.\\n\\n@sa\\nvtkTransform vtkIdentityTransform\\n\\n'})" __vtkname__ = 'vtkLinearTransform' class vtkIdentityTransform(vtkLinearTransform): """ vtkIdentityTransform - a transform that doesn't do anything Superclass: vtkLinearTransform vtkIdentityTransform is a transformation which will simply pass coordinate data unchanged. All other transform types can also do this, however, the vtkIdentityTransform does so with much greater efficiency. @sa vtkLinearTransform """ 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 InternalTransformDerivative(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InternalTransformDerivative(self, in_:(float, float, float), out:[float, float, float], derivative:[[float, float, float], [float, float, float], [float, float, float]]) -> None C++: void InternalTransformDerivative(const double in[3], double out[3], double derivative[3][3]) override; """ pass def InternalTransformNormal(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InternalTransformNormal(self, in_:(float, float, float), out:[float, float, float]) -> None C++: void InternalTransformNormal(const double in[3], double out[3]) override; """ pass def InternalTransformPoint(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InternalTransformPoint(self, in_:(float, float, float), out:[float, float, float]) -> None C++: void InternalTransformPoint(const double in[3], double out[3]) override; """ pass def InternalTransformVector(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InternalTransformVector(self, in_:(float, float, float), out:[float, float, float]) -> None C++: void InternalTransformVector(const double in[3], double out[3]) override; """ pass def Inverse(self): # real signature unknown; restored from __doc__ """ Inverse(self) -> None C++: void Inverse() override; Invert the transformation. """ 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 MakeTransform(self): # real signature unknown; restored from __doc__ """ MakeTransform(self) -> vtkAbstractTransform C++: vtkAbstractTransform *MakeTransform() override; Make a transform of the same type. This will actually return the same transform. """ return vtkAbstractTransform def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkIdentityTransform C++: vtkIdentityTransform *NewInstance() """ return vtkIdentityTransform def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkIdentityTransform C++: static vtkIdentityTransform *SafeDownCast(vtkObjectBase *o) """ return vtkIdentityTransform def TransformNormals(self, inNms, outNms): # real signature unknown; restored from __doc__ """ TransformNormals(self, inNms:vtkDataArray, outNms:vtkDataArray) -> None C++: void TransformNormals(vtkDataArray *inNms, vtkDataArray *outNms) override; Apply the transformation to a series of normals, and append the results to outNms. """ pass def TransformPoints(self, inPts, outPts): # real signature unknown; restored from __doc__ """ TransformPoints(self, inPts:vtkPoints, outPts:vtkPoints) -> None C++: void TransformPoints(vtkPoints *inPts, vtkPoints *outPts) override; Apply the transformation to a series of points, and append the results to outPts. """ pass def TransformVectors(self, inVrs, outVrs): # real signature unknown; restored from __doc__ """ TransformVectors(self, inVrs:vtkDataArray, outVrs:vtkDataArray) -> None C++: void TransformVectors(vtkDataArray *inVrs, vtkDataArray *outVrs) override; Apply the transformation to a series of vectors, and append the results to outVrs. """ 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__\': \'vtkIdentityTransform\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'TransformPoints\': , \'TransformNormals\': , \'TransformVectors\': , \'Inverse\': , \'InternalTransformPoint\': , \'InternalTransformNormal\': , \'InternalTransformVector\': , \'InternalTransformDerivative\': , \'MakeTransform\': , \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': "vtkIdentityTransform - a transform that doesn\'t do anything\\n\\nSuperclass: vtkLinearTransform\\n\\nvtkIdentityTransform is a transformation which will simply pass\\ncoordinate data unchanged. All other transform types can also do\\nthis, however, the vtkIdentityTransform does so with much greater\\nefficiency.\\n@sa\\nvtkLinearTransform\\n\\n"})' __vtkname__ = 'vtkIdentityTransform' class vtkLandmarkTransform(vtkLinearTransform): """ vtkLandmarkTransform - a linear transform specified by two corresponding point sets Superclass: vtkLinearTransform A vtkLandmarkTransform is defined by two sets of landmarks, the transform computed gives the best fit mapping one onto the other, in a least squares sense. The indices are taken to correspond, so point 1 in the first set will get mapped close to point 1 in the second set, etc. Call SetSourceLandmarks and SetTargetLandmarks to specify the two sets of landmarks, ensure they have the same number of points. @warning Whenever you add, subtract, or set points you must call Modified() on the vtkPoints object, or the transformation might not update. @sa vtkLinearTransform """ def GetMode(self): # real signature unknown; restored from __doc__ """ GetMode(self) -> int C++: virtual int GetMode() Get the current transformation mode. """ return 0 def GetModeAsString(self): # real signature unknown; restored from __doc__ """ GetModeAsString(self) -> str C++: const char *GetModeAsString() """ return "" def GetMTime(self): # real signature unknown; restored from __doc__ """ GetMTime(self) -> int C++: vtkMTimeType GetMTime() override; Get the MTime. """ 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 GetSourceLandmarks(self): # real signature unknown; restored from __doc__ """ GetSourceLandmarks(self) -> vtkPoints C++: virtual vtkPoints *GetSourceLandmarks() """ pass def GetTargetLandmarks(self): # real signature unknown; restored from __doc__ """ GetTargetLandmarks(self) -> vtkPoints C++: virtual vtkPoints *GetTargetLandmarks() """ pass def Inverse(self): # real signature unknown; restored from __doc__ """ Inverse(self) -> None C++: void Inverse() override; Invert the transformation. This is done by switching the source and target landmarks. """ 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 MakeTransform(self): # real signature unknown; restored from __doc__ """ MakeTransform(self) -> vtkAbstractTransform C++: vtkAbstractTransform *MakeTransform() override; Make another transform of the same type. """ return vtkAbstractTransform def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkLandmarkTransform C++: vtkLandmarkTransform *NewInstance() """ return vtkLandmarkTransform def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkLandmarkTransform C++: static vtkLandmarkTransform *SafeDownCast(vtkObjectBase *o) """ return vtkLandmarkTransform def SetMode(self, _arg): # real signature unknown; restored from __doc__ """ SetMode(self, _arg:int) -> None C++: virtual void SetMode(int _arg) Set the number of degrees of freedom to constrain the solution to. Rigidbody (VTK_LANDMARK_RIGIDBODY): rotation and translation only. Similarity (VTK_LANDMARK_SIMILARITY): rotation, translation and isotropic scaling. Affine (VTK_LANDMARK_AFFINE): collinearity is preserved. Ratios of distances along a line are preserved. The default is similarity. """ pass def SetModeToAffine(self): # real signature unknown; restored from __doc__ """ SetModeToAffine(self) -> None C++: void SetModeToAffine() """ pass def SetModeToRigidBody(self): # real signature unknown; restored from __doc__ """ SetModeToRigidBody(self) -> None C++: void SetModeToRigidBody() """ pass def SetModeToSimilarity(self): # real signature unknown; restored from __doc__ """ SetModeToSimilarity(self) -> None C++: void SetModeToSimilarity() """ pass def SetSourceLandmarks(self, source): # real signature unknown; restored from __doc__ """ SetSourceLandmarks(self, source:vtkPoints) -> None C++: void SetSourceLandmarks(vtkPoints *source) Specify the source and target landmark sets. The two sets must have the same number of points. If you add or change points in these objects, you must call Modified() on them or the transformation might not update. """ pass def SetTargetLandmarks(self, target): # real signature unknown; restored from __doc__ """ SetTargetLandmarks(self, target:vtkPoints) -> None C++: void SetTargetLandmarks(vtkPoints *target) """ 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__': 'vtkLandmarkTransform', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'SetSourceLandmarks': , 'SetTargetLandmarks': , 'GetSourceLandmarks': , 'GetTargetLandmarks': , 'SetMode': , 'SetModeToRigidBody': , 'SetModeToSimilarity': , 'SetModeToAffine': , 'GetMode': , 'GetModeAsString': , 'Inverse': , 'GetMTime': , 'MakeTransform': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkLandmarkTransform - a linear transform specified by two\\ncorresponding point sets\\n\\nSuperclass: vtkLinearTransform\\n\\nA vtkLandmarkTransform is defined by two sets of landmarks, the\\ntransform computed gives the best fit mapping one onto the other, in\\na least squares sense. The indices are taken to correspond, so point\\n1 in the first set will get mapped close to point 1 in the second\\nset, etc. Call SetSourceLandmarks and SetTargetLandmarks to specify\\nthe two sets of landmarks, ensure they have the same number of\\npoints.\\n@warning\\nWhenever you add, subtract, or set points you must call Modified() on\\nthe vtkPoints object, or the transformation might not update.\\n@sa\\nvtkLinearTransform\\n\\n'})" __vtkname__ = 'vtkLandmarkTransform' class vtkMatrixToHomogeneousTransform(vtkHomogeneousTransform): """ vtkMatrixToHomogeneousTransform - convert a matrix to a transform Superclass: vtkHomogeneousTransform This is a very simple class which allows a vtkMatrix4x4 to be used in place of a vtkHomogeneousTransform or vtkAbstractTransform. For example, if you use it as a proxy between a matrix and vtkTransformPolyDataFilter then any modifications to the matrix will automatically be reflected in the output of the filter. @sa vtkPerspectiveTransform vtkMatrix4x4 vtkMatrixToLinearTransform """ def GetInput(self): # real signature unknown; restored from __doc__ """ GetInput(self) -> vtkMatrix4x4 C++: virtual vtkMatrix4x4 *GetInput() """ pass def GetMTime(self): # real signature unknown; restored from __doc__ """ GetMTime(self) -> int C++: vtkMTimeType GetMTime() override; Get the MTime: this is the bit of magic that makes everything work. """ 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 Inverse(self): # real signature unknown; restored from __doc__ """ Inverse(self) -> None C++: void Inverse() override; The input matrix is left as-is, but the transformation matrix is inverted. """ 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 MakeTransform(self): # real signature unknown; restored from __doc__ """ MakeTransform(self) -> vtkAbstractTransform C++: vtkAbstractTransform *MakeTransform() override; Make a new transform of the same type. """ return vtkAbstractTransform def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkMatrixToHomogeneousTransform C++: vtkMatrixToHomogeneousTransform *NewInstance() """ return vtkMatrixToHomogeneousTransform def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkMatrixToHomogeneousTransform C++: static vtkMatrixToHomogeneousTransform *SafeDownCast( vtkObjectBase *o) """ return vtkMatrixToHomogeneousTransform def SetInput(self, __a): # real signature unknown; restored from __doc__ """ SetInput(self, __a:vtkMatrix4x4) -> None C++: virtual void SetInput(vtkMatrix4x4 *) """ 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__': 'vtkMatrixToHomogeneousTransform', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'SetInput': , 'GetInput': , 'Inverse': , 'GetMTime': , 'MakeTransform': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkMatrixToHomogeneousTransform - convert a matrix to a transform\\n\\nSuperclass: vtkHomogeneousTransform\\n\\nThis is a very simple class which allows a vtkMatrix4x4 to be used in\\nplace of a vtkHomogeneousTransform or vtkAbstractTransform. For\\nexample, if you use it as a proxy between a matrix and\\nvtkTransformPolyDataFilter then any modifications to the matrix will\\nautomatically be reflected in the output of the filter.\\n@sa\\nvtkPerspectiveTransform vtkMatrix4x4 vtkMatrixToLinearTransform\\n\\n'})" __vtkname__ = 'vtkMatrixToHomogeneousTransform' class vtkMatrixToLinearTransform(vtkLinearTransform): """ vtkMatrixToLinearTransform - convert a matrix to a transform Superclass: vtkLinearTransform This is a very simple class which allows a vtkMatrix4x4 to be used in place of a vtkLinearTransform or vtkAbstractTransform. For example, if you use it as a proxy between a matrix and vtkTransformPolyDataFilter then any modifications to the matrix will automatically be reflected in the output of the filter. @sa vtkTransform vtkMatrix4x4 vtkMatrixToHomogeneousTransform """ def GetInput(self): # real signature unknown; restored from __doc__ """ GetInput(self) -> vtkMatrix4x4 C++: virtual vtkMatrix4x4 *GetInput() """ pass def GetMTime(self): # real signature unknown; restored from __doc__ """ GetMTime(self) -> int C++: vtkMTimeType GetMTime() override; Get the MTime: this is the bit of magic that makes everything work. """ 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 Inverse(self): # real signature unknown; restored from __doc__ """ Inverse(self) -> None C++: void Inverse() override; The input matrix is left as-is, but the transformation matrix is inverted. """ 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 MakeTransform(self): # real signature unknown; restored from __doc__ """ MakeTransform(self) -> vtkAbstractTransform C++: vtkAbstractTransform *MakeTransform() override; Make a new transform of the same type. """ return vtkAbstractTransform def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkMatrixToLinearTransform C++: vtkMatrixToLinearTransform *NewInstance() """ return vtkMatrixToLinearTransform def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkMatrixToLinearTransform C++: static vtkMatrixToLinearTransform *SafeDownCast( vtkObjectBase *o) """ return vtkMatrixToLinearTransform def SetInput(self, __a): # real signature unknown; restored from __doc__ """ SetInput(self, __a:vtkMatrix4x4) -> None C++: virtual void SetInput(vtkMatrix4x4 *) Set the input matrix. Any modifications to the matrix will be reflected in the transformation. """ 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__': 'vtkMatrixToLinearTransform', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'SetInput': , 'GetInput': , 'Inverse': , 'GetMTime': , 'MakeTransform': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkMatrixToLinearTransform - convert a matrix to a transform\\n\\nSuperclass: vtkLinearTransform\\n\\nThis is a very simple class which allows a vtkMatrix4x4 to be used in\\nplace of a vtkLinearTransform or vtkAbstractTransform. For example,\\nif you use it as a proxy between a matrix and\\nvtkTransformPolyDataFilter then any modifications to the matrix will\\nautomatically be reflected in the output of the filter.\\n@sa\\nvtkTransform vtkMatrix4x4 vtkMatrixToHomogeneousTransform\\n\\n'})" __vtkname__ = 'vtkMatrixToLinearTransform' class vtkPerspectiveTransform(vtkHomogeneousTransform): """ vtkPerspectiveTransform - describes a 4x4 matrix transformation Superclass: vtkHomogeneousTransform A vtkPerspectiveTransform can be used to describe the full range of homogeneous transformations. It was designed in particular to describe a camera-view of a scene. The order in which you set up the display coordinates (via AdjustZBuffer() and AdjustViewport()), the projection (via Perspective(), Frustum(), or Ortho()) and the camera view (via SetupCamera()) are important. If the transform is in PreMultiply mode, which is the default, set the Viewport and ZBuffer first, then the projection, and finally the camera view. Once the view is set up, the Translate and Rotate methods can be used to move the camera around in world coordinates. If the Oblique() or Stereo() methods are used, they should be called just before SetupCamera(). In PostMultiply mode, you must perform all transformations in the opposite order. This is necessary, for example, if you already have a perspective transformation set up but must adjust the viewport. Another example is if you have a view transformation, and wish to perform translations and rotations in the camera's coordinate system rather than in world coordinates. The SetInput and Concatenate methods can be used to create a transformation pipeline with vtkPerspectiveTransform. See vtkTransform for more information on the transformation pipeline. @sa vtkGeneralTransform vtkTransform vtkMatrix4x4 vtkCamera """ def AdjustViewport(self, oldXMin, oldXMax, oldYMin, oldYMax, newXMin, newXMax, newYMin, newYMax): # real signature unknown; restored from __doc__ """ AdjustViewport(self, oldXMin:float, oldXMax:float, oldYMin:float, oldYMax:float, newXMin:float, newXMax:float, newYMin:float, newYMax:float) -> None C++: void AdjustViewport(double oldXMin, double oldXMax, double oldYMin, double oldYMax, double newXMin, double newXMax, double newYMin, double newYMax) Perform an adjustment to the viewport coordinates. By default Ortho, Frustum, and Perspective provide a window of ([-1,+1],[-1,+1]). In PreMultiply mode, you call this method before calling Ortho, Frustum, or Perspective. In PostMultiply mode you can call it after. Note that if you must apply both AdjustZBuffer and AdjustViewport, it makes no difference which order you apply them in. """ pass def AdjustZBuffer(self, oldNearZ, oldFarZ, newNearZ, newFarZ): # real signature unknown; restored from __doc__ """ AdjustZBuffer(self, oldNearZ:float, oldFarZ:float, newNearZ:float, newFarZ:float) -> None C++: void AdjustZBuffer(double oldNearZ, double oldFarZ, double newNearZ, double newFarZ) Perform an adjustment to the Z-Buffer range that the near and far clipping planes map to. By default Ortho, Frustum, and Perspective map the near clipping plane to -1 and the far clipping plane to +1. In PreMultiply mode, you call this method before calling Ortho, Frustum, or Perspective. In PostMultiply mode you can call it after. """ pass def CircuitCheck(self, transform): # real signature unknown; restored from __doc__ """ CircuitCheck(self, transform:vtkAbstractTransform) -> int C++: int CircuitCheck(vtkAbstractTransform *transform) override; Check for self-reference. Will return true if concatenating with the specified transform, setting it to be our inverse, or setting it to be our input will create a circular reference. CircuitCheck is automatically called by SetInput(), SetInverse(), and Concatenate(vtkXTransform *). Avoid using this function, it is experimental. """ return 0 def Concatenate(self, matrix): # real signature unknown; restored from __doc__ """ Concatenate(self, matrix:vtkMatrix4x4) -> None C++: void Concatenate(vtkMatrix4x4 *matrix) Concatenate(self, elements:(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float)) -> None C++: void Concatenate(const double elements[16]) Concatenate(self, transform:vtkHomogeneousTransform) -> None C++: void Concatenate(vtkHomogeneousTransform *transform) Concatenates the matrix with the current transformation according to PreMultiply or PostMultiply semantics. """ pass def Frustum(self, xmin, xmax, ymin, ymax, znear, zfar): # real signature unknown; restored from __doc__ """ Frustum(self, xmin:float, xmax:float, ymin:float, ymax:float, znear:float, zfar:float) -> None C++: void Frustum(double xmin, double xmax, double ymin, double ymax, double znear, double zfar) Create an perspective projection matrix and concatenate it by the current transformation. The matrix maps a frustum with a back plane at -zfar and a front plane at -znear with extent [xmin,xmax],[ymin,ymax] to [-1,+1], [-1,+1], [+1,-1]. """ pass def GetConcatenatedTransform(self, i): # real signature unknown; restored from __doc__ """ GetConcatenatedTransform(self, i:int) -> vtkHomogeneousTransform C++: vtkHomogeneousTransform *GetConcatenatedTransform(int i) Get one of the concatenated transformations as a vtkAbstractTransform. These transformations are applied, in series, every time the transformation of a coordinate occurs. This method is provided to make it possible to decompose a transformation into its constituents, for example to save a transformation to a file. """ return vtkHomogeneousTransform def GetInput(self): # real signature unknown; restored from __doc__ """ GetInput(self) -> vtkHomogeneousTransform C++: vtkHomogeneousTransform *GetInput() """ return vtkHomogeneousTransform def GetInverseFlag(self): # real signature unknown; restored from __doc__ """ GetInverseFlag(self) -> int C++: int GetInverseFlag() Get the inverse flag of the transformation. This controls whether it is the Input or the inverse of the Input that is used as the base transformation. The InverseFlag is flipped every time Inverse() is called. The InverseFlag is off when a transform is first created. """ return 0 def GetMTime(self): # real signature unknown; restored from __doc__ """ GetMTime(self) -> int C++: vtkMTimeType GetMTime() override; Override GetMTime to account for input and concatenation. """ return 0 def GetNumberOfConcatenatedTransforms(self): # real signature unknown; restored from __doc__ """ GetNumberOfConcatenatedTransforms(self) -> int C++: int GetNumberOfConcatenatedTransforms() Get the total number of transformations that are linked into this one via Concatenate() operations or via SetInput(). """ 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 Identity(self): # real signature unknown; restored from __doc__ """ Identity(self) -> None C++: void Identity() Set this transformation to the identity transformation. If the transform has an Input, then the transformation will be reset so that it is the same as the Input. """ pass def Inverse(self): # real signature unknown; restored from __doc__ """ Inverse(self) -> None C++: void Inverse() override; Invert the transformation. This will also set a flag so that the transformation will use the inverse of its Input, if an Input has been set. """ 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 MakeTransform(self): # real signature unknown; restored from __doc__ """ MakeTransform(self) -> vtkAbstractTransform C++: vtkAbstractTransform *MakeTransform() override; Make a new transform of the same type -- you are responsible for deleting the transform when you are done with it. """ return vtkAbstractTransform def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkPerspectiveTransform C++: vtkPerspectiveTransform *NewInstance() """ return vtkPerspectiveTransform def Ortho(self, xmin, xmax, ymin, ymax, znear, zfar): # real signature unknown; restored from __doc__ """ Ortho(self, xmin:float, xmax:float, ymin:float, ymax:float, znear:float, zfar:float) -> None C++: void Ortho(double xmin, double xmax, double ymin, double ymax, double znear, double zfar) Create an orthogonal projection matrix and concatenate it by the current transformation. The matrix maps [xmin,xmax], [ymin,ymax], [-znear,-zfar] to [-1,+1], [-1,+1], [+1,-1]. """ pass def Perspective(self, angle, aspect, znear, zfar): # real signature unknown; restored from __doc__ """ Perspective(self, angle:float, aspect:float, znear:float, zfar:float) -> None C++: void Perspective(double angle, double aspect, double znear, double zfar) Create a perspective projection matrix by specifying the view angle (this angle is in the y direction), the aspect ratio, and the near and far clipping range. The projection matrix is concatenated with the current transformation. This method works via Frustum. """ pass def Pop(self): # real signature unknown; restored from __doc__ """ Pop(self) -> None C++: void Pop() Deletes the transformation on the top of the stack and sets the top to the next transformation on the stack. """ pass def PostMultiply(self): # real signature unknown; restored from __doc__ """ PostMultiply(self) -> None C++: void PostMultiply() Sets the internal state of the transform to PostMultiply. All subsequent operations will occur after those already represented in the current transformation. In homogeneous matrix notation, M = A*M where M is the current transformation matrix and A is the applied matrix. The default is PreMultiply. """ pass def PreMultiply(self): # real signature unknown; restored from __doc__ """ PreMultiply(self) -> None C++: void PreMultiply() Sets the internal state of the transform to PreMultiply. All subsequent operations will occur before those already represented in the current transformation. In homogeneous matrix notation, M = M*A where M is the current transformation matrix and A is the applied matrix. The default is PreMultiply. """ pass def Push(self): # real signature unknown; restored from __doc__ """ Push(self) -> None C++: void Push() Pushes the current transformation onto the transformation stack. """ pass def RotateWXYZ(self, angle, x, y, z): # real signature unknown; restored from __doc__ """ RotateWXYZ(self, angle:float, x:float, y:float, z:float) -> None C++: void RotateWXYZ(double angle, double x, double y, double z) RotateWXYZ(self, angle:float, axis:(float, float, float)) -> None C++: void RotateWXYZ(double angle, const double axis[3]) Create a rotation matrix and concatenate it with the current transformation according to PreMultiply or PostMultiply semantics. The angle is in degrees, and (x,y,z) specifies the axis that the rotation will be performed around. """ pass def RotateX(self, angle): # real signature unknown; restored from __doc__ """ RotateX(self, angle:float) -> None C++: void RotateX(double angle) Create a rotation matrix about the X, Y, or Z axis and concatenate it with the current transformation according to PreMultiply or PostMultiply semantics. The angle is expressed in degrees. """ pass def RotateY(self, angle): # real signature unknown; restored from __doc__ """ RotateY(self, angle:float) -> None C++: void RotateY(double angle) """ pass def RotateZ(self, angle): # real signature unknown; restored from __doc__ """ RotateZ(self, angle:float) -> None C++: void RotateZ(double angle) """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkPerspectiveTransform C++: static vtkPerspectiveTransform *SafeDownCast( vtkObjectBase *o) """ return vtkPerspectiveTransform def Scale(self, x, y, z): # real signature unknown; restored from __doc__ """ Scale(self, x:float, y:float, z:float) -> None C++: void Scale(double x, double y, double z) Scale(self, s:(float, float, float)) -> None C++: void Scale(const double s[3]) Create a scale matrix (i.e. set the diagonal elements to x, y, z) and concatenate it with the current transformation according to PreMultiply or PostMultiply semantics. """ pass def SetInput(self, input): # real signature unknown; restored from __doc__ """ SetInput(self, input:vtkHomogeneousTransform) -> None C++: void SetInput(vtkHomogeneousTransform *input) Set the input for this transformation. This will be used as the base transformation if it is set. This method allows you to build a transform pipeline: if the input is modified, then this transformation will automatically update accordingly. Note that the InverseFlag, controlled via Inverse(), determines whether this transformation will use the Input or the inverse of the Input. """ pass def SetMatrix(self, matrix): # real signature unknown; restored from __doc__ """ SetMatrix(self, matrix:vtkMatrix4x4) -> None C++: void SetMatrix(vtkMatrix4x4 *matrix) SetMatrix(self, elements:(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float)) -> None C++: void SetMatrix(const double elements[16]) Set the current matrix directly. This actually calls Identity(), followed by Concatenate(matrix). """ pass def SetupCamera(self, position, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ SetupCamera(self, position:(float, float, float), focalpoint:( float, float, float), viewup:(float, float, float)) -> None C++: void SetupCamera(const double position[3], const double focalpoint[3], const double viewup[3]) SetupCamera(self, p0:float, p1:float, p2:float, fp0:float, fp1:float, fp2:float, vup0:float, vup1:float, vup2:float) -> None C++: void SetupCamera(double p0, double p1, double p2, double fp0, double fp1, double fp2, double vup0, double vup1, double vup2) Set a view transformation matrix for the camera (this matrix does not contain any perspective) and concatenate it with the current transformation. """ pass def Shear(self, dxdz, dydz, zplane): # real signature unknown; restored from __doc__ """ Shear(self, dxdz:float, dydz:float, zplane:float) -> None C++: void Shear(double dxdz, double dydz, double zplane) Create a shear transformation about a plane at distance z from the camera. The values dxdz (i.e. dx/dz) and dydz specify the amount of shear in the x and y directions. The 'zplane' specifies the distance from the camera to the plane at which the shear causes zero displacement. Generally you want this plane to be the focal plane. This transformation can be used in combination with Ortho to create an oblique projection. It can also be used in combination with Perspective to provide correct stereo views when the eye is at arbitrary but known positions relative to the center of a flat viewing screen. """ pass def Stereo(self, angle, focaldistance): # real signature unknown; restored from __doc__ """ Stereo(self, angle:float, focaldistance:float) -> None C++: void Stereo(double angle, double focaldistance) Create a stereo shear matrix and concatenate it with the current transformation. This can be applied in conjunction with either a perspective transformation (via Frustum or Projection) or an orthographic projection. You must specify the distance from the camera plane to the focal plane, and the angle between the distance vector and the eye. The angle should be negative for the left eye, and positive for the right. This method works via Oblique. """ pass def Translate(self, x, y, z): # real signature unknown; restored from __doc__ """ Translate(self, x:float, y:float, z:float) -> None C++: void Translate(double x, double y, double z) Translate(self, x:(float, float, float)) -> None C++: void Translate(const double x[3]) Create a translation matrix and concatenate it with the current transformation according to PreMultiply or PostMultiply semantics. """ 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__\': \'vtkPerspectiveTransform\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'Identity\': , \'Inverse\': , \'AdjustViewport\': , \'AdjustZBuffer\': , \'Ortho\': , \'Frustum\': , \'Perspective\': , \'Shear\': , \'Stereo\': , \'SetupCamera\': , \'Translate\': , \'RotateWXYZ\': , \'RotateX\': , \'RotateY\': , \'RotateZ\': , \'Scale\': , \'SetMatrix\': , \'Concatenate\': , \'PreMultiply\': , \'PostMultiply\': , \'GetNumberOfConcatenatedTransforms\': , \'GetConcatenatedTransform\': , \'SetInput\': , \'GetInput\': , \'GetInverseFlag\': , \'Push\': , \'Pop\': , \'MakeTransform\': , \'CircuitCheck\': , \'GetMTime\': , \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': "vtkPerspectiveTransform - describes a 4x4 matrix transformation\\n\\nSuperclass: vtkHomogeneousTransform\\n\\nA vtkPerspectiveTransform can be used to describe the full range of\\nhomogeneous transformations. It was designed in particular to\\ndescribe a camera-view of a scene.\\n\\nThe order in which you set up the display coordinates (via\\nAdjustZBuffer() and AdjustViewport()), the projection (via\\nPerspective(), Frustum(), or Ortho()) and the camera view (via\\nSetupCamera()) are important. If the transform is in PreMultiply\\nmode, which is the default, set the Viewport and ZBuffer first, then\\nthe projection, and finally the camera view. Once the view is set\\nup, the Translate and Rotate methods can be used to move the camera\\naround in world coordinates. If the Oblique() or Stereo() methods\\nare used, they should be called just before SetupCamera().\\n\\nIn PostMultiply mode, you must perform all transformations in the\\nopposite order. This is necessary, for example, if you already have\\na perspective transformation set up but must adjust the viewport. \\nAnother example is if you have a view transformation, and wish to\\nperform translations and rotations in the camera\'s coordinate system\\nrather than in world coordinates.\\n\\nThe SetInput and Concatenate methods can be used to create a\\ntransformation pipeline with vtkPerspectiveTransform. See\\nvtkTransform for more information on the transformation pipeline.\\n@sa\\nvtkGeneralTransform vtkTransform vtkMatrix4x4 vtkCamera\\n\\n"})' __vtkname__ = 'vtkPerspectiveTransform' class vtkSphericalTransform(vtkWarpTransform): """ vtkSphericalTransform - spherical to rectangular coords and back Superclass: vtkWarpTransform vtkSphericalTransform will convert (r,phi,theta) coordinates to (x,y,z) coordinates and back again. The angles are given in radians. By default, it converts spherical coordinates to rectangular, but GetInverse() returns a transform that will do the opposite. The equation that is used is x = r*sin(phi)*cos(theta), y = r*sin(phi)*sin(theta), z = r*cos(phi). @warning This transform is not well behaved along the line x=y=0 (i.e. along the z-axis) @sa vtkCylindricalTransform vtkGeneralTransform """ 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 MakeTransform(self): # real signature unknown; restored from __doc__ """ MakeTransform(self) -> vtkAbstractTransform C++: vtkAbstractTransform *MakeTransform() override; Make another transform of the same type. """ return vtkAbstractTransform def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkSphericalTransform C++: vtkSphericalTransform *NewInstance() """ return vtkSphericalTransform def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkSphericalTransform C++: static vtkSphericalTransform *SafeDownCast(vtkObjectBase *o) """ return vtkSphericalTransform 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__': 'vtkSphericalTransform', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'MakeTransform': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkSphericalTransform - spherical to rectangular coords and back\\n\\nSuperclass: vtkWarpTransform\\n\\nvtkSphericalTransform will convert (r,phi,theta) coordinates to\\n(x,y,z) coordinates and back again. The angles are given in radians.\\nBy default, it converts spherical coordinates to rectangular, but\\nGetInverse() returns a transform that will do the opposite. The\\nequation that is used is x = r*sin(phi)*cos(theta), y =\\nr*sin(phi)*sin(theta), z = r*cos(phi).\\n@warning\\nThis transform is not well behaved along the line x=y=0 (i.e. along\\nthe z-axis)\\n@sa\\nvtkCylindricalTransform vtkGeneralTransform\\n\\n'})" __vtkname__ = 'vtkSphericalTransform' class vtkThinPlateSplineTransform(vtkWarpTransform): """ vtkThinPlateSplineTransform - a nonlinear warp transformation Superclass: vtkWarpTransform vtkThinPlateSplineTransform describes a nonlinear warp transform defined by a set of source and target landmarks. Any point on the mesh close to a source landmark will be moved to a place close to the corresponding target landmark. The points in between are interpolated smoothly using Bookstein's Thin Plate Spline algorithm. To obtain a correct TPS warp, use the R2LogR kernel if your data is 2D, and the R kernel if your data is 3D. Or you can specify your own RBF. (Hence this class is more general than a pure TPS transform.) @warning 1) The inverse transform is calculated using an iterative method, and is several times more expensive than the forward transform. 2) Whenever you add, subtract, or set points you must call Modified() on the vtkPoints object, or the transformation might not update. 3) Collinear point configurations (except those that lie in the XY plane) result in an unstable transformation. Forward transform can be computed for any configuration by disabling bulk transform regularization. @sa vtkGridTransform vtkGeneralTransform """ def GetBasis(self): # real signature unknown; restored from __doc__ """ GetBasis(self) -> int C++: virtual int GetBasis() """ return 0 def GetBasisAsString(self): # real signature unknown; restored from __doc__ """ GetBasisAsString(self) -> str C++: const char *GetBasisAsString() """ return "" def GetMTime(self): # real signature unknown; restored from __doc__ """ GetMTime(self) -> int C++: vtkMTimeType GetMTime() override; Get the MTime. """ 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 GetRegularizeBulkTransform(self): # real signature unknown; restored from __doc__ """ GetRegularizeBulkTransform(self) -> bool C++: virtual bool GetRegularizeBulkTransform() Get/set whether the bulk linear transformation matrix is regularized. If regularization is enabled: If all landmark points are on the XY plane then forward and inverse transforms are computed correctly. For other coplanar configurations, both forward an inverse transform computation is unstable. If regularization is disabled: Forward transform is computed correctly for all point configurations. Inverse transform computation is unstable if source and/or target points are coplanar. If landmarks points are not coplanar then this setting has no effect. The default is true. """ return False def GetSigma(self): # real signature unknown; restored from __doc__ """ GetSigma(self) -> float C++: virtual double GetSigma() Specify the 'stiffness' of the spline. The default is 1.0. """ return 0.0 def GetSourceLandmarks(self): # real signature unknown; restored from __doc__ """ GetSourceLandmarks(self) -> vtkPoints C++: virtual vtkPoints *GetSourceLandmarks() """ pass def GetTargetLandmarks(self): # real signature unknown; restored from __doc__ """ GetTargetLandmarks(self) -> vtkPoints C++: virtual vtkPoints *GetTargetLandmarks() """ 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 MakeTransform(self): # real signature unknown; restored from __doc__ """ MakeTransform(self) -> vtkAbstractTransform C++: vtkAbstractTransform *MakeTransform() override; Make another transform of the same type. """ return vtkAbstractTransform def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkThinPlateSplineTransform C++: vtkThinPlateSplineTransform *NewInstance() """ return vtkThinPlateSplineTransform def RegularizeBulkTransformOff(self): # real signature unknown; restored from __doc__ """ RegularizeBulkTransformOff(self) -> None C++: virtual void RegularizeBulkTransformOff() """ pass def RegularizeBulkTransformOn(self): # real signature unknown; restored from __doc__ """ RegularizeBulkTransformOn(self) -> None C++: virtual void RegularizeBulkTransformOn() """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkThinPlateSplineTransform C++: static vtkThinPlateSplineTransform *SafeDownCast( vtkObjectBase *o) """ return vtkThinPlateSplineTransform def SetBasis(self, basis): # real signature unknown; restored from __doc__ """ SetBasis(self, basis:int) -> None C++: void SetBasis(int basis) Specify the radial basis function to use. The default is R2LogR which is appropriate for 2D. Use |R| (SetBasisToR) if your data is 3D. Alternatively specify your own basis function, however this will mean that the transform will no longer be a true thin-plate spline. """ pass def SetBasisToR(self): # real signature unknown; restored from __doc__ """ SetBasisToR(self) -> None C++: void SetBasisToR() """ pass def SetBasisToR2LogR(self): # real signature unknown; restored from __doc__ """ SetBasisToR2LogR(self) -> None C++: void SetBasisToR2LogR() """ pass def SetRegularizeBulkTransform(self, _arg): # real signature unknown; restored from __doc__ """ SetRegularizeBulkTransform(self, _arg:bool) -> None C++: virtual void SetRegularizeBulkTransform(bool _arg) """ pass def SetSigma(self, _arg): # real signature unknown; restored from __doc__ """ SetSigma(self, _arg:float) -> None C++: virtual void SetSigma(double _arg) """ pass def SetSourceLandmarks(self, source): # real signature unknown; restored from __doc__ """ SetSourceLandmarks(self, source:vtkPoints) -> None C++: void SetSourceLandmarks(vtkPoints *source) Set the source landmarks for the warp. If you add or change the vtkPoints object, you must call Modified() on it or the transformation might not update. """ pass def SetTargetLandmarks(self, target): # real signature unknown; restored from __doc__ """ SetTargetLandmarks(self, target:vtkPoints) -> None C++: void SetTargetLandmarks(vtkPoints *target) Set the target landmarks for the warp. If you add or change the vtkPoints object, you must call Modified() on it or the transformation might not update. """ 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__\': \'vtkThinPlateSplineTransform\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'GetSigma\': , \'SetSigma\': , \'SetBasis\': , \'GetBasis\': , \'SetBasisToR\': , \'SetBasisToR2LogR\': , \'GetBasisAsString\': , \'SetSourceLandmarks\': , \'GetSourceLandmarks\': , \'SetTargetLandmarks\': , \'GetTargetLandmarks\': , \'GetMTime\': , \'MakeTransform\': , \'GetRegularizeBulkTransform\': , \'SetRegularizeBulkTransform\': , \'RegularizeBulkTransformOn\': , \'RegularizeBulkTransformOff\': , \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': "vtkThinPlateSplineTransform - a nonlinear warp transformation\\n\\nSuperclass: vtkWarpTransform\\n\\nvtkThinPlateSplineTransform describes a nonlinear warp transform\\ndefined by a set of source and target landmarks. Any point on the\\nmesh close to a source landmark will be moved to a place close to the\\ncorresponding target landmark. The points in between are interpolated\\nsmoothly using Bookstein\'s Thin Plate Spline algorithm.\\n\\nTo obtain a correct TPS warp, use the R2LogR kernel if your data is\\n2D, and the R kernel if your data is 3D. Or you can specify your own\\nRBF. (Hence this class is more general than a pure TPS transform.)\\n@warning\\n1) The inverse transform is calculated using an iterative method,\\nand is several times more expensive than the forward transform.\\n2) Whenever you add, subtract, or set points you must call Modified()\\n on the vtkPoints object, or the transformation might not update.\\n3) Collinear point configurations (except those that lie in the XY\\n plane) result in an unstable transformation. Forward transform can\\nbe computed for any configuration by disabling bulk transform\\n regularization.\\n@sa\\nvtkGridTransform vtkGeneralTransform\\n\\n"})' __vtkname__ = 'vtkThinPlateSplineTransform' class vtkTransform(vtkLinearTransform): """ vtkTransform - describes linear transformations via a 4x4 matrix Superclass: vtkLinearTransform A vtkTransform can be used to describe the full range of linear (also known as affine) coordinate transformations in three dimensions, which are internally represented as a 4x4 homogeneous transformation matrix. When you create a new vtkTransform, it is always initialized to the identity transformation. The SetInput() method allows you to set another transform, instead of the identity transform, to be the base transformation. There is a pipeline mechanism to ensure that when the input is modified, the current transformation will be updated accordingly. This pipeline mechanism is also supported by the Concatenate() method. Most of the methods for manipulating this transformation, e.g. Translate, Rotate, and Concatenate, can operate in either PreMultiply (the default) or PostMultiply mode. In PreMultiply mode, the translation, concatenation, etc. will occur before any transformations which are represented by the current matrix. In PostMultiply mode, the additional transformation will occur after any transformations represented by the current matrix. This class performs all of its operations in a right handed coordinate system with right handed rotations. Some other graphics libraries use left handed coordinate systems and rotations. @sa vtkPerspectiveTransform vtkGeneralTransform vtkMatrix4x4 vtkTransformCollection vtkTransformFilter vtkTransformPolyDataFilter vtkImageReslice """ def CircuitCheck(self, transform): # real signature unknown; restored from __doc__ """ CircuitCheck(self, transform:vtkAbstractTransform) -> int C++: int CircuitCheck(vtkAbstractTransform *transform) override; Check for self-reference. Will return true if concatenating with the specified transform, setting it to be our inverse, or setting it to be our input will create a circular reference. CircuitCheck is automatically called by SetInput(), SetInverse(), and Concatenate(vtkXTransform *). Avoid using this function, it is experimental. """ return 0 def Concatenate(self, matrix): # real signature unknown; restored from __doc__ """ Concatenate(self, matrix:vtkMatrix4x4) -> None C++: void Concatenate(vtkMatrix4x4 *matrix) Concatenate(self, elements:(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float)) -> None C++: void Concatenate(const double elements[16]) Concatenate(self, transform:vtkLinearTransform) -> None C++: void Concatenate(vtkLinearTransform *transform) Concatenates the matrix with the current transformation according to PreMultiply or PostMultiply semantics. """ pass def GetConcatenatedTransform(self, i): # real signature unknown; restored from __doc__ """ GetConcatenatedTransform(self, i:int) -> vtkLinearTransform C++: vtkLinearTransform *GetConcatenatedTransform(int i) Get one of the concatenated transformations as a vtkAbstractTransform. These transformations are applied, in series, every time the transformation of a coordinate occurs. This method is provided to make it possible to decompose a transformation into its constituents, for example to save a transformation to a file. """ return vtkLinearTransform def GetInput(self): # real signature unknown; restored from __doc__ """ GetInput(self) -> vtkLinearTransform C++: vtkLinearTransform *GetInput() """ return vtkLinearTransform def GetInverse(self, inverse): # real signature unknown; restored from __doc__ """ GetInverse(self, inverse:vtkMatrix4x4) -> None C++: void GetInverse(vtkMatrix4x4 *inverse) GetInverse(self) -> vtkAbstractTransform C++: vtkAbstractTransform *GetInverse() Return a matrix which is the inverse of the current transformation matrix. """ pass def GetInverseFlag(self): # real signature unknown; restored from __doc__ """ GetInverseFlag(self) -> int C++: int GetInverseFlag() Get the inverse flag of the transformation. This controls whether it is the Input or the inverse of the Input that is used as the base transformation. The InverseFlag is flipped every time Inverse() is called. The InverseFlag is off when a transform is first created. """ return 0 def GetMTime(self): # real signature unknown; restored from __doc__ """ GetMTime(self) -> int C++: vtkMTimeType GetMTime() override; Override GetMTime to account for input and concatenation. """ return 0 def GetNumberOfConcatenatedTransforms(self): # real signature unknown; restored from __doc__ """ GetNumberOfConcatenatedTransforms(self) -> int C++: int GetNumberOfConcatenatedTransforms() Get the total number of transformations that are linked into this one via Concatenate() operations or via SetInput(). """ 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 GetOrientation(self, orient, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetOrientation(self, orient:[float, float, float]) -> None C++: void GetOrientation(double orient[3]) GetOrientation(self) -> (float, float, float) C++: double *GetOrientation() GetOrientation(orient:[float, float, float], matrix:vtkMatrix4x4) -> None C++: static void GetOrientation(double orient[3], vtkMatrix4x4 *matrix) Get the x, y, z orientation angles from the transformation matrix as an array of three floating point values. """ pass def GetOrientationWXYZ(self, wxyz, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetOrientationWXYZ(self, wxyz:[float, float, float, float]) -> None C++: void GetOrientationWXYZ(double wxyz[4]) GetOrientationWXYZ(self) -> (float, float, float, float) C++: double *GetOrientationWXYZ() Return the wxyz angle+axis representing the current orientation. The angle is in degrees and the axis is a unit vector. """ pass def GetPosition(self, pos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetPosition(self, pos:[float, float, float]) -> None C++: void GetPosition(double pos[3]) GetPosition(self) -> (float, float, float) C++: double *GetPosition() Return the position from the current transformation matrix as an array of three floating point numbers. This is simply returning the translation component of the 4x4 matrix. """ pass def GetScale(self, scale, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetScale(self, scale:[float, float, float]) -> None C++: void GetScale(double scale[3]) GetScale(self) -> (float, float, float) C++: double *GetScale() Return the scale factors of the current transformation matrix as an array of three float numbers. These scale factors are not necessarily about the x, y, and z axes unless unless the scale transformation was applied before any rotations. """ pass def GetTranspose(self, transpose): # real signature unknown; restored from __doc__ """ GetTranspose(self, transpose:vtkMatrix4x4) -> None C++: void GetTranspose(vtkMatrix4x4 *transpose) Return a matrix which is the transpose of the current transformation matrix. This is equivalent to the inverse if and only if the transformation is a pure rotation with no translation or scale. """ pass def Identity(self): # real signature unknown; restored from __doc__ """ Identity(self) -> None C++: void Identity() Set the transformation to the identity transformation. If the transform has an Input, then the transformation will be reset so that it is the same as the Input. """ pass def Inverse(self): # real signature unknown; restored from __doc__ """ Inverse(self) -> None C++: void Inverse() override; Invert the transformation. This will also set a flag so that the transformation will use the inverse of its Input, if an Input has been set. """ 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 MakeTransform(self): # real signature unknown; restored from __doc__ """ MakeTransform(self) -> vtkAbstractTransform C++: vtkAbstractTransform *MakeTransform() override; Make a new transform of the same type. """ return vtkAbstractTransform def MultiplyPoint(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ MultiplyPoint(self, in_:(float, float, float, float), out:[float, float, float, float]) -> None C++: void MultiplyPoint(const double in[4], double out[4]) """ pass def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkTransform C++: vtkTransform *NewInstance() """ return vtkTransform def Pop(self): # real signature unknown; restored from __doc__ """ Pop(self) -> None C++: void Pop() Deletes the transformation on the top of the stack and sets the top to the next transformation on the stack. """ pass def PostMultiply(self): # real signature unknown; restored from __doc__ """ PostMultiply(self) -> None C++: void PostMultiply() Sets the internal state of the transform to PostMultiply. All subsequent operations will occur after those already represented in the current transformation. In homogeneous matrix notation, M = A*M where M is the current transformation matrix and A is the applied matrix. The default is PreMultiply. """ pass def PreMultiply(self): # real signature unknown; restored from __doc__ """ PreMultiply(self) -> None C++: void PreMultiply() Sets the internal state of the transform to PreMultiply. All subsequent operations will occur before those already represented in the current transformation. In homogeneous matrix notation, M = M*A where M is the current transformation matrix and A is the applied matrix. The default is PreMultiply. """ pass def Push(self): # real signature unknown; restored from __doc__ """ Push(self) -> None C++: void Push() Pushes the current transformation onto the transformation stack. """ pass def RotateWXYZ(self, angle, x, y, z): # real signature unknown; restored from __doc__ """ RotateWXYZ(self, angle:float, x:float, y:float, z:float) -> None C++: void RotateWXYZ(double angle, double x, double y, double z) RotateWXYZ(self, angle:float, axis:(float, float, float)) -> None C++: void RotateWXYZ(double angle, const double axis[3]) Create a rotation matrix and concatenate it with the current transformation according to PreMultiply or PostMultiply semantics. The angle is in degrees, and (x,y,z) specifies the axis that the rotation will be performed around. """ pass def RotateX(self, angle): # real signature unknown; restored from __doc__ """ RotateX(self, angle:float) -> None C++: void RotateX(double angle) Create a rotation matrix about the X, Y, or Z axis and concatenate it with the current transformation according to PreMultiply or PostMultiply semantics. The angle is expressed in degrees. """ pass def RotateY(self, angle): # real signature unknown; restored from __doc__ """ RotateY(self, angle:float) -> None C++: void RotateY(double angle) """ pass def RotateZ(self, angle): # real signature unknown; restored from __doc__ """ RotateZ(self, angle:float) -> None C++: void RotateZ(double angle) """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkTransform C++: static vtkTransform *SafeDownCast(vtkObjectBase *o) """ return vtkTransform def Scale(self, x, y, z): # real signature unknown; restored from __doc__ """ Scale(self, x:float, y:float, z:float) -> None C++: void Scale(double x, double y, double z) Scale(self, s:(float, float, float)) -> None C++: void Scale(const double s[3]) Create a scale matrix (i.e. set the diagonal elements to x, y, z) and concatenate it with the current transformation according to PreMultiply or PostMultiply semantics. """ pass def SetInput(self, input): # real signature unknown; restored from __doc__ """ SetInput(self, input:vtkLinearTransform) -> None C++: void SetInput(vtkLinearTransform *input) Set the input for this transformation. This will be used as the base transformation if it is set. This method allows you to build a transform pipeline: if the input is modified, then this transformation will automatically update accordingly. Note that the InverseFlag, controlled via Inverse(), determines whether this transformation will use the Input or the inverse of the Input. """ pass def SetMatrix(self, matrix): # real signature unknown; restored from __doc__ """ SetMatrix(self, matrix:vtkMatrix4x4) -> None C++: void SetMatrix(vtkMatrix4x4 *matrix) SetMatrix(self, elements:(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float)) -> None C++: void SetMatrix(const double elements[16]) Set the current matrix directly. Note: First, the current matrix is set to the identity, then the input matrix is concatenated. """ pass def Translate(self, x, y, z): # real signature unknown; restored from __doc__ """ Translate(self, x:float, y:float, z:float) -> None C++: void Translate(double x, double y, double z) Translate(self, x:(float, float, float)) -> None C++: void Translate(const double x[3]) Create a translation matrix and concatenate it with the current transformation according to PreMultiply or PostMultiply semantics. """ 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__': 'vtkTransform', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'Identity': , 'Inverse': , 'Translate': , 'RotateWXYZ': , 'RotateX': , 'RotateY': , 'RotateZ': , 'Scale': , 'SetMatrix': , 'Concatenate': , 'PreMultiply': , 'PostMultiply': , 'GetNumberOfConcatenatedTransforms': , 'GetConcatenatedTransform': , 'GetOrientation': , 'GetOrientationWXYZ': , 'GetPosition': , 'GetScale': , 'GetInverse': , 'GetTranspose': , 'SetInput': , 'GetInput': , 'GetInverseFlag': , 'Push': , 'Pop': , 'CircuitCheck': , 'MakeTransform': , 'GetMTime': , 'MultiplyPoint': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkTransform - describes linear transformations via a 4x4 matrix\\n\\nSuperclass: vtkLinearTransform\\n\\nA vtkTransform can be used to describe the full range of linear (also\\nknown as affine) coordinate transformations in three dimensions,\\nwhich are internally represented as a 4x4 homogeneous transformation\\nmatrix. When you create a new vtkTransform, it is always initialized\\nto the identity transformation.\\n\\nThe SetInput() method allows you to set another transform, instead of\\nthe identity transform, to be the base transformation. There is a\\npipeline mechanism to ensure that when the input is modified, the\\ncurrent transformation will be updated accordingly. This pipeline\\nmechanism is also supported by the Concatenate() method.\\n\\nMost of the methods for manipulating this transformation, e.g.\\nTranslate, Rotate, and Concatenate, can operate in either PreMultiply\\n(the default) or PostMultiply mode. In PreMultiply mode, the\\ntranslation, concatenation, etc. will occur before any\\ntransformations which are represented by the current matrix. In\\nPostMultiply mode, the additional transformation will occur after any\\ntransformations represented by the current matrix.\\n\\nThis class performs all of its operations in a right handed\\ncoordinate system with right handed rotations. Some other graphics\\nlibraries use left handed coordinate systems and rotations.\\n@sa\\nvtkPerspectiveTransform vtkGeneralTransform vtkMatrix4x4\\nvtkTransformCollection vtkTransformFilter vtkTransformPolyDataFilter\\nvtkImageReslice\\n\\n'})" __vtkname__ = 'vtkTransform' class vtkTransform2D(__vtkmodules_vtkCommonCore.vtkObject): """ vtkTransform2D - describes linear transformations via a 3x3 matrix Superclass: vtkObject A vtkTransform2D can be used to describe the full range of linear (also known as affine) coordinate transformations in two dimensions, which are internally represented as a 3x3 homogeneous transformation matrix. When you create a new vtkTransform2D, it is always initialized to the identity transformation. All multiplicitive operations (Translate, Rotate, Scale, etc) are post-multiplied in this class (i.e. add them in the reverse of the order that they should be applied). This class performs all of its operations in a right handed coordinate system with right handed rotations. Some other graphics libraries use left handed coordinate systems and rotations. """ def GetInverse(self, inverse): # real signature unknown; restored from __doc__ """ GetInverse(self, inverse:vtkMatrix3x3) -> None C++: void GetInverse(vtkMatrix3x3 *inverse) Return a matrix which is the inverse of the current transformation matrix. """ pass def GetMatrix(self): # real signature unknown; restored from __doc__ """ GetMatrix(self) -> vtkMatrix3x3 C++: virtual vtkMatrix3x3 *GetMatrix() GetMatrix(self, matrix:vtkMatrix3x3) -> None C++: void GetMatrix(vtkMatrix3x3 *matrix) Get the underlying 3x3 matrix. """ pass def GetMTime(self): # real signature unknown; restored from __doc__ """ GetMTime(self) -> int C++: vtkMTimeType GetMTime() override; Override GetMTime to account for input and concatenation. """ 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 GetPosition(self, pos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetPosition(self, pos:[float, float]) -> None C++: void GetPosition(double pos[2]) Return the position from the current transformation matrix as an array of two floating point numbers. This is simply returning the translation component of the 3x3 matrix. """ pass def GetScale(self, scale, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetScale(self, scale:[float, float]) -> None C++: void GetScale(double scale[2]) Return the x and y scale from the current transformation matrix as an array of two floating point numbers. This is simply returning the scale component of the 3x3 matrix. """ pass def GetTranspose(self, transpose): # real signature unknown; restored from __doc__ """ GetTranspose(self, transpose:vtkMatrix3x3) -> None C++: void GetTranspose(vtkMatrix3x3 *transpose) Return a matrix which is the transpose of the current transformation matrix. This is equivalent to the inverse if and only if the transformation is a pure rotation with no translation or scale. """ pass def Identity(self): # real signature unknown; restored from __doc__ """ Identity(self) -> None C++: void Identity() Set the transformation to the identity transformation. """ pass def Inverse(self): # real signature unknown; restored from __doc__ """ Inverse(self) -> None C++: void Inverse() Invert the transformation. """ pass def InverseTransformPoints(self, inPts, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InverseTransformPoints(self, inPts:(float, ...), outPts:[float, ...], n:int) -> None C++: void InverseTransformPoints(const double *inPts, double *outPts, int n) InverseTransformPoints(self, inPts:vtkPoints2D, outPts:vtkPoints2D) -> None C++: void InverseTransformPoints(vtkPoints2D *inPts, vtkPoints2D *outPts) Apply the transformation to a series of points, and append the results to outPts. Where n is the number of points, and the float pointers are of length 2*n. """ 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 MultiplyPoint(self, in_, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ MultiplyPoint(self, in_:(float, float, float), out:[float, float, float]) -> None C++: void MultiplyPoint(const double in[3], double out[3]) """ pass def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkTransform2D C++: vtkTransform2D *NewInstance() """ return vtkTransform2D def Rotate(self, angle): # real signature unknown; restored from __doc__ """ Rotate(self, angle:float) -> None C++: void Rotate(double angle) Create a rotation matrix and concatenate it with the current transformation. The angle is in degrees. """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkTransform2D C++: static vtkTransform2D *SafeDownCast(vtkObjectBase *o) """ return vtkTransform2D def Scale(self, x, y): # real signature unknown; restored from __doc__ """ Scale(self, x:float, y:float) -> None C++: void Scale(double x, double y) Scale(self, s:(float, float)) -> None C++: void Scale(const double s[2]) Create a scale matrix (i.e. set the diagonal elements to x, y) and concatenate it with the current transformation. """ pass def SetMatrix(self, matrix): # real signature unknown; restored from __doc__ """ SetMatrix(self, matrix:vtkMatrix3x3) -> None C++: void SetMatrix(vtkMatrix3x3 *matrix) SetMatrix(self, elements:(float, float, float, float, float, float, float, float, float)) -> None C++: void SetMatrix(const double elements[9]) Set the current matrix directly. """ pass def TransformPoints(self, inPts, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ TransformPoints(self, inPts:(float, ...), outPts:[float, ...], n:int) -> None C++: void TransformPoints(const double *inPts, double *outPts, int n) TransformPoints(self, inPts:vtkPoints2D, outPts:vtkPoints2D) -> None C++: void TransformPoints(vtkPoints2D *inPts, vtkPoints2D *outPts) Apply the transformation to a series of points, and append the results to outPts. Where n is the number of points, and the float pointers are of length 2*n. """ pass def Translate(self, x, y): # real signature unknown; restored from __doc__ """ Translate(self, x:float, y:float) -> None C++: void Translate(double x, double y) Translate(self, x:(float, float)) -> None C++: void Translate(const double x[2]) Create a translation matrix and concatenate it with the current transformation. """ 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__': 'vtkTransform2D', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'Identity': , 'Inverse': , 'Translate': , 'Rotate': , 'Scale': , 'SetMatrix': , 'GetMatrix': , 'GetPosition': , 'GetScale': , 'GetInverse': , 'GetTranspose': , 'GetMTime': , 'TransformPoints': , 'InverseTransformPoints': , 'MultiplyPoint': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkTransform2D - describes linear transformations via a 3x3 matrix\\n\\nSuperclass: vtkObject\\n\\nA vtkTransform2D can be used to describe the full range of linear\\n(also known as affine) coordinate transformations in two dimensions,\\nwhich are internally represented as a 3x3 homogeneous transformation\\nmatrix. When you create a new vtkTransform2D, it is always\\ninitialized to the identity transformation.\\n\\nAll multiplicitive operations (Translate, Rotate, Scale, etc) are\\npost-multiplied in this class (i.e. add them in the reverse of the\\norder that they should be applied).\\n\\nThis class performs all of its operations in a right handed\\ncoordinate system with right handed rotations. Some other graphics\\nlibraries use left handed coordinate systems and rotations.\\n\\n'})" __vtkname__ = 'vtkTransform2D' class vtkTransformCollection(__vtkmodules_vtkCommonCore.vtkCollection): """ vtkTransformCollection - maintain a list of transforms Superclass: vtkCollection vtkTransformCollection is an object that creates and manipulates lists of objects of type vtkTransform. @sa vtkCollection vtkTransform """ def AddItem(self, __a): # real signature unknown; restored from __doc__ """ AddItem(self, __a:vtkTransform) -> None C++: void AddItem(vtkTransform *) Add a Transform to the list. """ pass def GetNextItem(self): # real signature unknown; restored from __doc__ """ GetNextItem(self) -> vtkTransform C++: vtkTransform *GetNextItem() Get the next Transform in the list. Return nullptr when the end of the list is reached. """ return vtkTransform 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) -> vtkTransformCollection C++: vtkTransformCollection *NewInstance() """ return vtkTransformCollection def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkTransformCollection C++: static vtkTransformCollection *SafeDownCast(vtkObjectBase *o) """ return vtkTransformCollection 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__': 'vtkTransformCollection', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'AddItem': , 'GetNextItem': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkTransformCollection - maintain a list of transforms\\n\\nSuperclass: vtkCollection\\n\\nvtkTransformCollection is an object that creates and manipulates\\nlists of objects of type vtkTransform.\\n\\n@sa\\nvtkCollection vtkTransform\\n\\n'})" __vtkname__ = 'vtkTransformCollection' class vtkTransformConcatenation(object): """ vtkTransformConcatenation - no description provided. """ def Concatenate(self, transform): # real signature unknown; restored from __doc__ """ Concatenate(self, transform:vtkAbstractTransform) -> None C++: void Concatenate(vtkAbstractTransform *transform) Concatenate(self, elements:(float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float)) -> None C++: void Concatenate(const double elements[16]) add a transform to the list according to Pre/PostMultiply semantics """ pass def GetInverseFlag(self): # real signature unknown; restored from __doc__ """ GetInverseFlag(self) -> int C++: int GetInverseFlag() get the inverse flag """ return 0 def GetMaxMTime(self): # real signature unknown; restored from __doc__ """ GetMaxMTime(self) -> int C++: vtkMTimeType GetMaxMTime() get maximum MTime of all transforms """ return 0 def GetNumberOfPostTransforms(self): # real signature unknown; restored from __doc__ """ GetNumberOfPostTransforms(self) -> int C++: int GetNumberOfPostTransforms() the number of transforms that were post-concatenated. """ return 0 def GetNumberOfPreTransforms(self): # real signature unknown; restored from __doc__ """ GetNumberOfPreTransforms(self) -> int C++: int GetNumberOfPreTransforms() the number of transforms that were pre-concatenated (note that whenever Inverse() is called, the pre-concatenated and post-concatenated transforms are switched) """ return 0 def GetNumberOfTransforms(self): # real signature unknown; restored from __doc__ """ GetNumberOfTransforms(self) -> int C++: int GetNumberOfTransforms() the number of stored transforms """ return 0 def GetPreMultiplyFlag(self): # real signature unknown; restored from __doc__ """ GetPreMultiplyFlag(self) -> int C++: int GetPreMultiplyFlag() """ return 0 def GetTransform(self, i): # real signature unknown; restored from __doc__ """ GetTransform(self, i:int) -> vtkAbstractTransform C++: vtkAbstractTransform *GetTransform(int i) get one of the transforms """ return vtkAbstractTransform def Identity(self): # real signature unknown; restored from __doc__ """ Identity(self) -> None C++: void Identity() identity simply clears the transform list """ pass def Inverse(self): # real signature unknown; restored from __doc__ """ Inverse(self) -> None C++: void Inverse() invert the concatenation """ pass def Rotate(self, angle, x, y, z): # real signature unknown; restored from __doc__ """ Rotate(self, angle:float, x:float, y:float, z:float) -> None C++: void Rotate(double angle, double x, double y, double z) """ pass def Scale(self, x, y, z): # real signature unknown; restored from __doc__ """ Scale(self, x:float, y:float, z:float) -> None C++: void Scale(double x, double y, double z) """ pass def SetPreMultiplyFlag(self, flag): # real signature unknown; restored from __doc__ """ SetPreMultiplyFlag(self, flag:int) -> None C++: void SetPreMultiplyFlag(int flag) set/get the PreMultiply flag """ pass def Translate(self, x, y, z): # real signature unknown; restored from __doc__ """ Translate(self, x:float, y:float, z:float) -> None C++: void Translate(double x, double y, double z) the three basic linear transformations """ 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, *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 class vtkTransformConcatenationStack(object): """ vtkTransformConcatenationStack - no description provided. """ 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, *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 class vtkTransformPair(object): """ vtkTransformPair() -> vtkTransformPair C++: vtkTransformPair() vtkTransformPair(__a:vtkTransformPair) -> vtkTransformPair C++: vtkTransformPair(const &vtkTransformPair) vtkTransformPair - no description provided. """ def SwapForwardInverse(self): # real signature unknown; restored from __doc__ """ SwapForwardInverse(self) -> None C++: void SwapForwardInverse() """ 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 0x000001C22826BC50>' __spec__ = None # (!) real value is "ModuleSpec(name='vtkmodules.vtkCommonTransforms', loader=<_frozen_importlib_external.ExtensionFileLoader object at 0x000001C22826BC50>, origin='C:\\\\Users\\\\xukai\\\\Downloads\\\\??2\\\\venv\\\\Lib\\\\site-packages\\\\vtkmodules\\\\vtkCommonTransforms.cp311-win_amd64.pyd')"