# encoding: utf-8 # module vtkmodules.vtkInteractionWidgets # from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\vtkmodules\vtkInteractionWidgets.cp311-win_amd64.pyd # by generator 1.147 # no doc # imports import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore import vtkmodules.vtkCommonExecutionModel as __vtkmodules_vtkCommonExecutionModel import vtkmodules.vtkFiltersSources as __vtkmodules_vtkFiltersSources import vtkmodules.vtkRenderingContext2D as __vtkmodules_vtkRenderingContext2D import vtkmodules.vtkRenderingCore as __vtkmodules_vtkRenderingCore class vtkPointPlacer(__vtkmodules_vtkCommonCore.vtkObject): """ vtkPointPlacer - Abstract interface to translate 2D display positions to world coordinates Superclass: vtkObject Most widgets in VTK have a need to translate of 2D display coordinates (as reported by the RenderWindowInteractor) to 3D world coordinates. This class is an abstraction of this functionality. A few subclasses are listed below: 1) vtkFocalPlanePointPlacer: This class converts 2D display positions to world positions such that they lie on the focal plane. 2) vtkPolygonalSurfacePointPlacer: Converts 2D display positions to world positions such that they lie on the surface of one or more specified polydatas. 3) vtkImageActorPointPlacer: Converts 2D display positions to world positions such that they lie on an ImageActor 4) vtkBoundedPlanePointPlacer: Converts 2D display positions to world positions such that they lie within a set of specified bounding planes. 5) vtkTerrainDataPointPlacer: Converts 2D display positions to world positions such that they lie on a height field. Point placers provide an extensible framework to specify constraints on points. The methods ComputeWorldPosition, ValidateDisplayPosition and ValidateWorldPosition may be overridden to dictate whether a world or display position is allowed. These classes are currently used by the HandleWidget and the ContourWidget to allow various constraints to be enforced on the placement of their handles. """ def ComputeWorldPosition(self, ren, displayPos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ ComputeWorldPosition(self, ren:vtkRenderer, displayPos:[float, float], worldPos:[float, float, float], worldOrient:[float, float, float, float, float, float, float, float, float]) -> int C++: virtual int ComputeWorldPosition(vtkRenderer *ren, double displayPos[2], double worldPos[3], double worldOrient[9]) ComputeWorldPosition(self, ren:vtkRenderer, displayPos:[float, float], refWorldPos:[float, float, float], worldPos:[float, float, float], worldOrient:[float, float, float, float, float, float, float, float, float]) -> int C++: virtual int ComputeWorldPosition(vtkRenderer *ren, double displayPos[2], double refWorldPos[3], double worldPos[3], double worldOrient[9]) Given a renderer and a display position in pixel coordinates, compute the world position and orientation where this point will be placed. This method is typically used by the representation to place the point initially. A return value of 1 indicates that constraints of the placer are met. """ 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 GetPixelTolerance(self): # real signature unknown; restored from __doc__ """ GetPixelTolerance(self) -> int C++: virtual int GetPixelTolerance() """ return 0 def GetPixelToleranceMaxValue(self): # real signature unknown; restored from __doc__ """ GetPixelToleranceMaxValue(self) -> int C++: virtual int GetPixelToleranceMaxValue() """ return 0 def GetPixelToleranceMinValue(self): # real signature unknown; restored from __doc__ """ GetPixelToleranceMinValue(self) -> int C++: virtual int GetPixelToleranceMinValue() """ return 0 def GetWorldTolerance(self): # real signature unknown; restored from __doc__ """ GetWorldTolerance(self) -> float C++: virtual double GetWorldTolerance() """ return 0.0 def GetWorldToleranceMaxValue(self): # real signature unknown; restored from __doc__ """ GetWorldToleranceMaxValue(self) -> float C++: virtual double GetWorldToleranceMaxValue() """ return 0.0 def GetWorldToleranceMinValue(self): # real signature unknown; restored from __doc__ """ GetWorldToleranceMinValue(self) -> float C++: virtual double GetWorldToleranceMinValue() """ return 0.0 def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkPointPlacer C++: vtkPointPlacer *NewInstance() """ return vtkPointPlacer def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkPointPlacer C++: static vtkPointPlacer *SafeDownCast(vtkObjectBase *o) """ return vtkPointPlacer def SetPixelTolerance(self, _arg): # real signature unknown; restored from __doc__ """ SetPixelTolerance(self, _arg:int) -> None C++: virtual void SetPixelTolerance(int _arg) Set/get the tolerance used when performing computations in display coordinates. """ pass def SetWorldTolerance(self, _arg): # real signature unknown; restored from __doc__ """ SetWorldTolerance(self, _arg:float) -> None C++: virtual void SetWorldTolerance(double _arg) Set/get the tolerance used when performing computations in world coordinates. """ pass def UpdateInternalState(self): # real signature unknown; restored from __doc__ """ UpdateInternalState(self) -> int C++: virtual int UpdateInternalState() Called by the representation to give the placer a chance to update itself. """ return 0 def UpdateNodeWorldPosition(self, worldPos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ UpdateNodeWorldPosition(self, worldPos:[float, float, float], nodePointId:int) -> int C++: virtual int UpdateNodeWorldPosition(double worldPos[3], vtkIdType nodePointId) Give the placer a chance to update the node information, if any. Most placers do not maintain any cached node information. vtkPolygonalSurfacePointPlacer is one that does. It stores the point id (id on the surface mesh) on which its drawn. The second argument may be used to pass that in. Update world position """ pass def UpdateWorldPosition(self, ren, worldPos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ UpdateWorldPosition(self, ren:vtkRenderer, worldPos:[float, float, float], worldOrient:[float, float, float, float, float, float, float, float, float]) -> int C++: virtual int UpdateWorldPosition(vtkRenderer *ren, double worldPos[3], double worldOrient[9]) Given a current renderer, world position and orientation, update them according to the constraints of the placer. This method is typically used when UpdateContour is called on the representation, which must be called after changes are made to the constraints in the placer. A return value of 1 indicates that the point has been updated. A return value of 0 indicates that the point could not be updated and was left alone. By default this is a no-op - leaving the point as is. """ pass def ValidateDisplayPosition(self, __a, displayPos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ ValidateDisplayPosition(self, __a:vtkRenderer, displayPos:[float, float]) -> int C++: virtual int ValidateDisplayPosition(vtkRenderer *, double displayPos[2]) Given a display position, check the validity of this position. """ pass def ValidateWorldPosition(self, worldPos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ ValidateWorldPosition(self, worldPos:[float, float, float]) -> int C++: virtual int ValidateWorldPosition(double worldPos[3]) ValidateWorldPosition(self, worldPos:[float, float, float], worldOrient:[float, float, float, float, float, float, float, float, float]) -> int C++: virtual int ValidateWorldPosition(double worldPos[3], double worldOrient[9]) Given a world position check the validity of this position according to the constraints of the placer. """ 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__': 'vtkPointPlacer', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'ComputeWorldPosition': , 'ValidateWorldPosition': , 'ValidateDisplayPosition': , 'UpdateWorldPosition': , 'UpdateNodeWorldPosition': , 'UpdateInternalState': , 'SetPixelTolerance': , 'GetPixelToleranceMinValue': , 'GetPixelToleranceMaxValue': , 'GetPixelTolerance': , 'SetWorldTolerance': , 'GetWorldToleranceMinValue': , 'GetWorldToleranceMaxValue': , 'GetWorldTolerance': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkPointPlacer - Abstract interface to translate 2D display positions\\nto world coordinates\\n\\nSuperclass: vtkObject\\n\\nMost widgets in VTK have a need to translate of 2D display\\ncoordinates (as reported by the RenderWindowInteractor) to 3D world\\ncoordinates. This class is an abstraction of this functionality. A\\nfew subclasses are listed below:\\n\\n1) vtkFocalPlanePointPlacer: This class converts 2D display positions\\nto world positions such that they lie on the focal plane.\\n\\n2) vtkPolygonalSurfacePointPlacer: Converts 2D display positions to\\nworld positions such that they lie on the surface of one or more\\nspecified polydatas.\\n\\n3) vtkImageActorPointPlacer: Converts 2D display positions to world\\npositions such that they lie on an ImageActor\\n\\n4) vtkBoundedPlanePointPlacer: Converts 2D display positions to world\\npositions such that they lie within a set of specified bounding\\nplanes.\\n\\n5) vtkTerrainDataPointPlacer: Converts 2D display positions to world\\npositions such that they lie on a height field.\\n\\nPoint placers provide an extensible framework to specify constraints\\non points. The methods ComputeWorldPosition, ValidateDisplayPosition\\nand ValidateWorldPosition may be overridden to dictate whether a\\nworld or display position is allowed. These classes are currently\\nused by the HandleWidget and the ContourWidget to allow various\\nconstraints to be enforced on the placement of their handles.\\n\\n'})" __vtkname__ = 'vtkPointPlacer'