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

import vtkmodules.vtkCommonExecutionModel as __vtkmodules_vtkCommonExecutionModel

class vtkSelectVisiblePoints(__vtkmodules_vtkCommonExecutionModel.vtkPolyDataAlgorithm):
    """
    vtkSelectVisiblePoints - extract points that are visible (based on
    z-buffer calculation)
    
    Superclass: vtkPolyDataAlgorithm
    
    vtkSelectVisiblePoints is a filter that selects points based on
    whether they are visible or not. Visibility is determined by
    accessing the z-buffer of a rendering window. (The position of each
    input point is converted into display coordinates, and then the
    z-value at that point is obtained. If within the user-specified
    tolerance, the point is considered visible.)
    
    Points that are visible (or if the ivar SelectInvisible is on,
    invisible points) are passed to the output. Associated data
    attributes are passed to the output as well.
    
    This filter also allows you to specify a rectangular window in
    display (pixel) coordinates in which the visible points must lie.
    This can be used as a sort of local "brushing" operation to select
    just data within a window.
    
    @warning
    You must carefully synchronize the execution of this filter. The
    filter refers to a renderer, which is modified every time a render
    occurs. Therefore, the filter is always out of date, and always
    executes. You may have to perform two rendering passes, or if you are
    using this filter in conjunction with vtkLabeledDataMapper, things
    work out because 2D rendering occurs after the 3D rendering.
    """
    def GetMTime(self):
        """
        V.GetMTime() -> int
        C++: vtkMTimeType GetMTime() override;
        
        Return MTime also considering the renderer.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        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.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> 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.
        """
        ...
    
    def GetRenderer(self):
        """
        V.GetRenderer() -> vtkRenderer
        C++: vtkRenderer *GetRenderer()
        
        Specify the renderer in which the visibility computation is to be
        performed.
        """
        ...
    
    def GetSelectInvisible(self):
        """
        V.GetSelectInvisible() -> int
        C++: virtual vtkTypeBool GetSelectInvisible()
        
        Set/Get the flag which enables inverse selection; i.e., invisible
        points are selected.
        """
        ...
    
    def GetSelection(self):
        """
        V.GetSelection() -> (int, int, int, int)
        C++: virtual int *GetSelection()
        
        Specify the selection window in display coordinates. You must
        specify a rectangular region using (xmin,xmax,ymin,ymax).
        """
        ...
    
    def GetSelectionWindow(self):
        """
        V.GetSelectionWindow() -> int
        C++: virtual vtkTypeBool GetSelectionWindow()
        
        Set/Get the flag which enables selection in a rectangular display
        region.
        """
        ...
    
    def GetTolerance(self):
        """
        V.GetTolerance() -> float
        C++: virtual double GetTolerance()
        
        Set/Get a tolerance in normalized display coordinate system to
        use to determine whether a point is visible. A tolerance is
        usually required because the conversion from world space to
        display space during rendering introduces numerical round-off.
        """
        ...
    
    def GetToleranceMaxValue(self):
        """
        V.GetToleranceMaxValue() -> float
        C++: virtual double GetToleranceMaxValue()
        
        Set/Get a tolerance in normalized display coordinate system to
        use to determine whether a point is visible. A tolerance is
        usually required because the conversion from world space to
        display space during rendering introduces numerical round-off.
        """
        ...
    
    def GetToleranceMinValue(self):
        """
        V.GetToleranceMinValue() -> float
        C++: virtual double GetToleranceMinValue()
        
        Set/Get a tolerance in normalized display coordinate system to
        use to determine whether a point is visible. A tolerance is
        usually required because the conversion from world space to
        display space during rendering introduces numerical round-off.
        """
        ...
    
    def GetToleranceWorld(self):
        """
        V.GetToleranceWorld() -> float
        C++: virtual double GetToleranceWorld()
        
        Set/Get a tolerance in world coordinate system to use to
        determine whether a point is visible. This allows determining
        visibility of small spheroid objects (such as glyphs) with known
        size in world coordinates. By default it is set to 0.
        """
        ...
    
    def GetToleranceWorldMaxValue(self):
        """
        V.GetToleranceWorldMaxValue() -> float
        C++: virtual double GetToleranceWorldMaxValue()
        
        Set/Get a tolerance in world coordinate system to use to
        determine whether a point is visible. This allows determining
        visibility of small spheroid objects (such as glyphs) with known
        size in world coordinates. By default it is set to 0.
        """
        ...
    
    def GetToleranceWorldMinValue(self):
        """
        V.GetToleranceWorldMinValue() -> float
        C++: virtual double GetToleranceWorldMinValue()
        
        Set/Get a tolerance in world coordinate system to use to
        determine whether a point is visible. This allows determining
        visibility of small spheroid objects (such as glyphs) with known
        size in world coordinates. By default it is set to 0.
        """
        ...
    
    def Initialize(self, bool):
        """
        V.Initialize(bool) -> (float, ...)
        C++: float *Initialize(bool getZbuff)
        
        Requires the renderer to be set. Populates the composite
        perspective transform and returns a pointer to the Z-buffer (that
        must be deleted) if getZbuff is set.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> 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.
        """
        ...
    
    def IsPointOccluded(self, , float_tuple):
        """
        V.IsPointOccluded((float, float, float), (float, ...)) -> bool
        C++: bool IsPointOccluded(const double x[3], const float *zPtr)
        
        Tests if a point x is being occluded or not against the Z-Buffer
        array passed in by zPtr. Call Initialize before calling this
        method.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> 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.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkSelectVisiblePoints
        C++: vtkSelectVisiblePoints *NewInstance()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkSelectVisiblePoints
        C++: static vtkSelectVisiblePoints *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def SelectInvisibleOff(self):
        """
        V.SelectInvisibleOff()
        C++: virtual void SelectInvisibleOff()
        
        Set/Get the flag which enables inverse selection; i.e., invisible
        points are selected.
        """
        ...
    
    def SelectInvisibleOn(self):
        """
        V.SelectInvisibleOn()
        C++: virtual void SelectInvisibleOn()
        
        Set/Get the flag which enables inverse selection; i.e., invisible
        points are selected.
        """
        ...
    
    def SelectionWindowOff(self):
        """
        V.SelectionWindowOff()
        C++: virtual void SelectionWindowOff()
        
        Set/Get the flag which enables selection in a rectangular display
        region.
        """
        ...
    
    def SelectionWindowOn(self):
        """
        V.SelectionWindowOn()
        C++: virtual void SelectionWindowOn()
        
        Set/Get the flag which enables selection in a rectangular display
        region.
        """
        ...
    
    def SetRenderer(self, vtkRenderer):
        """
        V.SetRenderer(vtkRenderer)
        C++: void SetRenderer(vtkRenderer *ren)
        
        Specify the renderer in which the visibility computation is to be
        performed.
        """
        ...
    
    def SetSelectInvisible(self, p_int):
        """
        V.SetSelectInvisible(int)
        C++: virtual void SetSelectInvisible(vtkTypeBool _arg)
        
        Set/Get the flag which enables inverse selection; i.e., invisible
        points are selected.
        """
        ...
    
    def SetSelection(self, p_int, p_int_1, p_int_2, p_int_3):
        """
        V.SetSelection(int, int, int, int)
        C++: virtual void SetSelection(int _arg1, int _arg2, int _arg3,
            int _arg4)
        V.SetSelection((int, int, int, int))
        C++: virtual void SetSelection(const int _arg[4])
        
        Specify the selection window in display coordinates. You must
        specify a rectangular region using (xmin,xmax,ymin,ymax).
        """
        ...
    
    def SetSelectionWindow(self, p_int):
        """
        V.SetSelectionWindow(int)
        C++: virtual void SetSelectionWindow(vtkTypeBool _arg)
        
        Set/Get the flag which enables selection in a rectangular display
        region.
        """
        ...
    
    def SetTolerance(self, p_float):
        """
        V.SetTolerance(float)
        C++: virtual void SetTolerance(double _arg)
        
        Set/Get a tolerance in normalized display coordinate system to
        use to determine whether a point is visible. A tolerance is
        usually required because the conversion from world space to
        display space during rendering introduces numerical round-off.
        """
        ...
    
    def SetToleranceWorld(self, p_float):
        """
        V.SetToleranceWorld(float)
        C++: virtual void SetToleranceWorld(double _arg)
        
        Set/Get a tolerance in world coordinate system to use to
        determine whether a point is visible. This allows determining
        visibility of small spheroid objects (such as glyphs) with known
        size in world coordinates. By default it is set to 0.
        """
        ...
    
    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__ = ...
    __dict__ = ...
    __vtkname__ = ...


