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

import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore

class vtkLocator(__vtkmodules_vtkCommonCore.vtkObject):
    """
    vtkLocator - abstract base class for objects that accelerate spatial
    searches
    
    Superclass: vtkObject
    
    vtkLocator is an abstract base class for spatial search objects, or
    locators. The principle behind locators is that they divide 3-space
    into small regions (or "buckets") that can be quickly found in
    response to queries about point location, line intersection, or
    object-object intersection.
    
    The purpose of this base class is to provide data members and methods
    shared by all locators. The GenerateRepresentation() is one such
    interesting method.  This method works in conjunction with
    vtkLocatorFilter to create polygonal representations for the locator.
    For example, if the locator is an OBB tree (i.e., vtkOBBTree.h), then
    the representation is a set of one or more oriented bounding boxes,
    depending upon the specified level.
    
    Locators typically work as follows. One or more "entities", such as
    points or cells, are inserted into the locator structure. These
    entities are associated with one or more buckets. Then, when
    performing geometric operations, the operations are performed first
    on the buckets, and then if the operation tests positive, then on the
    entities in the bucket. For example, during collision tests, the
    locators are collided first to identify intersecting buckets. If an
    intersection is found, more expensive operations are then carried out
    on the entities in the bucket.
    
    To obtain good performance, locators are often organized in a tree
    structure.  In such a structure, there are frequently multiple
    "levels" corresponding to different nodes in the tree. So the word
    level (in the context of the locator) can be used to specify a
    particular representation in the tree.  For example, in an octree
    (which is a tree with 8 children), level 0 is the bounding box, or
    root octant, and level 1 consists of its eight children.
    
    @warning
    There is a concept of static and incremental locators. Static
    locators are constructed one time, and then support appropriate
    queries. Incremental locators may have data inserted into them over
    time (e.g., adding new points during the process of isocontouring).
    
    @sa
    vtkPointLocator vtkCellLocator vtkOBBTree vtkMergePoints
    """
    def AutomaticOff(self):
        """
        V.AutomaticOff()
        C++: virtual void AutomaticOff()
        
        Boolean controls whether locator depth/resolution of locator is
        computed automatically from average number of entities in bucket.
        If not set, there will be an explicit method to control the
        construction of the locator (found in the subclass).
        """
        ...
    
    def AutomaticOn(self):
        """
        V.AutomaticOn()
        C++: virtual void AutomaticOn()
        
        Boolean controls whether locator depth/resolution of locator is
        computed automatically from average number of entities in bucket.
        If not set, there will be an explicit method to control the
        construction of the locator (found in the subclass).
        """
        ...
    
    def BuildLocator(self):
        """
        V.BuildLocator()
        C++: virtual void BuildLocator()
        
        Build the locator from the input dataset.
        """
        ...
    
    def FreeSearchStructure(self):
        """
        V.FreeSearchStructure()
        C++: virtual void FreeSearchStructure()
        
        Free the memory required for the spatial data structure.
        """
        ...
    
    def GenerateRepresentation(self, p_int, vtkPolyData):
        """
        V.GenerateRepresentation(int, vtkPolyData)
        C++: virtual void GenerateRepresentation(int level,
            vtkPolyData *pd)
        
        Method to build a representation at a particular level. Note that
        the method GetLevel() returns the maximum number of levels
        available for the tree. You must provide a vtkPolyData object
        into which to place the data.
        """
        ...
    
    def GetAutomatic(self):
        """
        V.GetAutomatic() -> int
        C++: virtual vtkTypeBool GetAutomatic()
        
        Boolean controls whether locator depth/resolution of locator is
        computed automatically from average number of entities in bucket.
        If not set, there will be an explicit method to control the
        construction of the locator (found in the subclass).
        """
        ...
    
    def GetBuildTime(self):
        """
        V.GetBuildTime() -> int
        C++: virtual vtkMTimeType GetBuildTime()
        
        Return the time of the last data structure build.
        """
        ...
    
    def GetDataSet(self):
        """
        V.GetDataSet() -> vtkDataSet
        C++: virtual vtkDataSet *GetDataSet()
        
        Build the locator from the points/cells defining this dataset.
        """
        ...
    
    def GetLevel(self):
        """
        V.GetLevel() -> int
        C++: virtual int GetLevel()
        
        Get the level of the locator (determined automatically if
        Automatic is true). The value of this ivar may change each time
        the locator is built. Initial value is 8.
        """
        ...
    
    def GetMaxLevel(self):
        """
        V.GetMaxLevel() -> int
        C++: virtual int GetMaxLevel()
        
        Set the maximum allowable level for the tree. If the Automatic
        ivar is off, this will be the target depth of the locator.
        Initial value is 8.
        """
        ...
    
    def GetMaxLevelMaxValue(self):
        """
        V.GetMaxLevelMaxValue() -> int
        C++: virtual int GetMaxLevelMaxValue()
        
        Set the maximum allowable level for the tree. If the Automatic
        ivar is off, this will be the target depth of the locator.
        Initial value is 8.
        """
        ...
    
    def GetMaxLevelMinValue(self):
        """
        V.GetMaxLevelMinValue() -> int
        C++: virtual int GetMaxLevelMinValue()
        
        Set the maximum allowable level for the tree. If the Automatic
        ivar is off, this will be the target depth of the locator.
        Initial value is 8.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Standard type and print methods.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Standard type and print methods.
        """
        ...
    
    def GetTolerance(self):
        """
        V.GetTolerance() -> float
        C++: virtual double GetTolerance()
        
        Specify absolute tolerance (in world coordinates) for performing
        geometric operations.
        """
        ...
    
    def GetToleranceMaxValue(self):
        """
        V.GetToleranceMaxValue() -> float
        C++: virtual double GetToleranceMaxValue()
        
        Specify absolute tolerance (in world coordinates) for performing
        geometric operations.
        """
        ...
    
    def GetToleranceMinValue(self):
        """
        V.GetToleranceMinValue() -> float
        C++: virtual double GetToleranceMinValue()
        
        Specify absolute tolerance (in world coordinates) for performing
        geometric operations.
        """
        ...
    
    def Initialize(self):
        """
        V.Initialize()
        C++: virtual void Initialize()
        
        Initialize locator. Frees memory and resets object as
        appropriate.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Standard type and print methods.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Standard type and print methods.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkLocator
        C++: vtkLocator *NewInstance()
        
        Standard type and print methods.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkLocator
        C++: static vtkLocator *SafeDownCast(vtkObjectBase *o)
        
        Standard type and print methods.
        """
        ...
    
    def SetAutomatic(self, p_int):
        """
        V.SetAutomatic(int)
        C++: virtual void SetAutomatic(vtkTypeBool _arg)
        
        Boolean controls whether locator depth/resolution of locator is
        computed automatically from average number of entities in bucket.
        If not set, there will be an explicit method to control the
        construction of the locator (found in the subclass).
        """
        ...
    
    def SetDataSet(self, vtkDataSet):
        """
        V.SetDataSet(vtkDataSet)
        C++: virtual void SetDataSet(vtkDataSet *)
        
        Build the locator from the points/cells defining this dataset.
        """
        ...
    
    def SetMaxLevel(self, p_int):
        """
        V.SetMaxLevel(int)
        C++: virtual void SetMaxLevel(int _arg)
        
        Set the maximum allowable level for the tree. If the Automatic
        ivar is off, this will be the target depth of the locator.
        Initial value is 8.
        """
        ...
    
    def SetTolerance(self, p_float):
        """
        V.SetTolerance(float)
        C++: virtual void SetTolerance(double _arg)
        
        Specify absolute tolerance (in world coordinates) for performing
        geometric operations.
        """
        ...
    
    def Update(self):
        """
        V.Update()
        C++: virtual void Update()
        
        Cause the locator to rebuild itself if it or its input dataset
        has changed.
        """
        ...
    
    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__ = ...


