# 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 vtkTensorRepresentation(vtkWidgetRepresentation):
    """
    vtkTensorRepresentation - class defining a representation for the
    vtkTensorWidget
    
    Superclass: vtkWidgetRepresentation
    
    This class is a concrete representation for the vtkTensorWidget. In
    summary, it allows the editing of a tensor glyph (by modifying the
    underlying tensor value). This includes controlling the position,
    scaling, and rotation of the glyph. The representation is simply an
    oriented, scaled box which can be manipulated to transform the
    tensor. Optionally, an ellipsoid defined by the tensor eigenvectors
    can be shown for informational purposes.
    
    To use this representation, specify a 3x3 real, symmetric matrix
    defining the tensor. (This implicitly defines an orthogonal basis
    from the three tensor eigenvectors.) Then use PlaceWidget() to define
    a bounding box: the bounding box defines a position for the tensor
    from its center point, and the representation is scaled to fit in the
    bounding box.
    
    Note: typical usage is to place a tensor glyph inside of the
    representation (i.e., the box) which is updated as the representation
    is manipulated by the user. The built-in ellipsoid can be used for
    this; alternatively through callbacks and such, it is possible to
    place other glyph types such as superquadrics.
    
    @sa
    vtkTensorWidget vtkBoxRepresentation
    """
    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 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 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 GetEigenvalues(self, evals, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetEigenvalues(self, evals:[float, float, float]) -> None
        C++: void GetEigenvalues(double evals[3])
        
        These are methods used to retrieve derived information about the
        tensor. Specify (0<=i<3) to retrieve the ith eigenvector. The
        eigenvalues and associated eigenvectors are sorted in decreasing
        order.
        """
        pass

    def GetEigenvector(self, n, ev, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetEigenvector(self, n:int, ev:[float, float, float]) -> None
        C++: void GetEigenvector(int n, double ev[3])
        """
        pass

    def GetEllipsoidProperty(self): # real signature unknown; restored from __doc__
        """
        GetEllipsoidProperty(self) -> vtkProperty
        C++: virtual vtkProperty *GetEllipsoidProperty()
        
        Get the tensor ellipsoid properties. If visibility is enabled,
        the ellipsoid will be rendered with this property.
        """
        pass

    def GetFaceProperty(self): # real signature unknown; restored from __doc__
        """
        GetFaceProperty(self) -> vtkProperty
        C++: virtual vtkProperty *GetFaceProperty()
        
        Get the face properties (the faces of the box). The properties of
        the face when selected and normal can be set.
        """
        pass

    def GetHandleProperty(self): # real signature unknown; restored from __doc__
        """
        GetHandleProperty(self) -> vtkProperty
        C++: virtual vtkProperty *GetHandleProperty()
        
        Get the handle properties (the little balls are the handles). The
        properties of the handles, when selected or normal, can be
        specified.
        """
        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 GetOutlineCursorWires(self): # real signature unknown; restored from __doc__
        """
        GetOutlineCursorWires(self) -> bool
        C++: virtual bool GetOutlineCursorWires()
        """
        return False

    def GetOutlineFaceWires(self): # real signature unknown; restored from __doc__
        """
        GetOutlineFaceWires(self) -> bool
        C++: virtual bool GetOutlineFaceWires()
        """
        return False

    def GetOutlineProperty(self): # real signature unknown; restored from __doc__
        """
        GetOutlineProperty(self) -> vtkProperty
        C++: virtual vtkProperty *GetOutlineProperty()
        
        Get the outline properties (the outline of the box). The
        properties of the outline when selected and normal can be set.
        """
        pass

    def GetPolyData(self, pd): # real signature unknown; restored from __doc__
        """
        GetPolyData(self, pd:vtkPolyData) -> None
        C++: void GetPolyData(vtkPolyData *pd)
        
        Grab the polydata (including points) that define the
        representation. The polydata consists of 6 quadrilateral faces
        and 15 points. The first eight points define the eight corner
        vertices; the next six define the
        -x,+x, -y,+y, -z,+z face points; and the final point (the 15th
            out of 15 points) defines the center of the box. These point
            values are guaranteed to be up-to-date when either the
            widget's corresponding InteractionEvent or
            EndInteractionEvent events are invoked. The user provides the
            vtkPolyData and the points and cells are added to it.
        """
        pass

    def GetPosition(self, pos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetPosition(self, pos:[float, float, float]) -> None
        C++: void GetPosition(double pos[3])
        """
        pass

    def GetSelectedFaceProperty(self): # real signature unknown; restored from __doc__
        """
        GetSelectedFaceProperty(self) -> vtkProperty
        C++: virtual vtkProperty *GetSelectedFaceProperty()
        """
        pass

    def GetSelectedHandleProperty(self): # real signature unknown; restored from __doc__
        """
        GetSelectedHandleProperty(self) -> vtkProperty
        C++: virtual vtkProperty *GetSelectedHandleProperty()
        """
        pass

    def GetSelectedOutlineProperty(self): # real signature unknown; restored from __doc__
        """
        GetSelectedOutlineProperty(self) -> vtkProperty
        C++: virtual vtkProperty *GetSelectedOutlineProperty()
        """
        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 GetSymmetricTensor(self, symTensor, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetSymmetricTensor(self, symTensor:[float, float, float, float,
            float, float]) -> None
        C++: void GetSymmetricTensor(double symTensor[6])
        """
        pass

    def GetTensor(self, tensor, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetTensor(self, tensor:[float, float, float, float, float, float,
            float, float, float]) -> None
        C++: void GetTensor(double tensor[9])
        """
        pass

    def GetTensorEllipsoid(self): # real signature unknown; restored from __doc__
        """
        GetTensorEllipsoid(self) -> bool
        C++: virtual bool GetTensorEllipsoid()
        """
        return False

    def GetTranslationAxis(self): # real signature unknown; restored from __doc__
        """
        GetTranslationAxis(self) -> int
        C++: virtual int GetTranslationAxis()
        
        Gets/Sets the constraint axis for translations. Returns
        Axis::NONE if none.
        """
        return 0

    def GetTranslationAxisMaxValue(self): # real signature unknown; restored from __doc__
        """
        GetTranslationAxisMaxValue(self) -> int
        C++: virtual int GetTranslationAxisMaxValue()
        """
        return 0

    def GetTranslationAxisMinValue(self): # real signature unknown; restored from __doc__
        """
        GetTranslationAxisMinValue(self) -> int
        C++: virtual int GetTranslationAxisMinValue()
        """
        return 0

    def HandlesOff(self): # real signature unknown; restored from __doc__
        """
        HandlesOff(self) -> None
        C++: virtual void HandlesOff()
        """
        pass

    def HandlesOn(self): # real signature unknown; restored from __doc__
        """
        HandlesOn(self) -> None
        C++: virtual void HandlesOn()
        
        Switches handles (the spheres) on or off by manipulating the
        underlying actor visibility.
        """
        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 NewInstance(self): # real signature unknown; restored from __doc__
        """
        NewInstance(self) -> vtkTensorRepresentation
        C++: vtkTensorRepresentation *NewInstance()
        """
        return vtkTensorRepresentation

    def OutlineCursorWiresOff(self): # real signature unknown; restored from __doc__
        """
        OutlineCursorWiresOff(self) -> None
        C++: void OutlineCursorWiresOff()
        """
        pass

    def OutlineCursorWiresOn(self): # real signature unknown; restored from __doc__
        """
        OutlineCursorWiresOn(self) -> None
        C++: void OutlineCursorWiresOn()
        """
        pass

    def OutlineFaceWiresOff(self): # real signature unknown; restored from __doc__
        """
        OutlineFaceWiresOff(self) -> None
        C++: void OutlineFaceWiresOff()
        """
        pass

    def OutlineFaceWiresOn(self): # real signature unknown; restored from __doc__
        """
        OutlineFaceWiresOn(self) -> None
        C++: void OutlineFaceWiresOn()
        """
        pass

    def PlaceTensor(self, tensor, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        PlaceTensor(self, tensor:[float, float, float, float, float,
            float, float, float, float], position:[float, float, float])
            -> None
        C++: void PlaceTensor(double tensor[9], double position[3])
        
        This is a specialized place widget method for a tensor. Specify
        the tensor (an array of 9 components) and the position to place
        the tensor. Note that the PlaceFactor (defined in superclass) can
        be used to scale the representation when placed.
        """
        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;
        
        These are methods that satisfy vtkWidgetRepresentation's API.
        """
        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;
        
        Methods supporting, and required by, the rendering process.
        """
        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) -> vtkTensorRepresentation
        C++: static vtkTensorRepresentation *SafeDownCast(
            vtkObjectBase *o)
        """
        return vtkTensorRepresentation

    def SetInteractionState(self, state): # real signature unknown; restored from __doc__
        """
        SetInteractionState(self, state:int) -> None
        C++: void SetInteractionState(int state)
        
        The interaction state may be set from a widget (e.g.,
        vtkTensorWidget) 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 SetOutlineCursorWires(self, __a): # real signature unknown; restored from __doc__
        """
        SetOutlineCursorWires(self, __a:bool) -> None
        C++: void SetOutlineCursorWires(bool)
        
        Control the representation of the outline. This flag enables the
        cursor lines running between the handles. By default cursor wires
        are on.
        """
        pass

    def SetOutlineFaceWires(self, __a): # real signature unknown; restored from __doc__
        """
        SetOutlineFaceWires(self, __a:bool) -> None
        C++: void SetOutlineFaceWires(bool)
        
        Control the representation of the outline. This flag enables face
        wires. By default face wires are off.
        """
        pass

    def SetPosition(self, pos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        SetPosition(self, pos:[float, float, float]) -> None
        C++: void SetPosition(double pos[3])
        
        Set/Get a position for the location of the tensor. Of course a
        tensor inherently has no position, but this is for the purpose of
        placing this widget representation.
        """
        pass

    def SetSnapToAxes(self, _arg): # real signature unknown; restored from __doc__
        """
        SetSnapToAxes(self, _arg:bool) -> None
        C++: virtual void SetSnapToAxes(bool _arg)
        """
        pass

    def SetSymmetricTensor(self, symTensor, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        SetSymmetricTensor(self, symTensor:[float, float, float, float,
            float, float]) -> None
        C++: void SetSymmetricTensor(double symTensor[6])
        """
        pass

    def SetTensor(self, tensor, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        SetTensor(self, tensor:[float, float, float, float, float, float,
            float, float, float]) -> None
        C++: void SetTensor(double tensor[9])
        
        These are the basic methods used to define the tensor (these
        methods coordinate with the overloaded PlaceWidget() method). The
        methods enable specification of a 3x3 symmetric tensor. This
        information is used to construct an oriented, appropriately
        ellipsoid that is (initially) centered and fits inside the
        bounding box defined by PlaceWidget(). As this widget is modified
        during user interaction, the tensor data member is continuously
        updated and can be queried. Note that a symmetric tensor can be
        defined with only six components. If a full 3x3 tensor is
        specified, only the symmetrical part of the tensor is used since
        the extracted eigenvalues/eigenvecters are required to be real
        valued. When a tensor is specified, the derived information
        (e.g., eigenvalues/vectors and position) are immediately updated.
        """
        pass

    def SetTensorEllipsoid(self, __a): # real signature unknown; restored from __doc__
        """
        SetTensorEllipsoid(self, __a:bool) -> None
        C++: void SetTensorEllipsoid(bool)
        
        Indicate whether to show the tensor ellipsoid. By default it is
        on.
        """
        pass

    def SetTranslationAxis(self, _arg): # real signature unknown; restored from __doc__
        """
        SetTranslationAxis(self, _arg:int) -> None
        C++: virtual void SetTranslationAxis(int _arg)
        """
        pass

    def SetTranslationAxisOff(self): # real signature unknown; restored from __doc__
        """
        SetTranslationAxisOff(self) -> None
        C++: void SetTranslationAxisOff()
        """
        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, e, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        StartWidgetInteraction(self, e:[float, float]) -> None
        C++: void StartWidgetInteraction(double e[2]) override;
        """
        pass

    def StepBackward(self): # real signature unknown; restored from __doc__
        """
        StepBackward(self) -> None
        C++: void StepBackward()
        """
        pass

    def StepForward(self): # real signature unknown; restored from __doc__
        """
        StepForward(self) -> None
        C++: void StepForward()
        
        For complex events should we snap orientations to be aligned with
        the x y z axes
        """
        pass

    def TensorEllipsoidOff(self): # real signature unknown; restored from __doc__
        """
        TensorEllipsoidOff(self) -> None
        C++: void TensorEllipsoidOff()
        """
        pass

    def TensorEllipsoidOn(self): # real signature unknown; restored from __doc__
        """
        TensorEllipsoidOn(self) -> None
        C++: void TensorEllipsoidOn()
        """
        pass

    def WidgetInteraction(self, e, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        WidgetInteraction(self, e:[float, float]) -> None
        C++: void WidgetInteraction(double e[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."""


    MoveF0 = 1
    MoveF1 = 2
    MoveF2 = 3
    MoveF3 = 4
    MoveF4 = 5
    MoveF5 = 6
    Outside = 0
    Rotating = 8
    Scaling = 9
    Translating = 7
    __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkTensorRepresentation', 'IsTypeOf': <method 'IsTypeOf' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'IsA': <method 'IsA' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'SafeDownCast': <method 'SafeDownCast' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'NewInstance': <method 'NewInstance' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'GetNumberOfGenerationsFromBaseType': <method 'GetNumberOfGenerationsFromBaseType' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'GetNumberOfGenerationsFromBase': <method 'GetNumberOfGenerationsFromBase' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'SetTensor': <method 'SetTensor' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'SetSymmetricTensor': <method 'SetSymmetricTensor' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'GetTensor': <method 'GetTensor' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'GetSymmetricTensor': <method 'GetSymmetricTensor' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'GetEigenvalues': <method 'GetEigenvalues' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'GetEigenvector': <method 'GetEigenvector' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'SetPosition': <method 'SetPosition' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'GetPosition': <method 'GetPosition' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'GetPolyData': <method 'GetPolyData' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'GetHandleProperty': <method 'GetHandleProperty' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'GetSelectedHandleProperty': <method 'GetSelectedHandleProperty' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'GetFaceProperty': <method 'GetFaceProperty' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'GetSelectedFaceProperty': <method 'GetSelectedFaceProperty' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'GetOutlineProperty': <method 'GetOutlineProperty' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'GetSelectedOutlineProperty': <method 'GetSelectedOutlineProperty' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'GetEllipsoidProperty': <method 'GetEllipsoidProperty' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'SetOutlineFaceWires': <method 'SetOutlineFaceWires' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'GetOutlineFaceWires': <method 'GetOutlineFaceWires' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'OutlineFaceWiresOn': <method 'OutlineFaceWiresOn' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'OutlineFaceWiresOff': <method 'OutlineFaceWiresOff' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'SetOutlineCursorWires': <method 'SetOutlineCursorWires' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'GetOutlineCursorWires': <method 'GetOutlineCursorWires' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'OutlineCursorWiresOn': <method 'OutlineCursorWiresOn' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'OutlineCursorWiresOff': <method 'OutlineCursorWiresOff' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'HandlesOn': <method 'HandlesOn' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'HandlesOff': <method 'HandlesOff' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'SetTensorEllipsoid': <method 'SetTensorEllipsoid' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'GetTensorEllipsoid': <method 'GetTensorEllipsoid' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'TensorEllipsoidOn': <method 'TensorEllipsoidOn' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'TensorEllipsoidOff': <method 'TensorEllipsoidOff' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'PlaceTensor': <method 'PlaceTensor' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'PlaceWidget': <method 'PlaceWidget' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'BuildRepresentation': <method 'BuildRepresentation' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'ComputeInteractionState': <method 'ComputeInteractionState' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'StartWidgetInteraction': <method 'StartWidgetInteraction' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'WidgetInteraction': <method 'WidgetInteraction' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'GetBounds': <method 'GetBounds' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'StartComplexInteraction': <method 'StartComplexInteraction' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'ComplexInteraction': <method 'ComplexInteraction' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'ComputeComplexInteractionState': <method 'ComputeComplexInteractionState' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'EndComplexInteraction': <method 'EndComplexInteraction' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'ReleaseGraphicsResources': <method 'ReleaseGraphicsResources' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'RenderOpaqueGeometry': <method 'RenderOpaqueGeometry' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'RenderTranslucentPolygonalGeometry': <method 'RenderTranslucentPolygonalGeometry' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'HasTranslucentPolygonalGeometry': <method 'HasTranslucentPolygonalGeometry' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'SetInteractionState': <method 'SetInteractionState' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'GetSnapToAxes': <method 'GetSnapToAxes' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'SetSnapToAxes': <method 'SetSnapToAxes' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'StepForward': <method 'StepForward' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'StepBackward': <method 'StepBackward' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'RegisterPickers': <method 'RegisterPickers' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'GetTranslationAxis': <method 'GetTranslationAxis' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'SetTranslationAxis': <method 'SetTranslationAxis' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'GetTranslationAxisMinValue': <method 'GetTranslationAxisMinValue' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'GetTranslationAxisMaxValue': <method 'GetTranslationAxisMaxValue' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'SetXTranslationAxisOn': <method 'SetXTranslationAxisOn' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'SetYTranslationAxisOn': <method 'SetYTranslationAxisOn' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'SetZTranslationAxisOn': <method 'SetZTranslationAxisOn' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'SetTranslationAxisOff': <method 'SetTranslationAxisOff' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'IsTranslationConstrained': <method 'IsTranslationConstrained' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, 'Outside': 0, 'MoveF0': 1, 'MoveF1': 2, 'MoveF2': 3, 'MoveF3': 4, 'MoveF4': 5, 'MoveF5': 6, 'Translating': 7, 'Rotating': 8, 'Scaling': 9, '__new__': <built-in method __new__ of type object at 0x00007FF81D6668A0>, '__repr__': <slot wrapper '__repr__' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, '__str__': <slot wrapper '__str__' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, '__getattribute__': <slot wrapper '__getattribute__' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, '__setattr__': <slot wrapper '__setattr__' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, '__delattr__': <slot wrapper '__delattr__' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, '__dict__': <attribute '__dict__' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, '__this__': <attribute '__this__' of 'vtkmodules.vtkInteractionWidgets.vtkTensorRepresentation' objects>, '__doc__': 'vtkTensorRepresentation - class defining a representation for the\\nvtkTensorWidget\\n\\nSuperclass: vtkWidgetRepresentation\\n\\nThis class is a concrete representation for the vtkTensorWidget. In\\nsummary, it allows the editing of a tensor glyph (by modifying the\\nunderlying tensor value). This includes controlling the position,\\nscaling, and rotation of the glyph. The representation is simply an\\noriented, scaled box which can be manipulated to transform the\\ntensor. Optionally, an ellipsoid defined by the tensor eigenvectors\\ncan be shown for informational purposes.\\n\\nTo use this representation, specify a 3x3 real, symmetric matrix\\ndefining the tensor. (This implicitly defines an orthogonal basis\\nfrom the three tensor eigenvectors.) Then use PlaceWidget() to define\\na bounding box: the bounding box defines a position for the tensor\\nfrom its center point, and the representation is scaled to fit in the\\nbounding box.\\n\\nNote: typical usage is to place a tensor glyph inside of the\\nrepresentation (i.e., the box) which is updated as the representation\\nis manipulated by the user. The built-in ellipsoid can be used for\\nthis; alternatively through callbacks and such, it is possible to\\nplace other glyph types such as superquadrics.\\n\\n@sa\\nvtkTensorWidget vtkBoxRepresentation\\n\\n'})"
    __vtkname__ = 'vtkTensorRepresentation'