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

import vtkmodules.vtkCommonExecutionModel as __vtkmodules_vtkCommonExecutionModel

class vtkCellValidator(__vtkmodules_vtkCommonExecutionModel.vtkDataSetAlgorithm):
    """
    vtkCellValidator - validates cells in a dataset
    
    Superclass: vtkDataSetAlgorithm
    
    vtkCellValidator accepts as input a dataset and adds integral cell
    data to it corresponding to the "validity" of each cell. The validity
    field encodes a bitfield for identifying problems that prevent a cell
    from standard use, including:
    
    
      WrongNumberOfPoints: filters assume that a cell has access to the
                           appropriate number of points that comprise it.
    This
                           assumption is often tacit, resulting in
    unexpected
                           behavior when the condition is not met. This
    check
                           simply confirms that the cell has the minimum
    number
                           of points needed to describe it.
    
    
      IntersectingEdges: cells that incorrectly describe the order of
    their
                         points often manifest with intersecting edges or
                         intersecting faces. Given a tolerance, this
    check
                         ensures that two edges from a two-dimensional
    cell
                         are separated by at least the tolerance
    (discounting
                         end-to-end connections).
    
    
      IntersectingFaces: cells that incorrectly describe the order of
    their
                         points often manifest with intersecting edges or
                         intersecting faces. Given a tolerance, this
    check
                         ensures that two faces from a three-dimensional
    cell
                         do not intersect.
    
    
      NoncontiguousEdges: another symptom of incorrect point ordering
    within a
                          cell is the presence of noncontiguous edges
    where
                          contiguous edges are otherwise expected. Given
    a
                          tolerance, this check ensures that edges around
    the
                          perimeter of a two-dimensional cell are
    contiguous.
    
    
      Nonconvex: many algorithms implicitly require that all input three-
                 dimensional cells be convex. This check uses the generic
                 convexity checkers implemented in vtkPolygon and
    vtkPolyhedron
                 to test this requirement.
    
    
      FacesAreOrientedIncorrectly: All three-dimensional cells have an
    implicit
                                   expectation for the orientation of
    their
                                   faces. While the convention is
    unfortunately
                                   inconsistent across cell types, it is
    usually
                                   required that cell faces point
    outward. This
                                   check tests that the faces of a cell
    point in
                                   the direction required by the cell
    type,
                                   taking into account the cell types
    with
                                   nonstandard orientation requirements.
    
    @sa
    vtkCellQuality
    """
    def Check(self, vtkGenericCell, p_float):
        """
        V.Check(vtkGenericCell, float) -> State
        C++: static State Check(vtkGenericCell *, double tolerance)
        V.Check(vtkCell, float) -> State
        C++: static State Check(vtkCell *, double tolerance)
        V.Check(vtkEmptyCell, float) -> State
        C++: static State Check(vtkEmptyCell *, double tolerance)
        V.Check(vtkVertex, float) -> State
        C++: static State Check(vtkVertex *, double tolerance)
        V.Check(vtkPolyVertex, float) -> State
        C++: static State Check(vtkPolyVertex *, double tolerance)
        V.Check(vtkLine, float) -> State
        C++: static State Check(vtkLine *, double tolerance)
        V.Check(vtkPolyLine, float) -> State
        C++: static State Check(vtkPolyLine *, double tolerance)
        V.Check(vtkTriangle, float) -> State
        C++: static State Check(vtkTriangle *, double tolerance)
        V.Check(vtkTriangleStrip, float) -> State
        C++: static State Check(vtkTriangleStrip *, double tolerance)
        V.Check(vtkPolygon, float) -> State
        C++: static State Check(vtkPolygon *, double tolerance)
        V.Check(vtkPixel, float) -> State
        C++: static State Check(vtkPixel *, double tolerance)
        V.Check(vtkQuad, float) -> State
        C++: static State Check(vtkQuad *, double tolerance)
        V.Check(vtkTetra, float) -> State
        C++: static State Check(vtkTetra *, double tolerance)
        V.Check(vtkVoxel, float) -> State
        C++: static State Check(vtkVoxel *, double tolerance)
        V.Check(vtkHexahedron, float) -> State
        C++: static State Check(vtkHexahedron *, double tolerance)
        V.Check(vtkWedge, float) -> State
        C++: static State Check(vtkWedge *, double tolerance)
        V.Check(vtkPyramid, float) -> State
        C++: static State Check(vtkPyramid *, double tolerance)
        V.Check(vtkPentagonalPrism, float) -> State
        C++: static State Check(vtkPentagonalPrism *, double tolerance)
        V.Check(vtkHexagonalPrism, float) -> State
        C++: static State Check(vtkHexagonalPrism *, double tolerance)
        V.Check(vtkQuadraticEdge, float) -> State
        C++: static State Check(vtkQuadraticEdge *, double tolerance)
        """
        ...
    
    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 GetTolerance(self):
        """
        V.GetTolerance() -> float
        C++: virtual double GetTolerance()
        
        Set/Get the tolerance. This value is used as an epsilon for
        floating point equality checks throughout the cell checking
        process. The default value is FLT_EPSILON.
        """
        ...
    
    def GetToleranceMaxValue(self):
        """
        V.GetToleranceMaxValue() -> float
        C++: virtual double GetToleranceMaxValue()
        
        Set/Get the tolerance. This value is used as an epsilon for
        floating point equality checks throughout the cell checking
        process. The default value is FLT_EPSILON.
        """
        ...
    
    def GetToleranceMinValue(self):
        """
        V.GetToleranceMinValue() -> float
        C++: virtual double GetToleranceMinValue()
        
        Set/Get the tolerance. This value is used as an epsilon for
        floating point equality checks throughout the cell checking
        process. The default value is FLT_EPSILON.
        """
        ...
    
    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 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() -> vtkCellValidator
        C++: vtkCellValidator *NewInstance()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkCellValidator
        C++: static vtkCellValidator *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def SetTolerance(self, p_float):
        """
        V.SetTolerance(float)
        C++: virtual void SetTolerance(double _arg)
        
        Set/Get the tolerance. This value is used as an epsilon for
        floating point equality checks throughout the cell checking
        process. The default value is FLT_EPSILON.
        """
        ...
    
    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__ = ...
    FacesAreOrientedIncorrectly = ...
    IntersectingEdges = ...
    IntersectingFaces = ...
    NoncontiguousEdges = ...
    Nonconvex = ...
    State = ...
    Valid = ...
    WrongNumberOfPoints = ...
    __dict__ = ...
    __vtkname__ = ...


