# 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 from .vtkHandleRepresentation import vtkHandleRepresentation class vtkAbstractPolygonalHandleRepresentation3D(vtkHandleRepresentation): """ vtkAbstractPolygonalHandleRepresentation3D - represent a user defined handle geometry in 3D while maintaining a fixed orientation w.r.t the camera. Superclass: vtkHandleRepresentation This class serves as the geometrical representation of a vtkHandleWidget. The handle can be represented by an arbitrary polygonal data (vtkPolyData), set via SetHandle(vtkPolyData *). The actual position of the handle will be initially assumed to be (0,0,0). You can specify an offset from this position if desired. This class differs from vtkPolygonalHandleRepresentation3D in that the handle will always remain front facing, ie it maintains a fixed orientation with respect to the camera. This is done by using vtkFollowers internally to render the actors. @sa vtkPolygonalHandleRepresentation3D vtkHandleRepresentation vtkHandleWidget """ def BuildRepresentation(self): # real signature unknown; restored from __doc__ """ BuildRepresentation(self) -> None C++: void BuildRepresentation() override; Methods to make this class properly act like a vtkWidgetRepresentation. """ pass def ComputeInteractionState(self, X, Y, modify=0): # real signature unknown; restored from __doc__ """ ComputeInteractionState(self, X:int, Y:int, modify:int=0) -> int C++: int ComputeInteractionState(int X, int Y, int modify=0) override; """ return 0 def DeepCopy(self, prop): # real signature unknown; restored from __doc__ """ DeepCopy(self, prop:vtkProp) -> None C++: void DeepCopy(vtkProp *prop) override; """ pass def GetActors(self, __a): # real signature unknown; restored from __doc__ """ GetActors(self, __a:vtkPropCollection) -> None C++: void GetActors(vtkPropCollection *) override; For some exporters and other other operations we must be able to collect all the actors or volumes. These methods are used in that process. """ pass def GetBounds(self): # real signature unknown; restored from __doc__ """ GetBounds(self) -> (float, float, float, float, float, float) C++: double *GetBounds() override; Methods to make this class behave as a vtkProp. They are repeated here (from the vtkProp superclass) as a reminder to the widget implementor. Failure to implement these methods properly may result in the representation not appearing in the scene (i.e., not implementing the Render() methods properly) or leaking graphics resources (i.e., not implementing ReleaseGraphicsResources() properly). """ pass def GetHandle(self): # real signature unknown; restored from __doc__ """ GetHandle(self) -> vtkPolyData C++: vtkPolyData *GetHandle() """ pass def GetHandleVisibility(self): # real signature unknown; restored from __doc__ """ GetHandleVisibility(self) -> int C++: virtual vtkTypeBool GetHandleVisibility() """ return 0 def GetLabelText(self): # real signature unknown; restored from __doc__ """ GetLabelText(self) -> str C++: virtual char *GetLabelText() """ return "" def GetLabelTextActor(self): # real signature unknown; restored from __doc__ """ GetLabelTextActor(self) -> vtkFollower C++: virtual vtkFollower *GetLabelTextActor() Get the label text actor """ pass def GetLabelTextScale(self): # real signature unknown; restored from __doc__ """ GetLabelTextScale(self) -> Pointer C++: virtual double *GetLabelTextScale() """ pass def GetLabelVisibility(self): # real signature unknown; restored from __doc__ """ GetLabelVisibility(self) -> int C++: virtual vtkTypeBool GetLabelVisibility() """ 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 GetProperty(self): # real signature unknown; restored from __doc__ """ GetProperty(self) -> vtkProperty C++: virtual vtkProperty *GetProperty() """ pass def GetSelectedProperty(self): # real signature unknown; restored from __doc__ """ GetSelectedProperty(self) -> vtkProperty C++: virtual vtkProperty *GetSelectedProperty() """ pass def GetSmoothMotion(self): # real signature unknown; restored from __doc__ """ GetSmoothMotion(self) -> int C++: virtual vtkTypeBool GetSmoothMotion() """ return 0 def GetTransform(self): # real signature unknown; restored from __doc__ """ GetTransform(self) -> vtkAbstractTransform C++: virtual vtkAbstractTransform *GetTransform() Get the transform used to transform the generic handle polydata before placing it in the render window """ pass def HandleVisibilityOff(self): # real signature unknown; restored from __doc__ """ HandleVisibilityOff(self) -> None C++: virtual void HandleVisibilityOff() """ pass def HandleVisibilityOn(self): # real signature unknown; restored from __doc__ """ HandleVisibilityOn(self) -> None C++: virtual void HandleVisibilityOn() """ pass def HasTranslucentPolygonalGeometry(self): # real signature unknown; restored from __doc__ """ HasTranslucentPolygonalGeometry(self) -> int C++: vtkTypeBool HasTranslucentPolygonalGeometry() override; WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE DO NOT USE THESE METHODS OUTSIDE OF THE RENDERING PROCESS Does this prop have some translucent polygonal geometry? This method is called during the rendering process to know if there is some translucent polygonal geometry. A simple prop that has some translucent polygonal geometry will return true. A composite prop (like vtkAssembly) that has at least one sub-prop that has some translucent polygonal geometry will return true. Default implementation return false. """ return 0 def Highlight(self, highlight): # real signature unknown; restored from __doc__ """ Highlight(self, highlight:int) -> None C++: void Highlight(int highlight) 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 LabelVisibilityOff(self): # real signature unknown; restored from __doc__ """ LabelVisibilityOff(self) -> None C++: virtual void LabelVisibilityOff() """ pass def LabelVisibilityOn(self): # real signature unknown; restored from __doc__ """ LabelVisibilityOn(self) -> None C++: virtual void LabelVisibilityOn() """ pass def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkAbstractPolygonalHandleRepresentation3D C++: vtkAbstractPolygonalHandleRepresentation3D *NewInstance() """ return vtkAbstractPolygonalHandleRepresentation3D def RegisterPickers(self): # real signature unknown; restored from __doc__ """ RegisterPickers(self) -> None C++: void RegisterPickers() override; Register internal Pickers in the Picking Manager. Must be reimplemented by concrete widget representations to register their pickers. """ pass def ReleaseGraphicsResources(self, __a): # real signature unknown; restored from __doc__ """ ReleaseGraphicsResources(self, __a:vtkWindow) -> None C++: void ReleaseGraphicsResources(vtkWindow *) override; WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE Release any graphics resources that are being consumed by this actor. The parameter window could be used to determine which graphic resources to release. """ pass def RenderOpaqueGeometry(self, viewport): # real signature unknown; restored from __doc__ """ RenderOpaqueGeometry(self, viewport:vtkViewport) -> int C++: int RenderOpaqueGeometry(vtkViewport *viewport) override; WARNING: INTERNAL METHOD - NOT INTENDED FOR GENERAL USE DO NOT USE THESE METHODS OUTSIDE OF THE RENDERING PROCESS All concrete subclasses must be able to render themselves. There are four key render methods in vtk and they correspond to four different points in the rendering cycle. Any given prop may implement one or more of these methods. The first method is intended for rendering all opaque geometry. The second method is intended for rendering all translucent polygonal geometry. The third one is intended for rendering all translucent volumetric geometry. Most of the volume rendering mappers draw their results during this third method. The last method is to render any 2D annotation or overlays. Each of these methods return an integer value indicating whether or not this render method was applied to this data. """ return 0 def RenderTranslucentPolygonalGeometry(self, viewport): # real signature unknown; restored from __doc__ """ RenderTranslucentPolygonalGeometry(self, viewport:vtkViewport) -> int C++: int RenderTranslucentPolygonalGeometry(vtkViewport *viewport) override; """ return 0 def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkAbstractPolygonalHandleRepresentation3D C++: static vtkAbstractPolygonalHandleRepresentation3D *SafeDownCast( vtkObjectBase *o) """ return vtkAbstractPolygonalHandleRepresentation3D def SetDisplayPosition(self, p, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ SetDisplayPosition(self, p:[float, float, float]) -> None C++: void SetDisplayPosition(double p[3]) override; Handles usually have their coordinates set in display coordinates (generally by an associated widget) and internally maintain the position in world coordinates. (Using world coordinates insures that handles are rendered in the right position when the camera view changes.) These methods are often subclassed because special constraint operations can be used to control the actual positioning. """ pass def SetHandle(self, __a): # real signature unknown; restored from __doc__ """ SetHandle(self, __a:vtkPolyData) -> None C++: void SetHandle(vtkPolyData *) Set/get the handle polydata. """ pass def SetHandleVisibility(self, _arg): # real signature unknown; restored from __doc__ """ SetHandleVisibility(self, _arg:int) -> None C++: virtual void SetHandleVisibility(vtkTypeBool _arg) Toggle the visibility of the handle on and off """ pass def SetLabelText(self, label): # real signature unknown; restored from __doc__ """ SetLabelText(self, label:str) -> None C++: virtual void SetLabelText(const char *label) """ pass def SetLabelTextScale(self, scale, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ SetLabelTextScale(self, scale:[float, float, float]) -> None C++: virtual void SetLabelTextScale(double scale[3]) SetLabelTextScale(self, x:float, y:float, z:float) -> None C++: void SetLabelTextScale(double x, double y, double z) Scale text (font size along each dimension). """ pass def SetLabelVisibility(self, _arg): # real signature unknown; restored from __doc__ """ SetLabelVisibility(self, _arg:int) -> None C++: virtual void SetLabelVisibility(vtkTypeBool _arg) A label may be associated with the seed. The string can be set via SetLabelText. The visibility of the label can be turned on / off. """ pass def SetProperty(self, __a): # real signature unknown; restored from __doc__ """ SetProperty(self, __a:vtkProperty) -> None C++: void SetProperty(vtkProperty *) Set/Get the handle properties when unselected and selected. """ pass def SetSelectedProperty(self, __a): # real signature unknown; restored from __doc__ """ SetSelectedProperty(self, __a:vtkProperty) -> None C++: void SetSelectedProperty(vtkProperty *) """ pass def SetSmoothMotion(self, _arg): # real signature unknown; restored from __doc__ """ SetSmoothMotion(self, _arg:int) -> None C++: virtual void SetSmoothMotion(vtkTypeBool _arg) Turn on/off smooth motion of the handle. See the documentation of MoveFocusRequest for details. By default, SmoothMotion is ON. However, in certain applications the user may want to turn it off. For instance when using certain specific PointPlacer's with the representation such as the vtkCellCentersPointPlacer, which causes the representation to snap to the center of cells, or using a vtkPolygonalSurfacePointPlacer which constrains the widget to the surface of a mesh. In such cases, inherent restrictions on handle placement might conflict with a request for smooth motion of the handles. """ pass def SetUniformScale(self, scale): # real signature unknown; restored from __doc__ """ SetUniformScale(self, scale:float) -> None C++: virtual void SetUniformScale(double scale) The handle may be scaled uniformly in all three dimensions using this API. The handle can also be scaled interactively using the right mouse button. """ pass def SetWorldPosition(self, p, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ SetWorldPosition(self, p:[float, float, float]) -> None C++: void SetWorldPosition(double p[3]) override; Set the position of the point in world and display coordinates. """ pass def ShallowCopy(self, prop): # real signature unknown; restored from __doc__ """ ShallowCopy(self, prop:vtkProp) -> None C++: void ShallowCopy(vtkProp *prop) override; Methods to make this class behave as a vtkProp. """ pass def SmoothMotionOff(self): # real signature unknown; restored from __doc__ """ SmoothMotionOff(self) -> None C++: virtual void SmoothMotionOff() """ pass def SmoothMotionOn(self): # real signature unknown; restored from __doc__ """ SmoothMotionOn(self) -> None C++: virtual void SmoothMotionOn() """ pass def StartWidgetInteraction(self, eventPos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ StartWidgetInteraction(self, eventPos:[float, float]) -> None C++: void StartWidgetInteraction(double eventPos[2]) override; """ pass def Translate(self, v, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ Translate(self, v:(float, ...)) -> None C++: virtual void Translate(const double *v) Translates world position by vector v projected on the constraint axis if any. """ pass def WidgetInteraction(self, eventPos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ WidgetInteraction(self, eventPos:[float, float]) -> None C++: void WidgetInteraction(double eventPos[2]) override; """ 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__': 'vtkAbstractPolygonalHandleRepresentation3D', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'SetWorldPosition': , 'SetDisplayPosition': , 'SetHandle': , 'GetHandle': , 'SetProperty': , 'SetSelectedProperty': , 'GetProperty': , 'GetSelectedProperty': , 'GetTransform': , 'BuildRepresentation': , 'StartWidgetInteraction': , 'WidgetInteraction': , 'ComputeInteractionState': , 'ShallowCopy': , 'DeepCopy': , 'GetActors': , 'ReleaseGraphicsResources': , 'RenderOpaqueGeometry': , 'RenderTranslucentPolygonalGeometry': , 'HasTranslucentPolygonalGeometry': , 'GetBounds': , 'SetLabelVisibility': , 'GetLabelVisibility': , 'LabelVisibilityOn': , 'LabelVisibilityOff': , 'SetLabelText': , 'GetLabelText': , 'SetLabelTextScale': , 'GetLabelTextScale': , 'GetLabelTextActor': , 'SetUniformScale': , 'SetHandleVisibility': , 'GetHandleVisibility': , 'HandleVisibilityOn': , 'HandleVisibilityOff': , 'Highlight': , 'SetSmoothMotion': , 'GetSmoothMotion': , 'SmoothMotionOn': , 'SmoothMotionOff': , 'RegisterPickers': , 'Translate': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkAbstractPolygonalHandleRepresentation3D - represent a user defined\\nhandle geometry in 3D while maintaining a fixed orientation w.r.t the\\ncamera.\\n\\nSuperclass: vtkHandleRepresentation\\n\\nThis class serves as the geometrical representation of a\\nvtkHandleWidget. The handle can be represented by an arbitrary\\npolygonal data (vtkPolyData), set via SetHandle(vtkPolyData *). The\\nactual position of the handle will be initially assumed to be\\n(0,0,0). You can specify an offset from this position if desired.\\nThis class differs from vtkPolygonalHandleRepresentation3D in that\\nthe handle will always remain front facing, ie it maintains a fixed\\norientation with respect to the camera. This is done by using\\nvtkFollowers internally to render the actors.\\n@sa\\nvtkPolygonalHandleRepresentation3D vtkHandleRepresentation\\nvtkHandleWidget\\n\\n'})" __vtkname__ = 'vtkAbstractPolygonalHandleRepresentation3D'