# 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 vtkPointHandleRepresentation3D(vtkHandleRepresentation): """ vtkPointHandleRepresentation3D - represent the position of a point in 3D space Superclass: vtkHandleRepresentation This class is used to represent a vtkHandleWidget. It represents a position in 3D world coordinates using a x-y-z cursor. The cursor can be configured to show a bounding box and/or shadows. @sa vtkHandleRepresentation vtkHandleWidget vtkCursor3D """ def AllOff(self): # real signature unknown; restored from __doc__ """ AllOff(self) -> None C++: void AllOff() """ pass def AllOn(self): # real signature unknown; restored from __doc__ """ AllOn(self) -> None C++: void AllOn() Convenience methods to turn outline and shadows on and off. """ pass def BuildRepresentation(self): # real signature unknown; restored from __doc__ """ BuildRepresentation(self) -> None C++: void BuildRepresentation() override; """ pass def ComplexInteraction(self, iren, widget, event, calldata): # real signature unknown; restored from __doc__ """ ComplexInteraction(self, iren:vtkRenderWindowInteractor, widget:vtkAbstractWidget, event:int, calldata:Pointer) -> None C++: void ComplexInteraction(vtkRenderWindowInteractor *iren, vtkAbstractWidget *widget, unsigned long event, void *calldata) override; """ pass def ComputeComplexInteractionState(self, iren, widget, event, calldata, modify=0): # real signature unknown; restored from __doc__ """ ComputeComplexInteractionState(self, iren:vtkRenderWindowInteractor, widget:vtkAbstractWidget, event:int, calldata:Pointer, modify:int=0) -> int C++: int ComputeComplexInteractionState( vtkRenderWindowInteractor *iren, vtkAbstractWidget *widget, unsigned long event, void *calldata, int modify=0) override; """ return 0 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 properly act like a vtkWidgetRepresentation. """ pass def GetHotSpotSize(self): # real signature unknown; restored from __doc__ """ GetHotSpotSize(self) -> float C++: virtual double GetHotSpotSize() """ return 0.0 def GetHotSpotSizeMaxValue(self): # real signature unknown; restored from __doc__ """ GetHotSpotSizeMaxValue(self) -> float C++: virtual double GetHotSpotSizeMaxValue() """ return 0.0 def GetHotSpotSizeMinValue(self): # real signature unknown; restored from __doc__ """ GetHotSpotSizeMinValue(self) -> float C++: virtual double GetHotSpotSizeMinValue() """ 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 GetOutline(self): # real signature unknown; restored from __doc__ """ GetOutline(self) -> int C++: int GetOutline() """ 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 GetTranslationMode(self): # real signature unknown; restored from __doc__ """ GetTranslationMode(self) -> int C++: virtual vtkTypeBool GetTranslationMode() """ return 0 def GetXShadows(self): # real signature unknown; restored from __doc__ """ GetXShadows(self) -> int C++: int GetXShadows() """ return 0 def GetYShadows(self): # real signature unknown; restored from __doc__ """ GetYShadows(self) -> int C++: int GetYShadows() """ return 0 def GetZShadows(self): # real signature unknown; restored from __doc__ """ GetZShadows(self) -> int C++: int GetZShadows() """ return 0 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 NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkPointHandleRepresentation3D C++: vtkPointHandleRepresentation3D *NewInstance() """ return vtkPointHandleRepresentation3D def OutlineOff(self): # real signature unknown; restored from __doc__ """ OutlineOff(self) -> None C++: void OutlineOff() """ pass def OutlineOn(self): # real signature unknown; restored from __doc__ """ OutlineOn(self) -> None C++: void OutlineOn() """ pass def PlaceWidget(self, bounds, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ PlaceWidget(self, bounds:[float, float, float, float, float, float]) -> None C++: void PlaceWidget(double bounds[6]) override; The following is a suggested API for widget representations. These methods define the communication between the widget and its representation. These methods are only suggestions because widgets take on so many different forms that a universal API is not deemed practical. However, these methods should be implemented when possible to ensure that the VTK widget hierarchy remains self-consistent. PlaceWidget() - given a bounding box (xmin,xmax,ymin,ymax,zmin,zmax), place the widget inside of it. The current orientation of the widget is preserved, only scaling and translation is performed. StartWidgetInteraction() - generally corresponds to a initial event (e.g., mouse down) that starts the interaction process with the widget. WidgetInteraction() - invoked when an event causes the widget to change appearance. EndWidgetInteraction() - generally corresponds to a final event (e.g., mouse up) and completes the interaction sequence. ComputeInteractionState() - given (X,Y) display coordinates in a renderer, with a possible flag that modifies the computation, what is the state of the widget? GetInteractionState() - return the current state of the widget. Note that the value of "0" typically refers to "outside". The interaction state is strictly a function of the representation, and the widget/represent must agree on what they mean. Highlight() - turn on or off any highlights associated with the widget. Highlights are generally turned on when the widget is selected. Note that subclasses may ignore some of these methods and implement their own depending on the specifics of the widget. """ pass 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) -> vtkPointHandleRepresentation3D C++: static vtkPointHandleRepresentation3D *SafeDownCast( vtkObjectBase *o) """ return vtkPointHandleRepresentation3D 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 SetHandleSize(self, size): # real signature unknown; restored from __doc__ """ SetHandleSize(self, size:float) -> None C++: void SetHandleSize(double size) override; Overload the superclasses SetHandleSize() method to update internal variables. """ pass def SetHotSpotSize(self, _arg): # real signature unknown; restored from __doc__ """ SetHotSpotSize(self, _arg:float) -> None C++: virtual void SetHotSpotSize(double _arg) Set the "hot spot" size; i.e., the region around the focus, in which the motion vector is used to control the constrained sliding action. Note the size is specified as a fraction of the length of the diagonal of the point widget's bounding box. """ pass def SetOutline(self, o): # real signature unknown; restored from __doc__ """ SetOutline(self, o:int) -> None C++: void SetOutline(int o) Turn on/off the wireframe bounding box. """ 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 SetTranslationMode(self, mode): # real signature unknown; restored from __doc__ """ SetTranslationMode(self, mode:int) -> None C++: void SetTranslationMode(vtkTypeBool mode) If translation mode is on, as the widget is moved the bounding box, shadows, and cursor are all translated and sized simultaneously as the point moves (i.e., the left and middle mouse buttons act the same). If translation mode is off, the cursor does not scale itself (based on the specified handle size), and the bounding box and shadows do not move or size themselves as the cursor focal point moves, which is constrained by the bounds of the point representation. (Note that the bounds can be scaled up using the right mouse button, and the bounds can be manually set with the SetBounds() method.) """ pass def SetVisibility(self, visible): # real signature unknown; restored from __doc__ """ SetVisibility(self, visible:int) -> None C++: void SetVisibility(vtkTypeBool visible) override; Override to ensure that the internal actor's visibility is consistent with this representation's visibility. Inconsistency between the two would cause issues in picking logic which relies on individual view prop visibility to determine whether the prop is pickable. """ 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. Note that if the position is set outside of the bounding box, it will be clamped to the boundary of the bounding box. This method overloads the superclasses' SetWorldPosition() and SetDisplayPosition() in order to set the focal point of the cursor properly. """ pass def SetXShadows(self, o): # real signature unknown; restored from __doc__ """ SetXShadows(self, o:int) -> None C++: void SetXShadows(int o) Turn on/off the wireframe x-shadows. """ pass def SetYShadows(self, o): # real signature unknown; restored from __doc__ """ SetYShadows(self, o:int) -> None C++: void SetYShadows(int o) Turn on/off the wireframe y-shadows. """ pass def SetZShadows(self, o): # real signature unknown; restored from __doc__ """ SetZShadows(self, o:int) -> None C++: void SetZShadows(int o) Turn on/off the wireframe z-shadows. """ 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 StartComplexInteraction(self, iren, widget, event, calldata): # real signature unknown; restored from __doc__ """ StartComplexInteraction(self, iren:vtkRenderWindowInteractor, widget:vtkAbstractWidget, event:int, calldata:Pointer) -> None C++: void StartComplexInteraction(vtkRenderWindowInteractor *iren, vtkAbstractWidget *widget, unsigned long event, void *calldata) override; """ 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 TranslationModeOff(self): # real signature unknown; restored from __doc__ """ TranslationModeOff(self) -> None C++: virtual void TranslationModeOff() """ pass def TranslationModeOn(self): # real signature unknown; restored from __doc__ """ TranslationModeOn(self) -> None C++: virtual void TranslationModeOn() """ 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 XShadowsOff(self): # real signature unknown; restored from __doc__ """ XShadowsOff(self) -> None C++: void XShadowsOff() """ pass def XShadowsOn(self): # real signature unknown; restored from __doc__ """ XShadowsOn(self) -> None C++: void XShadowsOn() """ pass def YShadowsOff(self): # real signature unknown; restored from __doc__ """ YShadowsOff(self) -> None C++: void YShadowsOff() """ pass def YShadowsOn(self): # real signature unknown; restored from __doc__ """ YShadowsOn(self) -> None C++: void YShadowsOn() """ pass def ZShadowsOff(self): # real signature unknown; restored from __doc__ """ ZShadowsOff(self) -> None C++: void ZShadowsOff() """ pass def ZShadowsOn(self): # real signature unknown; restored from __doc__ """ ZShadowsOn(self) -> None C++: void ZShadowsOn() """ 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__': 'vtkPointHandleRepresentation3D', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'SetWorldPosition': , 'SetDisplayPosition': , 'SetOutline': , 'GetOutline': , 'OutlineOn': , 'OutlineOff': , 'SetXShadows': , 'GetXShadows': , 'XShadowsOn': , 'XShadowsOff': , 'SetYShadows': , 'GetYShadows': , 'YShadowsOn': , 'YShadowsOff': , 'SetZShadows': , 'GetZShadows': , 'ZShadowsOn': , 'ZShadowsOff': , 'SetTranslationMode': , 'GetTranslationMode': , 'TranslationModeOn': , 'TranslationModeOff': , 'AllOn': , 'AllOff': , 'SetProperty': , 'SetSelectedProperty': , 'GetProperty': , 'GetSelectedProperty': , 'SetHotSpotSize': , 'GetHotSpotSizeMinValue': , 'GetHotSpotSizeMaxValue': , 'GetHotSpotSize': , 'SetHandleSize': , 'GetBounds': , 'BuildRepresentation': , 'StartWidgetInteraction': , 'WidgetInteraction': , 'ComputeInteractionState': , 'PlaceWidget': , 'StartComplexInteraction': , 'ComplexInteraction': , 'ComputeComplexInteractionState': , 'ShallowCopy': , 'DeepCopy': , 'GetActors': , 'ReleaseGraphicsResources': , 'RenderOpaqueGeometry': , 'RenderTranslucentPolygonalGeometry': , 'HasTranslucentPolygonalGeometry': , 'Highlight': , 'SetSmoothMotion': , 'GetSmoothMotion': , 'SmoothMotionOn': , 'SmoothMotionOff': , 'RegisterPickers': , 'SetVisibility': , 'Translate': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkPointHandleRepresentation3D - represent the position of a point in\\n3D space\\n\\nSuperclass: vtkHandleRepresentation\\n\\nThis class is used to represent a vtkHandleWidget. It represents a\\nposition in 3D world coordinates using a x-y-z cursor. The cursor can\\nbe configured to show a bounding box and/or shadows.\\n\\n@sa\\nvtkHandleRepresentation vtkHandleWidget vtkCursor3D\\n\\n'})" __vtkname__ = 'vtkPointHandleRepresentation3D'