# 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 vtkContourRepresentation(vtkWidgetRepresentation):
    """
    vtkContourRepresentation - represent the vtkContourWidget
    
    Superclass: vtkWidgetRepresentation
    
    The vtkContourRepresentation is a superclass for various types of
    representations for vtkContourWidget.
    
    @par Managing contour points: The classes
    vtkContourRepresentationNode, vtkContourRepresentationInternals, and
    vtkContourRepresentationPoint manage the data structure used to
    represent nodes and points on a contour. A contour may contain
    several nodes and several additional points. Nodes are usually the
    result of user-clicked points on the contour. Additional points are
    created between nodes to generate a smooth curve using some
    Interpolator -- see the method SetLineInterpolator.
    
    @par Managing contour points:\par The data structure stores both the
    world and display positions for every point. (This may seem like a
    duplication.) The default behaviour of this class is to use the
    WorldPosition to do all the math. Typically a point is added at a
    given display position. Its corresponding world position is computed
    using the point placer, and stored. Any query of the display position
    of a stored point is done via the Renderer, which computes the
    display position given a world position.
    
    @par Managing contour points:\par So why maintain the display
    position? Consider drawing a contour on a volume widget. You might
    want the contour to be located at a certain world position in the
    volume or you might want to be overlaid over the window like an
    Actor2D. The default behaviour of this class is to provide the former
    behaviour.
    
    @par Managing contour points:\par To achieve the latter behaviour,
    override the methods that return the display position (to return the
    set display position instead of computing it from the world
    positions) and the method BuildLines() to interpolate lines using
    their display positions instead of world positions.
    
    @sa
    vtkContourWidget
    """
    def ActivateNode(self, displayPos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        ActivateNode(self, displayPos:[float, float]) -> int
        C++: virtual int ActivateNode(double displayPos[2])
        ActivateNode(self, displayPos:[int, int]) -> int
        C++: virtual int ActivateNode(int displayPos[2])
        ActivateNode(self, X:int, Y:int) -> int
        C++: virtual int ActivateNode(int X, int Y)
        
        Given a display position, activate a node. The closest node
        within tolerance will be activated. If a node is activated, 1
        will be returned, otherwise 0 will be returned.
        """
        pass

    def AddIntermediatePointWorldPosition(self, n, point, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        AddIntermediatePointWorldPosition(self, n:int, point:[float,
            float, float]) -> int
        C++: virtual int AddIntermediatePointWorldPosition(int n,
            double point[3])
        AddIntermediatePointWorldPosition(self, n:int, point:[float,
            float, float], ptId:int) -> int
        C++: virtual int AddIntermediatePointWorldPosition(int n,
            double point[3], vtkIdType ptId)
        
        Add an intermediate point between node n and n+1 (or n and 0 if n
        is the last node and the loop is closed). Returns 1 on success or
        0 if n is out of range.
        """
        pass

    def AddNodeAtDisplayPosition(self, displayPos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        AddNodeAtDisplayPosition(self, displayPos:[float, float]) -> int
        C++: virtual int AddNodeAtDisplayPosition(double displayPos[2])
        AddNodeAtDisplayPosition(self, displayPos:[int, int]) -> int
        C++: virtual int AddNodeAtDisplayPosition(int displayPos[2])
        AddNodeAtDisplayPosition(self, X:int, Y:int) -> int
        C++: virtual int AddNodeAtDisplayPosition(int X, int Y)
        
        Add a node at a specific display position. This will be converted
        into a world position according to the current constraints of the
        point placer. Return 0 if a point could not be added, 1
        otherwise.
        """
        pass

    def AddNodeAtWorldPosition(self, x, y, z): # real signature unknown; restored from __doc__
        """
        AddNodeAtWorldPosition(self, x:float, y:float, z:float) -> int
        C++: virtual int AddNodeAtWorldPosition(double x, double y,
            double z)
        AddNodeAtWorldPosition(self, worldPos:[float, float, float])
            -> int
        C++: virtual int AddNodeAtWorldPosition(double worldPos[3])
        AddNodeAtWorldPosition(self, worldPos:[float, float, float],
            worldOrient:[float, float, float, float, float, float, float,
            float, float]) -> int
        C++: virtual int AddNodeAtWorldPosition(double worldPos[3],
            double worldOrient[9])
        
        Add a node at a specific world position. Returns 0 if the node
        could not be added, 1 otherwise.
        """
        return 0

    def AddNodeOnContour(self, X, Y): # real signature unknown; restored from __doc__
        """
        AddNodeOnContour(self, X:int, Y:int) -> int
        C++: virtual int AddNodeOnContour(int X, int Y)
        
        Given a specific X, Y pixel location, add a new node on the
        contour at this location.
        """
        return 0

    def BuildRepresentation(self): # real signature unknown; restored from __doc__
        """
        BuildRepresentation(self) -> None
        C++: void BuildRepresentation() override = 0;
        
        These are methods that satisfy vtkWidgetRepresentation's API.
        """
        pass

    def ClearAllNodes(self): # real signature unknown; restored from __doc__
        """
        ClearAllNodes(self) -> None
        C++: virtual void ClearAllNodes()
        
        Delete all nodes.
        """
        pass

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

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

    def ComputeInteractionState(self, X, Y, modified=0): # real signature unknown; restored from __doc__
        """
        ComputeInteractionState(self, X:int, Y:int, modified:int=0) -> int
        C++: int ComputeInteractionState(int X, int Y, int modified=0)
            override = 0;
        """
        return 0

    def DeleteActiveNode(self): # real signature unknown; restored from __doc__
        """
        DeleteActiveNode(self) -> int
        C++: virtual int DeleteActiveNode()
        
        Delete the active node. Returns 1 on success or 0 if the active
        node did not indicate a valid node.
        """
        return 0

    def DeleteLastNode(self): # real signature unknown; restored from __doc__
        """
        DeleteLastNode(self) -> int
        C++: virtual int DeleteLastNode()
        
        Delete the last node. Returns 1 on success or 0 if there were not
        any nodes.
        """
        return 0

    def DeleteNthNode(self, n): # real signature unknown; restored from __doc__
        """
        DeleteNthNode(self, n:int) -> int
        C++: virtual int DeleteNthNode(int n)
        
        Delete the nth node. Return 1 on success or 0 if n is out of
        range.
        """
        return 0

    def GetActiveNodeDisplayPosition(self, pos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetActiveNodeDisplayPosition(self, pos:[float, float]) -> int
        C++: virtual int GetActiveNodeDisplayPosition(double pos[2])
        
        Get the display position of the active node. Will return 0 if
        there is no active node, or 1 otherwise.
        """
        pass

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

    def GetActiveNodeWorldOrientation(self, orient, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetActiveNodeWorldOrientation(self, orient:[float, float, float,
            float, float, float, float, float, float]) -> int
        C++: virtual int GetActiveNodeWorldOrientation(double orient[9])
        
        Get the world orientation of the active node. Will return 0 if
        there is no active node, or 1 otherwise.
        """
        pass

    def GetActiveNodeWorldPosition(self, pos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetActiveNodeWorldPosition(self, pos:[float, float, float]) -> int
        C++: virtual int GetActiveNodeWorldPosition(double pos[3])
        
        Get the world position of the active node. Will return 0 if there
        is no active node, or 1 otherwise.
        """
        pass

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

    def GetContourRepresentationAsPolyData(self): # real signature unknown; restored from __doc__
        """
        GetContourRepresentationAsPolyData(self) -> vtkPolyData
        C++: virtual vtkPolyData *GetContourRepresentationAsPolyData()
        
        Get the points in this contour as a vtkPolyData.
        """
        pass

    def GetCurrentOperation(self): # real signature unknown; restored from __doc__
        """
        GetCurrentOperation(self) -> int
        C++: virtual int GetCurrentOperation()
        
        Set / get the current operation. The widget is either inactive,
        or it is being translated.
        """
        return 0

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

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

    def GetIntermediatePointWorldPosition(self, n, idx, point, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetIntermediatePointWorldPosition(self, n:int, idx:int,
            point:[float, float, float]) -> int
        C++: virtual int GetIntermediatePointWorldPosition(int n, int idx,
             double point[3])
        
        Get the world position of the intermediate point at index idx
        between nodes n and (n+1) (or n and 0 if n is the last node and
        the loop is closed). Returns 1 on success or 0 if n or idx are
        out of range.
        """
        pass

    def GetLineInterpolator(self): # real signature unknown; restored from __doc__
        """
        GetLineInterpolator(self) -> vtkContourLineInterpolator
        C++: virtual vtkContourLineInterpolator *GetLineInterpolator()
        """
        return vtkContourLineInterpolator

    def GetNodePolyData(self, poly): # real signature unknown; restored from __doc__
        """
        GetNodePolyData(self, poly:vtkPolyData) -> None
        C++: void GetNodePolyData(vtkPolyData *poly)
        
        Get the nodes and not the intermediate points in this contour as
        a vtkPolyData.
        """
        pass

    def GetNthNodeDisplayPosition(self, n, pos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetNthNodeDisplayPosition(self, n:int, pos:[float, float]) -> int
        C++: virtual int GetNthNodeDisplayPosition(int n, double pos[2])
        
        Get the nth node's display position. Will return 1 on success, or
        0 if there are not at least (n+1) nodes (0 based counting).
        """
        pass

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

    def GetNthNodeSlope(self, idx, slope, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetNthNodeSlope(self, idx:int, slope:[float, float, float]) -> int
        C++: virtual int GetNthNodeSlope(int idx, double slope[3])
        
        Get the nth node's slope. Will return 1 on success, or 0 if there
        are not at least (n+1) nodes (0 based counting).
        """
        pass

    def GetNthNodeWorldOrientation(self, n, orient, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetNthNodeWorldOrientation(self, n:int, orient:[float, float,
            float, float, float, float, float, float, float]) -> int
        C++: virtual int GetNthNodeWorldOrientation(int n,
            double orient[9])
        
        Get the nth node's world orientation. Will return 1 on success,
        or 0 if there are not at least (n+1) nodes (0 based counting).
        """
        pass

    def GetNthNodeWorldPosition(self, n, pos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetNthNodeWorldPosition(self, n:int, pos:[float, float, float])
            -> int
        C++: virtual int GetNthNodeWorldPosition(int n, double pos[3])
        
        Get the nth node's world position. Will return 1 on success, or 0
        if there are not at least (n+1) nodes (0 based counting).
        """
        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 GetNumberOfIntermediatePoints(self, n): # real signature unknown; restored from __doc__
        """
        GetNumberOfIntermediatePoints(self, n:int) -> int
        C++: virtual int GetNumberOfIntermediatePoints(int n)
        
        For a given node n, get the number of intermediate points between
        this node and the node at (n+1). If n is the last node and the
        loop is closed, this is the number of intermediate points between
        node n and node 0. 0 is returned if n is out of range.
        """
        return 0

    def GetNumberOfNodes(self): # real signature unknown; restored from __doc__
        """
        GetNumberOfNodes(self) -> int
        C++: virtual int GetNumberOfNodes()
        
        Get the number of nodes.
        """
        return 0

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

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

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

    def GetPointPlacer(self): # real signature unknown; restored from __doc__
        """
        GetPointPlacer(self) -> vtkPointPlacer
        C++: virtual vtkPointPlacer *GetPointPlacer()
        
        Set / get the Point Placer. The point placer is responsible for
        converting display coordinates into world coordinates according
        to some constraints, and for validating world positions.
        """
        return vtkPointPlacer

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

    def GetWorldTolerance(self): # real signature unknown; restored from __doc__
        """
        GetWorldTolerance(self) -> float
        C++: virtual double GetWorldTolerance()
        """
        return 0.0

    def GetWorldToleranceMaxValue(self): # real signature unknown; restored from __doc__
        """
        GetWorldToleranceMaxValue(self) -> float
        C++: virtual double GetWorldToleranceMaxValue()
        """
        return 0.0

    def GetWorldToleranceMinValue(self): # real signature unknown; restored from __doc__
        """
        GetWorldToleranceMinValue(self) -> float
        C++: virtual double GetWorldToleranceMinValue()
        """
        return 0.0

    def HasTranslucentPolygonalGeometry(self): # real signature unknown; restored from __doc__
        """
        HasTranslucentPolygonalGeometry(self) -> int
        C++: vtkTypeBool HasTranslucentPolygonalGeometry() override = 0;
        
        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 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) -> vtkContourRepresentation
        C++: vtkContourRepresentation *NewInstance()
        """
        return vtkContourRepresentation

    def ReleaseGraphicsResources(self, w): # real signature unknown; restored from __doc__
        """
        ReleaseGraphicsResources(self, w:vtkWindow) -> None
        C++: void ReleaseGraphicsResources(vtkWindow *w) override = 0;
        
        Methods required by vtkProp superclass.
        """
        pass

    def RenderOpaqueGeometry(self, viewport): # real signature unknown; restored from __doc__
        """
        RenderOpaqueGeometry(self, viewport:vtkViewport) -> int
        C++: int RenderOpaqueGeometry(vtkViewport *viewport) override = 0;
        
        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 RenderOverlay(self, viewport): # real signature unknown; restored from __doc__
        """
        RenderOverlay(self, viewport:vtkViewport) -> int
        C++: int RenderOverlay(vtkViewport *viewport) override = 0;
        """
        return 0

    def RenderTranslucentPolygonalGeometry(self, viewport): # real signature unknown; restored from __doc__
        """
        RenderTranslucentPolygonalGeometry(self, viewport:vtkViewport)
            -> int
        C++: int RenderTranslucentPolygonalGeometry(vtkViewport *viewport)
             override = 0;
        """
        return 0

    def SafeDownCast(self, o): # real signature unknown; restored from __doc__
        """
        SafeDownCast(o:vtkObjectBase) -> vtkContourRepresentation
        C++: static vtkContourRepresentation *SafeDownCast(
            vtkObjectBase *o)
        """
        return vtkContourRepresentation

    def SetActiveNodeToDisplayPosition(self, pos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        SetActiveNodeToDisplayPosition(self, pos:[float, float]) -> int
        C++: virtual int SetActiveNodeToDisplayPosition(double pos[2])
        SetActiveNodeToDisplayPosition(self, pos:[int, int]) -> int
        C++: virtual int SetActiveNodeToDisplayPosition(int pos[2])
        SetActiveNodeToDisplayPosition(self, X:int, Y:int) -> int
        C++: virtual int SetActiveNodeToDisplayPosition(int X, int Y)
        
        Move the active node based on a specified display position. The
        display position will be converted into a world position. If the
        new position is not valid or there is no active node, a 0 will be
        returned. Otherwise, on success a 1 will be returned.
        """
        pass

    def SetActiveNodeToWorldPosition(self, pos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        SetActiveNodeToWorldPosition(self, pos:[float, float, float])
            -> int
        C++: virtual int SetActiveNodeToWorldPosition(double pos[3])
        SetActiveNodeToWorldPosition(self, pos:[float, float, float],
            orient:[float, float, float, float, float, float, float,
            float, float]) -> int
        C++: virtual int SetActiveNodeToWorldPosition(double pos[3],
            double orient[9])
        
        Move the active node to a specified world position. Will return 0
        if there is no active node or the node could not be moved to that
        position. 1 will be returned on success.
        """
        pass

    def SetClosedLoop(self, val): # real signature unknown; restored from __doc__
        """
        SetClosedLoop(self, val:int) -> None
        C++: void SetClosedLoop(vtkTypeBool val)
        
        Set / Get the ClosedLoop value. This ivar indicates whether the
        contour forms a closed loop.
        """
        pass

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

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

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

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

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

    def SetLineInterpolator(self, __a): # real signature unknown; restored from __doc__
        """
        SetLineInterpolator(self, __a:vtkContourLineInterpolator) -> None
        C++: void SetLineInterpolator(vtkContourLineInterpolator *)
        
        Set / Get the Line Interpolator. The line interpolator is
        responsible for generating the line segments connecting nodes.
        """
        pass

    def SetNthNodeDisplayPosition(self, n, X, Y): # real signature unknown; restored from __doc__
        """
        SetNthNodeDisplayPosition(self, n:int, X:int, Y:int) -> int
        C++: virtual int SetNthNodeDisplayPosition(int n, int X, int Y)
        SetNthNodeDisplayPosition(self, n:int, pos:[int, int]) -> int
        C++: virtual int SetNthNodeDisplayPosition(int n, int pos[2])
        SetNthNodeDisplayPosition(self, n:int, pos:[float, float]) -> int
        C++: virtual int SetNthNodeDisplayPosition(int n, double pos[2])
        
        Set the nth node's display position. Display position will be
        converted into world position according to the constraints of the
        point placer. Will return 1 on success, or 0 if there are not at
        least (n+1) nodes (0 based counting) or the world position is not
        valid.
        """
        return 0

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

    def SetNthNodeWorldPosition(self, n, pos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        SetNthNodeWorldPosition(self, n:int, pos:[float, float, float])
            -> int
        C++: virtual int SetNthNodeWorldPosition(int n, double pos[3])
        SetNthNodeWorldPosition(self, n:int, pos:[float, float, float],
            orient:[float, float, float, float, float, float, float,
            float, float]) -> int
        C++: virtual int SetNthNodeWorldPosition(int n, double pos[3],
            double orient[9])
        
        Set the nth node's world position. Will return 1 on success, or 0
        if there are not at least (n+1) nodes (0 based counting) or the
        world position is not valid according to the point placer.
        """
        pass

    def SetPixelTolerance(self, _arg): # real signature unknown; restored from __doc__
        """
        SetPixelTolerance(self, _arg:int) -> None
        C++: virtual void SetPixelTolerance(int _arg)
        
        The tolerance to use when calculations are performed in display
        coordinates
        """
        pass

    def SetPointPlacer(self, __a): # real signature unknown; restored from __doc__
        """
        SetPointPlacer(self, __a:vtkPointPlacer) -> None
        C++: void SetPointPlacer(vtkPointPlacer *)
        
        Set / get the Point Placer. The point placer is responsible for
        converting display coordinates into world coordinates according
        to some constraints, and for validating world positions.
        """
        pass

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

    def SetShowSelectedNodes(self, __a): # real signature unknown; restored from __doc__
        """
        SetShowSelectedNodes(self, __a:int) -> None
        C++: virtual void SetShowSelectedNodes(vtkTypeBool)
        
        A flag to indicate whether to show the Selected nodes Default is
        to set it to false.
        """
        pass

    def SetWorldTolerance(self, _arg): # real signature unknown; restored from __doc__
        """
        SetWorldTolerance(self, _arg:float) -> None
        C++: virtual void SetWorldTolerance(double _arg)
        
        The tolerance to use when calculations are performed in world
        coordinates
        """
        pass

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

    def ShowSelectedNodesOn(self): # real signature unknown; restored from __doc__
        """
        ShowSelectedNodesOn(self) -> None
        C++: virtual void ShowSelectedNodesOn()
        """
        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 = 0;
        """
        pass

    def ToggleActiveNodeSelected(self): # real signature unknown; restored from __doc__
        """
        ToggleActiveNodeSelected(self) -> int
        C++: virtual int ToggleActiveNodeSelected()
        
        Set/Get whether the active or nth node is selected.
        """
        return 0

    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 = 0;
        """
        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."""


    Inactive = 0
    Nearby = 1
    Outside = 0
    Scale = 3
    Shift = 2
    Translate = 1
    __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkContourRepresentation', 'IsTypeOf': <method 'IsTypeOf' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'IsA': <method 'IsA' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'SafeDownCast': <method 'SafeDownCast' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'NewInstance': <method 'NewInstance' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetNumberOfGenerationsFromBaseType': <method 'GetNumberOfGenerationsFromBaseType' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetNumberOfGenerationsFromBase': <method 'GetNumberOfGenerationsFromBase' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'AddNodeAtWorldPosition': <method 'AddNodeAtWorldPosition' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'AddNodeAtDisplayPosition': <method 'AddNodeAtDisplayPosition' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'ActivateNode': <method 'ActivateNode' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'SetActiveNodeToWorldPosition': <method 'SetActiveNodeToWorldPosition' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'SetActiveNodeToDisplayPosition': <method 'SetActiveNodeToDisplayPosition' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'ToggleActiveNodeSelected': <method 'ToggleActiveNodeSelected' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetActiveNodeSelected': <method 'GetActiveNodeSelected' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetNthNodeSelected': <method 'GetNthNodeSelected' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'SetNthNodeSelected': <method 'SetNthNodeSelected' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetActiveNodeWorldPosition': <method 'GetActiveNodeWorldPosition' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetActiveNodeWorldOrientation': <method 'GetActiveNodeWorldOrientation' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetActiveNodeDisplayPosition': <method 'GetActiveNodeDisplayPosition' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetNumberOfNodes': <method 'GetNumberOfNodes' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetNthNodeDisplayPosition': <method 'GetNthNodeDisplayPosition' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetNthNodeWorldPosition': <method 'GetNthNodeWorldPosition' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetNthNodeWorldOrientation': <method 'GetNthNodeWorldOrientation' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'SetNthNodeDisplayPosition': <method 'SetNthNodeDisplayPosition' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'SetNthNodeWorldPosition': <method 'SetNthNodeWorldPosition' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetNthNodeSlope': <method 'GetNthNodeSlope' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetNumberOfIntermediatePoints': <method 'GetNumberOfIntermediatePoints' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetIntermediatePointWorldPosition': <method 'GetIntermediatePointWorldPosition' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'AddIntermediatePointWorldPosition': <method 'AddIntermediatePointWorldPosition' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'DeleteLastNode': <method 'DeleteLastNode' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'DeleteActiveNode': <method 'DeleteActiveNode' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'DeleteNthNode': <method 'DeleteNthNode' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'ClearAllNodes': <method 'ClearAllNodes' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'AddNodeOnContour': <method 'AddNodeOnContour' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'SetPixelTolerance': <method 'SetPixelTolerance' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetPixelToleranceMinValue': <method 'GetPixelToleranceMinValue' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetPixelToleranceMaxValue': <method 'GetPixelToleranceMaxValue' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetPixelTolerance': <method 'GetPixelTolerance' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'SetWorldTolerance': <method 'SetWorldTolerance' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetWorldToleranceMinValue': <method 'GetWorldToleranceMinValue' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetWorldToleranceMaxValue': <method 'GetWorldToleranceMaxValue' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetWorldTolerance': <method 'GetWorldTolerance' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetCurrentOperation': <method 'GetCurrentOperation' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'SetCurrentOperation': <method 'SetCurrentOperation' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetCurrentOperationMinValue': <method 'GetCurrentOperationMinValue' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetCurrentOperationMaxValue': <method 'GetCurrentOperationMaxValue' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'SetCurrentOperationToInactive': <method 'SetCurrentOperationToInactive' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'SetCurrentOperationToTranslate': <method 'SetCurrentOperationToTranslate' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'SetCurrentOperationToShift': <method 'SetCurrentOperationToShift' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'SetCurrentOperationToScale': <method 'SetCurrentOperationToScale' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'SetPointPlacer': <method 'SetPointPlacer' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetPointPlacer': <method 'GetPointPlacer' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'SetLineInterpolator': <method 'SetLineInterpolator' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetLineInterpolator': <method 'GetLineInterpolator' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'BuildRepresentation': <method 'BuildRepresentation' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'ComputeInteractionState': <method 'ComputeInteractionState' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'StartWidgetInteraction': <method 'StartWidgetInteraction' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'WidgetInteraction': <method 'WidgetInteraction' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'ReleaseGraphicsResources': <method 'ReleaseGraphicsResources' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'RenderOverlay': <method 'RenderOverlay' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'RenderOpaqueGeometry': <method 'RenderOpaqueGeometry' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'RenderTranslucentPolygonalGeometry': <method 'RenderTranslucentPolygonalGeometry' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'HasTranslucentPolygonalGeometry': <method 'HasTranslucentPolygonalGeometry' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'SetClosedLoop': <method 'SetClosedLoop' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetClosedLoop': <method 'GetClosedLoop' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'ClosedLoopOn': <method 'ClosedLoopOn' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'ClosedLoopOff': <method 'ClosedLoopOff' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'SetShowSelectedNodes': <method 'SetShowSelectedNodes' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetShowSelectedNodes': <method 'GetShowSelectedNodes' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'ShowSelectedNodesOn': <method 'ShowSelectedNodesOn' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'ShowSelectedNodesOff': <method 'ShowSelectedNodesOff' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetContourRepresentationAsPolyData': <method 'GetContourRepresentationAsPolyData' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'GetNodePolyData': <method 'GetNodePolyData' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'SetRebuildLocator': <method 'SetRebuildLocator' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, 'Outside': 0, 'Nearby': 1, 'Inactive': 0, 'Translate': 1, 'Shift': 2, 'Scale': 3, '__new__': <built-in method __new__ of type object at 0x00007FF81D642CF0>, '__repr__': <slot wrapper '__repr__' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, '__str__': <slot wrapper '__str__' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, '__getattribute__': <slot wrapper '__getattribute__' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, '__setattr__': <slot wrapper '__setattr__' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, '__delattr__': <slot wrapper '__delattr__' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, '__dict__': <attribute '__dict__' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, '__this__': <attribute '__this__' of 'vtkmodules.vtkInteractionWidgets.vtkContourRepresentation' objects>, '__doc__': 'vtkContourRepresentation - represent the vtkContourWidget\\n\\nSuperclass: vtkWidgetRepresentation\\n\\nThe vtkContourRepresentation is a superclass for various types of\\nrepresentations for vtkContourWidget.\\n\\n@par Managing contour points: The classes\\nvtkContourRepresentationNode, vtkContourRepresentationInternals, and\\nvtkContourRepresentationPoint manage the data structure used to\\nrepresent nodes and points on a contour. A contour may contain\\nseveral nodes and several additional points. Nodes are usually the\\nresult of user-clicked points on the contour. Additional points are\\ncreated between nodes to generate a smooth curve using some\\nInterpolator -- see the method SetLineInterpolator.\\n\\n@par Managing contour points:\\\\par The data structure stores both the\\nworld and display positions for every point. (This may seem like a\\nduplication.) The default behaviour of this class is to use the\\nWorldPosition to do all the math. Typically a point is added at a\\ngiven display position. Its corresponding world position is computed\\nusing the point placer, and stored. Any query of the display position\\nof a stored point is done via the Renderer, which computes the\\ndisplay position given a world position.\\n\\n@par Managing contour points:\\\\par So why maintain the display\\nposition? Consider drawing a contour on a volume widget. You might\\nwant the contour to be located at a certain world position in the\\nvolume or you might want to be overlaid over the window like an\\nActor2D. The default behaviour of this class is to provide the former\\nbehaviour.\\n\\n@par Managing contour points:\\\\par To achieve the latter behaviour,\\noverride the methods that return the display position (to return the\\nset display position instead of computing it from the world\\npositions) and the method BuildLines() to interpolate lines using\\ntheir display positions instead of world positions.\\n\\n@sa\\nvtkContourWidget\\n\\n'})"
    __vtkname__ = 'vtkContourRepresentation'