# 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 .vtkWidgetRepresentation import vtkWidgetRepresentation class vtkImplicitPlaneRepresentation(vtkWidgetRepresentation): """ vtkImplicitPlaneRepresentation - a class defining the representation for a vtkImplicitPlaneWidget2 Superclass: vtkWidgetRepresentation This class is a concrete representation for the vtkImplicitPlaneWidget2. It represents an infinite plane defined by a normal and point in the context of a bounding box. Through interaction with the widget, the plane can be manipulated by adjusting the plane normal or moving the origin point. To use this representation, you normally define a (plane) origin and (plane) normal. The PlaceWidget() method is also used to initially position the representation. @warning This class, and vtkImplicitPlaneWidget2, are next generation VTK widgets. An earlier version of this functionality was defined in the class vtkImplicitPlaneWidget. @sa vtkImplicitPlaneWidget2 vtkImplicitPlaneWidget vtkImplicitImageRepresentation """ def BuildRepresentation(self): # real signature unknown; restored from __doc__ """ BuildRepresentation(self) -> None C++: void BuildRepresentation() override; """ pass def BumpPlane(self, dir, factor): # real signature unknown; restored from __doc__ """ BumpPlane(self, dir:int, factor:float) -> None C++: void BumpPlane(int dir, double factor) Translate the plane in the direction of the normal by the specified BumpDistance. The dir parameter controls which direction the pushing occurs, either in the same direction as the normal, or when negative, in the opposite direction. The factor controls whether what percentage of the bump is used. """ 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; Methods to interface with the vtkImplicitPlaneWidget2. """ return 0 def ConstrainToWidgetBoundsOff(self): # real signature unknown; restored from __doc__ """ ConstrainToWidgetBoundsOff(self) -> None C++: virtual void ConstrainToWidgetBoundsOff() """ pass def ConstrainToWidgetBoundsOn(self): # real signature unknown; restored from __doc__ """ ConstrainToWidgetBoundsOn(self) -> None C++: virtual void ConstrainToWidgetBoundsOn() """ pass def CropPlaneToBoundingBoxOff(self): # real signature unknown; restored from __doc__ """ CropPlaneToBoundingBoxOff(self) -> None C++: virtual void CropPlaneToBoundingBoxOff() """ pass def CropPlaneToBoundingBoxOn(self): # real signature unknown; restored from __doc__ """ CropPlaneToBoundingBoxOn(self) -> None C++: virtual void CropPlaneToBoundingBoxOn() """ pass def DrawOutlineOff(self): # real signature unknown; restored from __doc__ """ DrawOutlineOff(self) -> None C++: virtual void DrawOutlineOff() """ pass def DrawOutlineOn(self): # real signature unknown; restored from __doc__ """ DrawOutlineOn(self) -> None C++: virtual void DrawOutlineOn() """ pass def DrawPlaneOff(self): # real signature unknown; restored from __doc__ """ DrawPlaneOff(self) -> None C++: virtual void DrawPlaneOff() """ pass def DrawPlaneOn(self): # real signature unknown; restored from __doc__ """ DrawPlaneOn(self) -> None C++: virtual void DrawPlaneOn() """ pass def EndComplexInteraction(self, iren, widget, event, calldata): # real signature unknown; restored from __doc__ """ EndComplexInteraction(self, iren:vtkRenderWindowInteractor, widget:vtkAbstractWidget, event:int, calldata:Pointer) -> None C++: void EndComplexInteraction(vtkRenderWindowInteractor *iren, vtkAbstractWidget *widget, unsigned long event, void *calldata) override; """ pass def EndWidgetInteraction(self, newEventPos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ EndWidgetInteraction(self, newEventPos:[float, float]) -> None C++: void EndWidgetInteraction(double newEventPos[2]) override; """ pass def GetActors(self, pc): # real signature unknown; restored from __doc__ """ GetActors(self, pc:vtkPropCollection) -> None C++: void GetActors(vtkPropCollection *pc) 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 GetAlwaysSnapToNearestAxis(self): # real signature unknown; restored from __doc__ """ GetAlwaysSnapToNearestAxis(self) -> bool C++: virtual bool GetAlwaysSnapToNearestAxis() Forces the plane's normal to be aligned with x, y or z axis. The alignment happens when calling SetNormal. It defers with SnapToAxes from it is always applicable, and SnapToAxes only snaps when the angle difference exceeds 16 degrees in complex interactions. """ return False def GetBounds(self): # real signature unknown; restored from __doc__ """ GetBounds(self) -> (float, float, float, float, float, float) C++: double *GetBounds() override; Methods supporting the rendering process. """ pass def GetBumpDistance(self): # real signature unknown; restored from __doc__ """ GetBumpDistance(self) -> float C++: virtual double GetBumpDistance() """ return 0.0 def GetBumpDistanceMaxValue(self): # real signature unknown; restored from __doc__ """ GetBumpDistanceMaxValue(self) -> float C++: virtual double GetBumpDistanceMaxValue() """ return 0.0 def GetBumpDistanceMinValue(self): # real signature unknown; restored from __doc__ """ GetBumpDistanceMinValue(self) -> float C++: virtual double GetBumpDistanceMinValue() """ return 0.0 def GetConstrainToWidgetBounds(self): # real signature unknown; restored from __doc__ """ GetConstrainToWidgetBounds(self) -> int C++: virtual vtkTypeBool GetConstrainToWidgetBounds() """ return 0 def GetCropPlaneToBoundingBox(self): # real signature unknown; restored from __doc__ """ GetCropPlaneToBoundingBox(self) -> bool C++: virtual bool GetCropPlaneToBoundingBox() """ return False def GetDrawOutline(self): # real signature unknown; restored from __doc__ """ GetDrawOutline(self) -> int C++: virtual vtkTypeBool GetDrawOutline() """ return 0 def GetDrawPlane(self): # real signature unknown; restored from __doc__ """ GetDrawPlane(self) -> int C++: virtual vtkTypeBool GetDrawPlane() """ return 0 def GetEdgesProperty(self): # real signature unknown; restored from __doc__ """ GetEdgesProperty(self) -> vtkProperty C++: virtual vtkProperty *GetEdgesProperty() Get the property of the intersection edges. (This property also applies to the edges when tubed.) """ pass def GetInteractionStateMaxValue(self): # real signature unknown; restored from __doc__ """ GetInteractionStateMaxValue(self) -> int C++: virtual int GetInteractionStateMaxValue() """ return 0 def GetInteractionStateMinValue(self): # real signature unknown; restored from __doc__ """ GetInteractionStateMinValue(self) -> int C++: virtual int GetInteractionStateMinValue() """ return 0 def GetLockNormalToCamera(self): # real signature unknown; restored from __doc__ """ GetLockNormalToCamera(self) -> int C++: virtual vtkTypeBool GetLockNormalToCamera() """ return 0 def GetNormal(self): # real signature unknown; restored from __doc__ """ GetNormal(self) -> (float, float, float) C++: double *GetNormal() GetNormal(self, xyz:[float, float, float]) -> None C++: void GetNormal(double xyz[3]) """ pass def GetNormalProperty(self): # real signature unknown; restored from __doc__ """ GetNormalProperty(self) -> vtkProperty C++: virtual vtkProperty *GetNormalProperty() Get the properties on the normal (line and cone). """ pass def GetNormalToXAxis(self): # real signature unknown; restored from __doc__ """ GetNormalToXAxis(self) -> int C++: virtual vtkTypeBool GetNormalToXAxis() """ return 0 def GetNormalToYAxis(self): # real signature unknown; restored from __doc__ """ GetNormalToYAxis(self) -> int C++: virtual vtkTypeBool GetNormalToYAxis() """ return 0 def GetNormalToZAxis(self): # real signature unknown; restored from __doc__ """ GetNormalToZAxis(self) -> int C++: virtual vtkTypeBool GetNormalToZAxis() """ 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 GetOrigin(self): # real signature unknown; restored from __doc__ """ GetOrigin(self) -> (float, float, float) C++: double *GetOrigin() GetOrigin(self, xyz:[float, float, float]) -> None C++: void GetOrigin(double xyz[3]) """ pass def GetOutlineProperty(self): # real signature unknown; restored from __doc__ """ GetOutlineProperty(self) -> vtkProperty C++: virtual vtkProperty *GetOutlineProperty() Get the property of the outline. """ pass def GetOutlineTranslation(self): # real signature unknown; restored from __doc__ """ GetOutlineTranslation(self) -> int C++: virtual vtkTypeBool GetOutlineTranslation() """ return 0 def GetOutsideBounds(self): # real signature unknown; restored from __doc__ """ GetOutsideBounds(self) -> int C++: virtual vtkTypeBool GetOutsideBounds() """ return 0 def GetPlane(self, plane): # real signature unknown; restored from __doc__ """ GetPlane(self, plane:vtkPlane) -> None C++: void GetPlane(vtkPlane *plane) Get the implicit function for the plane by copying the origin and normal of the cut plane into the provided vtkPlane. The user must provide the instance of the class vtkPlane. Note that vtkPlane is a subclass of vtkImplicitFunction, meaning that it can be used by a variety of filters to perform clipping, cutting, and selection of data. """ pass def GetPlaneProperty(self): # real signature unknown; restored from __doc__ """ GetPlaneProperty(self) -> vtkProperty C++: virtual vtkProperty *GetPlaneProperty() Get the plane properties. The properties of the plane when selected and unselected can be manipulated. """ pass def GetPolyData(self, pd): # real signature unknown; restored from __doc__ """ GetPolyData(self, pd:vtkPolyData) -> None C++: void GetPolyData(vtkPolyData *pd) Grab the polydata that defines the plane. The polydata contains a single polygon that is clipped by the bounding box. """ pass def GetPolyDataAlgorithm(self): # real signature unknown; restored from __doc__ """ GetPolyDataAlgorithm(self) -> vtkPolyDataAlgorithm C++: vtkPolyDataAlgorithm *GetPolyDataAlgorithm() Satisfies superclass API. This returns a pointer to the underlying PolyData (which represents the plane). """ pass def GetRepresentationState(self): # real signature unknown; restored from __doc__ """ GetRepresentationState(self) -> int C++: virtual int GetRepresentationState() """ return 0 def GetScaleEnabled(self): # real signature unknown; restored from __doc__ """ GetScaleEnabled(self) -> int C++: virtual vtkTypeBool GetScaleEnabled() """ return 0 def GetSelectedNormalProperty(self): # real signature unknown; restored from __doc__ """ GetSelectedNormalProperty(self) -> vtkProperty C++: virtual vtkProperty *GetSelectedNormalProperty() """ pass def GetSelectedOutlineProperty(self): # real signature unknown; restored from __doc__ """ GetSelectedOutlineProperty(self) -> vtkProperty C++: virtual vtkProperty *GetSelectedOutlineProperty() """ pass def GetSelectedPlaneProperty(self): # real signature unknown; restored from __doc__ """ GetSelectedPlaneProperty(self) -> vtkProperty C++: virtual vtkProperty *GetSelectedPlaneProperty() """ pass def GetSnapToAxes(self): # real signature unknown; restored from __doc__ """ GetSnapToAxes(self) -> bool C++: virtual bool GetSnapToAxes() For complex events should we snap orientations to be aligned with the x y z axes """ return False def GetTubing(self): # real signature unknown; restored from __doc__ """ GetTubing(self) -> int C++: virtual vtkTypeBool GetTubing() """ return 0 def GetUnderlyingPlane(self): # real signature unknown; restored from __doc__ """ GetUnderlyingPlane(self) -> vtkPlane C++: vtkPlane *GetUnderlyingPlane() """ pass def GetWidgetBounds(self): # real signature unknown; restored from __doc__ """ GetWidgetBounds(self) -> (float, float, float, float, float, float) C++: virtual double *GetWidgetBounds() """ 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 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 IsTranslationConstrained(self): # real signature unknown; restored from __doc__ """ IsTranslationConstrained(self) -> bool C++: bool IsTranslationConstrained() Returns true if ContrainedAxis """ return False def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def LockNormalToCameraOff(self): # real signature unknown; restored from __doc__ """ LockNormalToCameraOff(self) -> None C++: virtual void LockNormalToCameraOff() """ pass def LockNormalToCameraOn(self): # real signature unknown; restored from __doc__ """ LockNormalToCameraOn(self) -> None C++: virtual void LockNormalToCameraOn() """ pass def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkImplicitPlaneRepresentation C++: vtkImplicitPlaneRepresentation *NewInstance() """ return vtkImplicitPlaneRepresentation def NormalToXAxisOff(self): # real signature unknown; restored from __doc__ """ NormalToXAxisOff(self) -> None C++: virtual void NormalToXAxisOff() """ pass def NormalToXAxisOn(self): # real signature unknown; restored from __doc__ """ NormalToXAxisOn(self) -> None C++: virtual void NormalToXAxisOn() """ pass def NormalToYAxisOff(self): # real signature unknown; restored from __doc__ """ NormalToYAxisOff(self) -> None C++: virtual void NormalToYAxisOff() """ pass def NormalToYAxisOn(self): # real signature unknown; restored from __doc__ """ NormalToYAxisOn(self) -> None C++: virtual void NormalToYAxisOn() """ pass def NormalToZAxisOff(self): # real signature unknown; restored from __doc__ """ NormalToZAxisOff(self) -> None C++: virtual void NormalToZAxisOff() """ pass def NormalToZAxisOn(self): # real signature unknown; restored from __doc__ """ NormalToZAxisOn(self) -> None C++: virtual void NormalToZAxisOn() """ pass def OutlineTranslationOff(self): # real signature unknown; restored from __doc__ """ OutlineTranslationOff(self) -> None C++: virtual void OutlineTranslationOff() """ pass def OutlineTranslationOn(self): # real signature unknown; restored from __doc__ """ OutlineTranslationOn(self) -> None C++: virtual void OutlineTranslationOn() """ pass def OutsideBoundsOff(self): # real signature unknown; restored from __doc__ """ OutsideBoundsOff(self) -> None C++: virtual void OutsideBoundsOff() """ pass def OutsideBoundsOn(self): # real signature unknown; restored from __doc__ """ OutsideBoundsOn(self) -> None C++: virtual void OutsideBoundsOn() """ 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 PushPlane(self, distance): # real signature unknown; restored from __doc__ """ PushPlane(self, distance:float) -> None C++: void PushPlane(double distance) Push the plane the distance specified along the normal. Positive values are in the direction of the normal; negative values are in the opposite direction of the normal. The distance value is expressed in world coordinates. """ 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, __a): # real signature unknown; restored from __doc__ """ RenderOpaqueGeometry(self, __a:vtkViewport) -> int C++: int RenderOpaqueGeometry(vtkViewport *) 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, __a): # real signature unknown; restored from __doc__ """ RenderTranslucentPolygonalGeometry(self, __a:vtkViewport) -> int C++: int RenderTranslucentPolygonalGeometry(vtkViewport *) override; """ return 0 def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkImplicitPlaneRepresentation C++: static vtkImplicitPlaneRepresentation *SafeDownCast( vtkObjectBase *o) """ return vtkImplicitPlaneRepresentation def ScaleEnabledOff(self): # real signature unknown; restored from __doc__ """ ScaleEnabledOff(self) -> None C++: virtual void ScaleEnabledOff() """ pass def ScaleEnabledOn(self): # real signature unknown; restored from __doc__ """ ScaleEnabledOn(self) -> None C++: virtual void ScaleEnabledOn() """ pass def SetAlwaysSnapToNearestAxis(self, snap): # real signature unknown; restored from __doc__ """ SetAlwaysSnapToNearestAxis(self, snap:bool) -> None C++: virtual void SetAlwaysSnapToNearestAxis(bool snap) """ pass def SetBumpDistance(self, _arg): # real signature unknown; restored from __doc__ """ SetBumpDistance(self, _arg:float) -> None C++: virtual void SetBumpDistance(double _arg) Specify a translation distance used by the BumpPlane() method. Note that the distance is normalized; it is the fraction of the length of the bounding box of the wire outline. """ pass def SetConstrainToWidgetBounds(self, _arg): # real signature unknown; restored from __doc__ """ SetConstrainToWidgetBounds(self, _arg:int) -> None C++: virtual void SetConstrainToWidgetBounds(vtkTypeBool _arg) Turn on/off whether the plane should be constrained to the widget bounds. If on, the origin will not be allowed to move outside the set widget bounds. This is the default behaviour. If off, the origin can be freely moved and the widget outline will change accordingly. """ pass def SetCropPlaneToBoundingBox(self, __a): # real signature unknown; restored from __doc__ """ SetCropPlaneToBoundingBox(self, __a:bool) -> None C++: virtual void SetCropPlaneToBoundingBox(bool) Control if the plane should be drawn cropped by the bounding box or without cropping. Defaults to on. """ pass def SetDrawOutline(self, plane): # real signature unknown; restored from __doc__ """ SetDrawOutline(self, plane:int) -> None C++: void SetDrawOutline(vtkTypeBool plane) Enable/disable the drawing of the outline. """ pass def SetDrawPlane(self, plane): # real signature unknown; restored from __doc__ """ SetDrawPlane(self, plane:int) -> None C++: void SetDrawPlane(vtkTypeBool plane) Enable/disable the drawing of the plane. In some cases the plane interferes with the object that it is operating on (i.e., the plane interferes with the cut surface it produces producing z-buffer artifacts.) """ pass def SetEdgeColor(self, __a): # real signature unknown; restored from __doc__ """ SetEdgeColor(self, __a:vtkLookupTable) -> None C++: void SetEdgeColor(vtkLookupTable *) SetEdgeColor(self, __a:float, __b:float, __c:float) -> None C++: void SetEdgeColor(double, double, double) SetEdgeColor(self, c:[float, float, float]) -> None C++: void SetEdgeColor(double c[3]) Set color to the edge """ pass def SetInteractionState(self, _arg): # real signature unknown; restored from __doc__ """ SetInteractionState(self, _arg:int) -> None C++: virtual void SetInteractionState(int _arg) The interaction state may be set from a widget (e.g., vtkImplicitPlaneWidget2) or other object. This controls how the interaction with the widget proceeds. Normally this method is used as part of a handshaking process with the widget: First ComputeInteractionState() is invoked that returns a state based on geometric considerations (i.e., cursor near a widget feature), then based on events, the widget may modify this further. """ pass def SetLockNormalToCamera(self, __a): # real signature unknown; restored from __doc__ """ SetLockNormalToCamera(self, __a:int) -> None C++: virtual void SetLockNormalToCamera(vtkTypeBool) If enabled, and a vtkCamera is available through the renderer, then LockNormalToCamera will cause the normal to follow the camera's normal. """ pass def SetNormal(self, x, y, z): # real signature unknown; restored from __doc__ """ SetNormal(self, x:float, y:float, z:float) -> None C++: void SetNormal(double x, double y, double z) SetNormal(self, n:[float, float, float]) -> None C++: void SetNormal(double n[3]) Get the normal to the plane. """ pass def SetNormalToCamera(self): # real signature unknown; restored from __doc__ """ SetNormalToCamera(self) -> None C++: void SetNormalToCamera() """ pass def SetNormalToXAxis(self, __a): # real signature unknown; restored from __doc__ """ SetNormalToXAxis(self, __a:int) -> None C++: void SetNormalToXAxis(vtkTypeBool) Force the plane widget to be aligned with one of the x-y-z axes. If one axis is set on, the other two will be set off. Remember that when the state changes, a ModifiedEvent is invoked. This can be used to snap the plane to the axes if it is originally not aligned. """ pass def SetNormalToYAxis(self, __a): # real signature unknown; restored from __doc__ """ SetNormalToYAxis(self, __a:int) -> None C++: void SetNormalToYAxis(vtkTypeBool) """ pass def SetNormalToZAxis(self, __a): # real signature unknown; restored from __doc__ """ SetNormalToZAxis(self, __a:int) -> None C++: void SetNormalToZAxis(vtkTypeBool) """ pass def SetOrigin(self, x, y, z): # real signature unknown; restored from __doc__ """ SetOrigin(self, x:float, y:float, z:float) -> None C++: void SetOrigin(double x, double y, double z) SetOrigin(self, x:[float, float, float]) -> None C++: void SetOrigin(double x[3]) Get the origin of the plane. """ pass def SetOutlineTranslation(self, _arg): # real signature unknown; restored from __doc__ """ SetOutlineTranslation(self, _arg:int) -> None C++: virtual void SetOutlineTranslation(vtkTypeBool _arg) Turn on/off the ability to translate the bounding box by grabbing it with the left mouse button. """ pass def SetOutsideBounds(self, _arg): # real signature unknown; restored from __doc__ """ SetOutsideBounds(self, _arg:int) -> None C++: virtual void SetOutsideBounds(vtkTypeBool _arg) Turn on/off the ability to move the widget outside of the bounds specified in the initial PlaceWidget() invocation. """ pass def SetPlane(self, plane): # real signature unknown; restored from __doc__ """ SetPlane(self, plane:vtkPlane) -> None C++: void SetPlane(vtkPlane *plane) Alternative way to define the cutting plane. The normal and origin of the plane provided is copied into the internal instance of the class cutting vtkPlane. """ pass def SetRepresentationState(self, __a): # real signature unknown; restored from __doc__ """ SetRepresentationState(self, __a:int) -> None C++: virtual void SetRepresentationState(int) Sets the visual appearance of the representation based on the state it is in. This state is usually the same as InteractionState. """ pass def SetScaleEnabled(self, _arg): # real signature unknown; restored from __doc__ """ SetScaleEnabled(self, _arg:int) -> None C++: virtual void SetScaleEnabled(vtkTypeBool _arg) Turn on/off the ability to scale the widget with the mouse. """ pass def SetSnapToAxes(self, _arg): # real signature unknown; restored from __doc__ """ SetSnapToAxes(self, _arg:bool) -> None C++: virtual void SetSnapToAxes(bool _arg) """ pass def SetTranslationAxisOff(self): # real signature unknown; restored from __doc__ """ SetTranslationAxisOff(self) -> None C++: void SetTranslationAxisOff() """ pass def SetTubing(self, _arg): # real signature unknown; restored from __doc__ """ SetTubing(self, _arg:int) -> None C++: virtual void SetTubing(vtkTypeBool _arg) Turn on/off tubing of the wire outline of the plane. The tube thickens the line by wrapping with a vtkTubeFilter. """ pass def SetWidgetBounds(self, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6): # real signature unknown; restored from __doc__ """ SetWidgetBounds(self, _arg1:float, _arg2:float, _arg3:float, _arg4:float, _arg5:float, _arg6:float) -> None C++: virtual void SetWidgetBounds(double _arg1, double _arg2, double _arg3, double _arg4, double _arg5, double _arg6) SetWidgetBounds(self, _arg:(float, float, float, float, float, float)) -> None C++: virtual void SetWidgetBounds(const double _arg[6]) Set/Get the bounds of the widget representation. PlaceWidget can also be used to set the bounds of the widget but it may also have other effects on the internal state of the representation. Use this function when only the widget bounds are needs to be modified. """ pass def SetXTranslationAxisOn(self): # real signature unknown; restored from __doc__ """ SetXTranslationAxisOn(self) -> None C++: void SetXTranslationAxisOn() Toggles constraint translation axis on/off. """ pass def SetYTranslationAxisOn(self): # real signature unknown; restored from __doc__ """ SetYTranslationAxisOn(self) -> None C++: void SetYTranslationAxisOn() """ pass def SetZTranslationAxisOn(self): # real signature unknown; restored from __doc__ """ SetZTranslationAxisOn(self) -> None C++: void SetZTranslationAxisOn() """ 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 TubingOff(self): # real signature unknown; restored from __doc__ """ TubingOff(self) -> None C++: virtual void TubingOff() """ pass def TubingOn(self): # real signature unknown; restored from __doc__ """ TubingOn(self) -> None C++: virtual void TubingOn() """ pass def UpdatePlacement(self): # real signature unknown; restored from __doc__ """ UpdatePlacement(self) -> None C++: void UpdatePlacement(void) Satisfies the superclass API. This will change the state of the widget to match changes that have been made to the underlying PolyDataSource """ pass def WidgetInteraction(self, newEventPos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ WidgetInteraction(self, newEventPos:[float, float]) -> None C++: void WidgetInteraction(double newEventPos[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.""" InteractionStateType = None # (!) real value is "" Moving = 1 MovingOrigin = 3 MovingOutline = 2 Outside = 0 Pushing = 5 Rotating = 4 Scaling = 6 __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkImplicitPlaneRepresentation', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'SetOrigin': , 'GetOrigin': , 'SetNormal': , 'SetNormalToCamera': , 'GetNormal': , 'SetNormalToXAxis': , 'GetNormalToXAxis': , 'NormalToXAxisOn': , 'NormalToXAxisOff': , 'SetNormalToYAxis': , 'GetNormalToYAxis': , 'NormalToYAxisOn': , 'NormalToYAxisOff': , 'SetNormalToZAxis': , 'GetNormalToZAxis': , 'NormalToZAxisOn': , 'NormalToZAxisOff': , 'SetLockNormalToCamera': , 'GetLockNormalToCamera': , 'LockNormalToCameraOn': , 'LockNormalToCameraOff': , 'SetTubing': , 'GetTubing': , 'TubingOn': , 'TubingOff': , 'SetDrawPlane': , 'GetDrawPlane': , 'DrawPlaneOn': , 'DrawPlaneOff': , 'SetDrawOutline': , 'GetDrawOutline': , 'DrawOutlineOn': , 'DrawOutlineOff': , 'SetOutlineTranslation': , 'GetOutlineTranslation': , 'OutlineTranslationOn': , 'OutlineTranslationOff': , 'SetOutsideBounds': , 'GetOutsideBounds': , 'OutsideBoundsOn': , 'OutsideBoundsOff': , 'SetXTranslationAxisOn': , 'SetYTranslationAxisOn': , 'SetZTranslationAxisOn': , 'SetTranslationAxisOff': , 'IsTranslationConstrained': , 'SetWidgetBounds': , 'GetWidgetBounds': , 'SetConstrainToWidgetBounds': , 'GetConstrainToWidgetBounds': , 'ConstrainToWidgetBoundsOn': , 'ConstrainToWidgetBoundsOff': , 'SetScaleEnabled': , 'GetScaleEnabled': , 'ScaleEnabledOn': , 'ScaleEnabledOff': , 'GetPolyData': , 'GetPolyDataAlgorithm': , 'GetPlane': , 'SetPlane': , 'UpdatePlacement': , 'GetNormalProperty': , 'GetSelectedNormalProperty': , 'GetPlaneProperty': , 'GetSelectedPlaneProperty': , 'GetOutlineProperty': , 'GetSelectedOutlineProperty': , 'GetEdgesProperty': , 'SetEdgeColor': , 'SetBumpDistance': , 'GetBumpDistanceMinValue': , 'GetBumpDistanceMaxValue': , 'GetBumpDistance': , 'BumpPlane': , 'PushPlane': , 'ComputeInteractionState': , 'PlaceWidget': , 'BuildRepresentation': , 'StartWidgetInteraction': , 'WidgetInteraction': , 'EndWidgetInteraction': , 'StartComplexInteraction': , 'ComplexInteraction': , 'ComputeComplexInteractionState': , 'EndComplexInteraction': , 'GetBounds': , 'GetActors': , 'ReleaseGraphicsResources': , 'RenderOpaqueGeometry': , 'RenderTranslucentPolygonalGeometry': , 'HasTranslucentPolygonalGeometry': , 'SetInteractionState': , 'GetInteractionStateMinValue': , 'GetInteractionStateMaxValue': , 'SetRepresentationState': , 'GetRepresentationState': , 'GetUnderlyingPlane': , 'SetCropPlaneToBoundingBox': , 'GetCropPlaneToBoundingBox': , 'CropPlaneToBoundingBoxOn': , 'CropPlaneToBoundingBoxOff': , 'GetSnapToAxes': , 'SetSnapToAxes': , 'GetAlwaysSnapToNearestAxis': , 'SetAlwaysSnapToNearestAxis': , 'InteractionStateType': , 'Outside': 0, 'Moving': 1, 'MovingOutline': 2, 'MovingOrigin': 3, 'Rotating': 4, 'Pushing': 5, 'Scaling': 6, '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkImplicitPlaneRepresentation - a class defining the representation\\nfor a vtkImplicitPlaneWidget2\\n\\nSuperclass: vtkWidgetRepresentation\\n\\nThis class is a concrete representation for the\\nvtkImplicitPlaneWidget2. It represents an infinite plane defined by a\\nnormal and point in the context of a bounding box. Through\\ninteraction with the widget, the plane can be manipulated by\\nadjusting the plane normal or moving the origin point.\\n\\nTo use this representation, you normally define a (plane) origin and\\n(plane) normal. The PlaceWidget() method is also used to initially\\nposition the representation.\\n\\n@warning\\nThis class, and vtkImplicitPlaneWidget2, are next generation VTK\\nwidgets. An earlier version of this functionality was defined in the\\nclass vtkImplicitPlaneWidget.\\n\\n@sa\\nvtkImplicitPlaneWidget2 vtkImplicitPlaneWidget\\nvtkImplicitImageRepresentation\\n\\n'})" __vtkname__ = 'vtkImplicitPlaneRepresentation'