# encoding: utf-8
# module vtkmodules.vtkCommonDataModel
# from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\vtkmodules\vtkCommonDataModel.cp311-win_amd64.pyd
# by generator 1.147
# no doc

# imports
import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore
import vtkmodules.vtkCommonMath as __vtkmodules_vtkCommonMath
import vtkmodules.vtkCommonTransforms as __vtkmodules_vtkCommonTransforms


from .object import object

class vtkIntersectionCounter(object):
    """
    vtkIntersectionCounter() -> vtkIntersectionCounter
    C++: vtkIntersectionCounter()
    vtkIntersectionCounter(tol:float, length:float)
        -> vtkIntersectionCounter
    C++: vtkIntersectionCounter(double tol, double length)
    vtkIntersectionCounter(__a:vtkIntersectionCounter)
        -> vtkIntersectionCounter
    C++: vtkIntersectionCounter(const &vtkIntersectionCounter)
    
    vtkIntersectionCounter - Fast simple class for dealing with ray
    intersections
    
    vtkIntersectionCounter is used to intersect data and merge coincident
    points along the intersect ray. It is light-weight and many of the
    member functions are in-lined so its very fast. It is not derived
    from vtkObject so it can be allocated on the stack.
    
    This class makes the finite ray intersection process more robust. It
    merges intersections that are very close to one another (within a
    tolerance). Such situations are common when intersection rays pass
    through the edge or vertex of a mesh.
    
    @sa
    vtkBoundingBox
    """
    def AddIntersection(self, t): # real signature unknown; restored from __doc__
        """
        AddIntersection(self, t:float) -> None
        C++: void AddIntersection(double t)
        
        Add an intersection given by parametric coordinate t.
        """
        pass

    def CountIntersections(self): # real signature unknown; restored from __doc__
        """
        CountIntersections(self) -> int
        C++: int CountIntersections()
        
        Returns number of intersections (even number of intersections,
        outside or odd number of intersections, inside). This is done by
        considering close intersections (within Tolerance) as being the
        same point.
        """
        return 0

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

    def Reset(self): # real signature unknown; restored from __doc__
        """
        Reset(self) -> None
        C++: void Reset()
        
        Reset the intersection process.
        """
        pass

    def SetTolerance(self, tol): # real signature unknown; restored from __doc__
        """
        SetTolerance(self, tol:float) -> None
        C++: void SetTolerance(double tol)
        
        Set/Get the intersection tolerance.
        """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        pass

    def __init__(self): # real signature unknown; restored from __doc__
        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