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

import vtkmodules.vtkCommonDataModel as __vtkmodules_vtkCommonDataModel

class vtkViewDependentErrorMetric(__vtkmodules_vtkCommonDataModel.vtkGenericSubdivisionErrorMetric):
    """
    vtkViewDependentErrorMetric - Objects that compute a screen-based
    error during cell tessellation.
    
    Superclass: vtkGenericSubdivisionErrorMetric
    
    It is a concrete error metric, based on a geometric criterium in the
    screen space: the variation of the projected edge from a projected
    straight line
    
    @sa
    vtkGenericCellTessellator vtkGenericSubdivisionErrorMetric
    """
    def GetError(self, *float, **kwargs):
        """
        V.GetError([float, ...], [float, ...], [float, ...], float)
            -> float
        C++: double GetError(double *leftPoint, double *midPoint,
            double *rightPoint, double alpha) override;
        
        Return the error at the mid-point. The type of error depends on
        the state of the concrete error metric. For instance, it can
        return an absolute or relative error metric. See
        RequiresEdgeSubdivision() for a description of the arguments.
        \pre leftPoint_exists: leftPoint!=0
        \pre midPoint_exists: midPoint!=0
        \pre rightPoint_exists: rightPoint!=0
        \pre clamped_alpha: alpha>0 && alpha<1
        \pre valid_size:
            sizeof(leftPoint)=sizeof(midPoint)=sizeof(rightPoint)
        =GetAttributeCollection()->GetNumberOfPointCenteredComponents()+6
        \post positive_result: result>=0
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Standard VTK type and error macros.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Standard VTK type and error macros.
        """
        ...
    
    def GetPixelTolerance(self):
        """
        V.GetPixelTolerance() -> float
        C++: virtual double GetPixelTolerance()
        
        Return the squared screen-based geometric accuracy measured in
        pixels. An accuracy less or equal to 0.25 (0.5^2) ensures that
        the screen-space interpolation of a mid-point matches exactly
        with the projection of the mid-point (a value less than 1 but
        greater than 0.25 is not enough, because of 8-neighbors). Maybe
        it is useful for lower accuracy in case of anti-aliasing?
        \post positive_result: result>0
        """
        ...
    
    def GetViewport(self):
        """
        V.GetViewport() -> vtkViewport
        C++: virtual vtkViewport *GetViewport()
        
        Set/Get the renderer with `renderer' on which the error metric is
        based. The error metric use the active camera of the renderer.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Standard VTK type and error macros.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Standard VTK type and error macros.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkViewDependentErrorMetric
        C++: vtkViewDependentErrorMetric *NewInstance()
        
        Standard VTK type and error macros.
        """
        ...
    
    def RequiresEdgeSubdivision(self, *float, **kwargs):
        """
        V.RequiresEdgeSubdivision([float, ...], [float, ...], [float,
            ...], float) -> int
        C++: int RequiresEdgeSubdivision(double *leftPoint,
            double *midPoint, double *rightPoint, double alpha) override;
        
        Does the edge need to be subdivided according to the distance
        between the line passing through its endpoints in screen space
        and the projection of its mid point? The edge is defined by its
        `leftPoint' and its `rightPoint'. `leftPoint', `midPoint' and
        `rightPoint' have to be initialized before calling
        RequiresEdgeSubdivision(). Their format is global coordinates,
        parametric coordinates and point centered attributes: xyx rst abc
        de... `alpha' is the normalized abscissa of the midpoint along
        the edge. (close to 0 means close to the left point, close to 1
        means close to the right point)
        \pre leftPoint_exists: leftPoint!=0
        \pre midPoint_exists: midPoint!=0
        \pre rightPoint_exists: rightPoint!=0
        \pre clamped_alpha: alpha>0 && alpha<1
        \pre valid_size:
            sizeof(leftPoint)=sizeof(midPoint)=sizeof(rightPoint)
        =GetAttributeCollection()->GetNumberOfPointCenteredComponents()+6
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkViewDependentErrorMetric
        C++: static vtkViewDependentErrorMetric *SafeDownCast(
            vtkObjectBase *o)
        
        Standard VTK type and error macros.
        """
        ...
    
    def SetPixelTolerance(self, p_float):
        """
        V.SetPixelTolerance(float)
        C++: void SetPixelTolerance(double value)
        
        Set the squared screen-based geometric accuracy measured in
        pixels. Subdivision will be required if the square distance
        between the projection of the real point and the straight line
        passing through the projection of the vertices of the edge is
        greater than `value'. For instance, 0.25 will give better result
        than 1.
        \pre positive_value: value>0
        """
        ...
    
    def SetViewport(self, vtkViewport):
        """
        V.SetViewport(vtkViewport)
        C++: void SetViewport(vtkViewport *viewport)
        
        Set/Get the renderer with `renderer' on which the error metric is
        based. The error metric use the active camera of the renderer.
        """
        ...
    
    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__ = ...


