"""
This type stub file was generated by pyright.
"""

from .vtkPointPlacer import vtkPointPlacer

class vtkBoundedPlanePointPlacer(vtkPointPlacer):
    """
    vtkBoundedPlanePointPlacer - a placer that constrains a handle to a
    finite plane
    
    Superclass: vtkPointPlacer
    
    vtkBoundedPlanePointPlacer is a type of point placer that constrains
    its points to a finite (i.e., bounded) plance.
    
    @sa
    vtkPointPlacer vtkHandleWidget vtkHandleRepresentation
    """
    def AddBoundingPlane(self, vtkPlane):
        """
        V.AddBoundingPlane(vtkPlane)
        C++: void AddBoundingPlane(vtkPlane *plane)
        
        A collection of plane equations used to bound the position of the
        point. This is in addition to confining the point to a plane -
        these constraints are meant to, for example, keep a point within
        the extent of an image. Using a set of plane equations allows for
        more complex bounds (such as bounding a point to an oblique
        reliced image that has hexagonal shape) than a simple extent.
        """
        ...
    
    def ComputeWorldPosition(self, vtkRenderer, p_float=..., p_float=..., *args, **kwargs):
        """
        V.ComputeWorldPosition(vtkRenderer, [float, float], [float, float,
             float], [float, float, float, float, float, float, float,
            float, float]) -> int
        C++: int ComputeWorldPosition(vtkRenderer *ren,
            double displayPos[2], double worldPos[3],
            double worldOrient[9]) override;
        V.ComputeWorldPosition(vtkRenderer, [float, float], [float, float,
             float], [float, float, float], [float, float, float, float,
            float, float, float, float, float]) -> int
        C++: int ComputeWorldPosition(vtkRenderer *ren,
            double displayPos[2], double refWorldPos[3],
            double worldPos[3], double worldOrient[9]) override;
        
        Given a renderer and a display position, compute the world
        position and world orientation for this point. A plane is defined
        by a combination of the ProjectionNormal, ProjectionOrigin, and
        ObliquePlane ivars. The display position is projected onto this
        plane to determine a world position, and the orientation is set
        to the normal of the plane. If the point cannot project onto the
        plane or if it falls outside the bounds imposed by the
        BoundingPlanes, then 0 is returned, otherwise 1 is returned to
        indicate a valid return position and orientation.
        """
        ...
    
    def GetBoundingPlanes(self):
        """
        V.GetBoundingPlanes() -> vtkPlaneCollection
        C++: virtual vtkPlaneCollection *GetBoundingPlanes()
        
        A collection of plane equations used to bound the position of the
        point. This is in addition to confining the point to a plane -
        these constraints are meant to, for example, keep a point within
        the extent of an image. Using a set of plane equations allows for
        more complex bounds (such as bounding a point to an oblique
        reliced image that has hexagonal shape) than a simple extent.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Standard methods for instances of this class.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Standard methods for instances of this class.
        """
        ...
    
    def GetObliquePlane(self):
        """
        V.GetObliquePlane() -> vtkPlane
        C++: virtual vtkPlane *GetObliquePlane()
        
        If the ProjectionNormal is set to Oblique, then this is the
        oblique plane used to constrain the handle position.
        """
        ...
    
    def GetProjectionNormal(self):
        """
        V.GetProjectionNormal() -> int
        C++: virtual int GetProjectionNormal()
        
        Set the projection normal to lie along the x, y, or z axis, or to
        be oblique. If it is oblique, then the plane is defined in the
        ObliquePlane ivar.
        """
        ...
    
    def GetProjectionNormalMaxValue(self):
        """
        V.GetProjectionNormalMaxValue() -> int
        C++: virtual int GetProjectionNormalMaxValue()
        
        Set the projection normal to lie along the x, y, or z axis, or to
        be oblique. If it is oblique, then the plane is defined in the
        ObliquePlane ivar.
        """
        ...
    
    def GetProjectionNormalMinValue(self):
        """
        V.GetProjectionNormalMinValue() -> int
        C++: virtual int GetProjectionNormalMinValue()
        
        Set the projection normal to lie along the x, y, or z axis, or to
        be oblique. If it is oblique, then the plane is defined in the
        ObliquePlane ivar.
        """
        ...
    
    def GetProjectionPosition(self):
        """
        V.GetProjectionPosition() -> float
        C++: virtual double GetProjectionPosition()
        
        The position of the bounding plane from the origin along the
        normal. The origin and normal are defined in the oblique plane
        when the ProjectionNormal is oblique. For the X, Y, and Z axes
        projection normals, the normal is the axis direction, and the
        origin is (0,0,0).
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Standard methods for instances of this class.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Standard methods for instances of this class.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkBoundedPlanePointPlacer
        C++: vtkBoundedPlanePointPlacer *NewInstance()
        
        Standard methods for instances of this class.
        """
        ...
    
    def RemoveAllBoundingPlanes(self):
        """
        V.RemoveAllBoundingPlanes()
        C++: void RemoveAllBoundingPlanes()
        
        A collection of plane equations used to bound the position of the
        point. This is in addition to confining the point to a plane -
        these constraints are meant to, for example, keep a point within
        the extent of an image. Using a set of plane equations allows for
        more complex bounds (such as bounding a point to an oblique
        reliced image that has hexagonal shape) than a simple extent.
        """
        ...
    
    def RemoveBoundingPlane(self, vtkPlane):
        """
        V.RemoveBoundingPlane(vtkPlane)
        C++: void RemoveBoundingPlane(vtkPlane *plane)
        
        A collection of plane equations used to bound the position of the
        point. This is in addition to confining the point to a plane -
        these constraints are meant to, for example, keep a point within
        the extent of an image. Using a set of plane equations allows for
        more complex bounds (such as bounding a point to an oblique
        reliced image that has hexagonal shape) than a simple extent.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkBoundedPlanePointPlacer
        C++: static vtkBoundedPlanePointPlacer *SafeDownCast(
            vtkObjectBase *o)
        
        Standard methods for instances of this class.
        """
        ...
    
    def SetBoundingPlanes(self, vtkPlaneCollection):
        """
        V.SetBoundingPlanes(vtkPlaneCollection)
        C++: virtual void SetBoundingPlanes(vtkPlaneCollection *)
        V.SetBoundingPlanes(vtkPlanes)
        C++: void SetBoundingPlanes(vtkPlanes *planes)
        
        A collection of plane equations used to bound the position of the
        point. This is in addition to confining the point to a plane -
        these constraints are meant to, for example, keep a point within
        the extent of an image. Using a set of plane equations allows for
        more complex bounds (such as bounding a point to an oblique
        reliced image that has hexagonal shape) than a simple extent.
        """
        ...
    
    def SetObliquePlane(self, vtkPlane):
        """
        V.SetObliquePlane(vtkPlane)
        C++: void SetObliquePlane(vtkPlane *)
        
        If the ProjectionNormal is set to Oblique, then this is the
        oblique plane used to constrain the handle position.
        """
        ...
    
    def SetProjectionNormal(self, p_int):
        """
        V.SetProjectionNormal(int)
        C++: virtual void SetProjectionNormal(int _arg)
        
        Set the projection normal to lie along the x, y, or z axis, or to
        be oblique. If it is oblique, then the plane is defined in the
        ObliquePlane ivar.
        """
        ...
    
    def SetProjectionNormalToOblique(self):
        """
        V.SetProjectionNormalToOblique()
        C++: void SetProjectionNormalToOblique()
        
        Set the projection normal to lie along the x, y, or z axis, or to
        be oblique. If it is oblique, then the plane is defined in the
        ObliquePlane ivar.
        """
        ...
    
    def SetProjectionNormalToXAxis(self):
        """
        V.SetProjectionNormalToXAxis()
        C++: void SetProjectionNormalToXAxis()
        
        Set the projection normal to lie along the x, y, or z axis, or to
        be oblique. If it is oblique, then the plane is defined in the
        ObliquePlane ivar.
        """
        ...
    
    def SetProjectionNormalToYAxis(self):
        """
        V.SetProjectionNormalToYAxis()
        C++: void SetProjectionNormalToYAxis()
        
        Set the projection normal to lie along the x, y, or z axis, or to
        be oblique. If it is oblique, then the plane is defined in the
        ObliquePlane ivar.
        """
        ...
    
    def SetProjectionNormalToZAxis(self):
        """
        V.SetProjectionNormalToZAxis()
        C++: void SetProjectionNormalToZAxis()
        
        Set the projection normal to lie along the x, y, or z axis, or to
        be oblique. If it is oblique, then the plane is defined in the
        ObliquePlane ivar.
        """
        ...
    
    def SetProjectionPosition(self, p_float):
        """
        V.SetProjectionPosition(float)
        C++: void SetProjectionPosition(double position)
        
        The position of the bounding plane from the origin along the
        normal. The origin and normal are defined in the oblique plane
        when the ProjectionNormal is oblique. For the X, Y, and Z axes
        projection normals, the normal is the axis direction, and the
        origin is (0,0,0).
        """
        ...
    
    def UpdateWorldPosition(self, vtkRenderer, p_float=..., p_float=..., p_float=..., *args, **kwargs):
        """
        V.UpdateWorldPosition(vtkRenderer, [float, float, float], [float,
            float, float, float, float, float, float, float, float])
            -> int
        C++: int UpdateWorldPosition(vtkRenderer *ren, double worldPos[3],
             double worldOrient[9]) override;
        
        If the constraints on this placer are changed, then this method
        will be called by the representation on each of its points. For
        this placer, the world position will be converted to a display
        position, then ComputeWorldPosition will be used to update the
        point.
        """
        ...
    
    def ValidateWorldPosition(self, p_float=..., p_float=..., p_float=...):
        """
        V.ValidateWorldPosition([float, float, float]) -> int
        C++: int ValidateWorldPosition(double worldPos[3]) override;
        V.ValidateWorldPosition([float, float, float], [float, float,
            float, float, float, float, float, float, float]) -> int
        C++: int ValidateWorldPosition(double worldPos[3],
            double worldOrient[9]) override;
        
        Give a world position check if it is valid - does it lie on the
        plane and within the bounds? Returns 1 if it is valid, 0
        otherwise.
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    Oblique = ...
    XAxis = ...
    YAxis = ...
    ZAxis = ...
    __dict__ = ...
    __vtkname__ = ...


