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

import vtkmodules.vtkCommonExecutionModel as __vtkmodules_vtkCommonExecutionModel

class vtkAdaptiveSubdivisionFilter(__vtkmodules_vtkCommonExecutionModel.vtkPolyDataAlgorithm):
    """
    vtkAdaptiveSubdivisionFilter - subdivide triangles based on edge
    and/or area metrics
    
    Superclass: vtkPolyDataAlgorithm
    
    vtkAdaptiveSubdivisionFilter is a filter that subdivides triangles
    based on maximum edge length and/or triangle area. It uses a simple
    case-based, multi-pass approach to repeatedly subdivide the input
    triangle mesh to meet the area and/or edge length criteria. New
    points may be inserted only on edges; depending on the number of
    edges to be subdivided a different number of triangles are inserted
    ranging from two (i.e., two triangles replace the original one) to
    four.
    
    Triangle subdivision is controlled by specifying a maximum edge
    length and/or triangle area that any given triangle may have.
    Subdivision proceeds until their criteria are satisfied. Note that
    using excessively small criteria values can produce enormous meshes
    with the possibility of exhausting system memory. Also, if you want
    to ignore a particular criterion value (e.g., triangle area) then
    simply set the criterion value to a very large value (e.g.,
    VTK_DOUBLE_MAX).
    
    An incremental point locator is used because as new points are
    created, a search is made to ensure that a point has not already been
    created. This ensures that the mesh remains compatible (watertight)
    as long as certain criteria are not used (triangle area limit, and
    number of triangles limit).
    
    To prevent overly large triangle meshes from being created, it is
    possible to set a limit on the number of triangles created. By
    default this number is a very large number (i.e., no limit). Further,
    a limit on the number of passes can also be set, this is mostly
    useful to generated animations of the algorithm.
    
    Finally, the attribute data (point and cell data) is treated as
    follows. The cell data from a parent triangle is assigned to its
    subdivided children.  Point data is interpolated along edges as the
    edges are subdivided.
    
    @warning
    The subdivision is linear along edges. Thus do not expect smoothing
    or blending effects to occur. If you need to smooth the resulting
    mesh use an algorithm like vtkWindowedSincPolyDataFilter or
    vtkSmoothPolyDataFilter.
    
    The filter retains mesh compatibility (watertightness) if the mesh
    was originally compatible; and the area, max triangles criteria are
    not used.
    
    @warning
    The filter requires a triangle mesh. Use vtkTriangleFilter to
    tessellate the mesh if necessary.
    
    @sa
    vtkInterpolatingSubdivisionFilter vtkLinearSubdivisionFilter
    vtkButterflySubdivisionFilter vtkTriangleFilter
    """
    def CreateDefaultLocator(self):
        """
        V.CreateDefaultLocator()
        C++: void CreateDefaultLocator()
        
        Create a default locator. Used to create one when none is
        specified.
        """
        ...
    
    def GetLocator(self):
        """
        V.GetLocator() -> vtkIncrementalPointLocator
        C++: virtual vtkIncrementalPointLocator *GetLocator()
        
        Set / get a spatial locator for merging points. By default, an
        instance of vtkMergePoints is used. This is used to merge
        coincident points during subdivision.
        """
        ...
    
    def GetMaximumEdgeLength(self):
        """
        V.GetMaximumEdgeLength() -> float
        C++: virtual double GetMaximumEdgeLength()
        
        Specify the maximum edge length that a triangle may have. Edges
        longer than this value are split in half and the associated
        triangles are modified accordingly.
        """
        ...
    
    def GetMaximumEdgeLengthMaxValue(self):
        """
        V.GetMaximumEdgeLengthMaxValue() -> float
        C++: virtual double GetMaximumEdgeLengthMaxValue()
        
        Specify the maximum edge length that a triangle may have. Edges
        longer than this value are split in half and the associated
        triangles are modified accordingly.
        """
        ...
    
    def GetMaximumEdgeLengthMinValue(self):
        """
        V.GetMaximumEdgeLengthMinValue() -> float
        C++: virtual double GetMaximumEdgeLengthMinValue()
        
        Specify the maximum edge length that a triangle may have. Edges
        longer than this value are split in half and the associated
        triangles are modified accordingly.
        """
        ...
    
    def GetMaximumNumberOfPasses(self):
        """
        V.GetMaximumNumberOfPasses() -> int
        C++: virtual vtkIdType GetMaximumNumberOfPasses()
        
        Set a limit on the number of passes (i.e., levels of
        subdivision).  If the limit is hit, then the subdivision process
        stops and additional passes (needed to meet other criteria) are
        aborted. The default limit is set to a very large number (i.e.,
        no effective limit).
        """
        ...
    
    def GetMaximumNumberOfPassesMaxValue(self):
        """
        V.GetMaximumNumberOfPassesMaxValue() -> int
        C++: virtual vtkIdType GetMaximumNumberOfPassesMaxValue()
        
        Set a limit on the number of passes (i.e., levels of
        subdivision).  If the limit is hit, then the subdivision process
        stops and additional passes (needed to meet other criteria) are
        aborted. The default limit is set to a very large number (i.e.,
        no effective limit).
        """
        ...
    
    def GetMaximumNumberOfPassesMinValue(self):
        """
        V.GetMaximumNumberOfPassesMinValue() -> int
        C++: virtual vtkIdType GetMaximumNumberOfPassesMinValue()
        
        Set a limit on the number of passes (i.e., levels of
        subdivision).  If the limit is hit, then the subdivision process
        stops and additional passes (needed to meet other criteria) are
        aborted. The default limit is set to a very large number (i.e.,
        no effective limit).
        """
        ...
    
    def GetMaximumNumberOfTriangles(self):
        """
        V.GetMaximumNumberOfTriangles() -> int
        C++: virtual vtkIdType GetMaximumNumberOfTriangles()
        
        Set a limit on the maximum number of triangles that can be
        created.  If the limit is hit, it may result in premature
        termination of the algorithm and the results may be less than
        satisfactory (for example non-watertight meshes may be created).
        By default, the limit is set to a very large number (i.e., no
        effective limit).
        """
        ...
    
    def GetMaximumNumberOfTrianglesMaxValue(self):
        """
        V.GetMaximumNumberOfTrianglesMaxValue() -> int
        C++: virtual vtkIdType GetMaximumNumberOfTrianglesMaxValue()
        
        Set a limit on the maximum number of triangles that can be
        created.  If the limit is hit, it may result in premature
        termination of the algorithm and the results may be less than
        satisfactory (for example non-watertight meshes may be created).
        By default, the limit is set to a very large number (i.e., no
        effective limit).
        """
        ...
    
    def GetMaximumNumberOfTrianglesMinValue(self):
        """
        V.GetMaximumNumberOfTrianglesMinValue() -> int
        C++: virtual vtkIdType GetMaximumNumberOfTrianglesMinValue()
        
        Set a limit on the maximum number of triangles that can be
        created.  If the limit is hit, it may result in premature
        termination of the algorithm and the results may be less than
        satisfactory (for example non-watertight meshes may be created).
        By default, the limit is set to a very large number (i.e., no
        effective limit).
        """
        ...
    
    def GetMaximumTriangleArea(self):
        """
        V.GetMaximumTriangleArea() -> float
        C++: virtual double GetMaximumTriangleArea()
        
        Specify the maximum area that a triangle may have. Triangles
        larger than this value are subdivided to meet this threshold.
        Note that if this criterion is used it may produce non-watertight
        meshes as a result.
        """
        ...
    
    def GetMaximumTriangleAreaMaxValue(self):
        """
        V.GetMaximumTriangleAreaMaxValue() -> float
        C++: virtual double GetMaximumTriangleAreaMaxValue()
        
        Specify the maximum area that a triangle may have. Triangles
        larger than this value are subdivided to meet this threshold.
        Note that if this criterion is used it may produce non-watertight
        meshes as a result.
        """
        ...
    
    def GetMaximumTriangleAreaMinValue(self):
        """
        V.GetMaximumTriangleAreaMinValue() -> float
        C++: virtual double GetMaximumTriangleAreaMinValue()
        
        Specify the maximum area that a triangle may have. Triangles
        larger than this value are subdivided to meet this threshold.
        Note that if this criterion is used it may produce non-watertight
        meshes as a result.
        """
        ...
    
    def GetMTime(self):
        """
        V.GetMTime() -> int
        C++: vtkMTimeType GetMTime() override;
        
        Modified GetMTime because of the dependence on the locator.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Standard methods for instantiation, type info, and printing.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Standard methods for instantiation, type info, and printing.
        """
        ...
    
    def GetOutputPointsPrecision(self):
        """
        V.GetOutputPointsPrecision() -> int
        C++: virtual int GetOutputPointsPrecision()
        
        Set/get the desired precision for the output types. See the
        documentation for the vtkAlgorithm::Precision enum for an
        explanation of the available precision settings.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Standard methods for instantiation, type info, and printing.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Standard methods for instantiation, type info, and printing.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkAdaptiveSubdivisionFilter
        C++: vtkAdaptiveSubdivisionFilter *NewInstance()
        
        Standard methods for instantiation, type info, and printing.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkAdaptiveSubdivisionFilter
        C++: static vtkAdaptiveSubdivisionFilter *SafeDownCast(
            vtkObjectBase *o)
        
        Standard methods for instantiation, type info, and printing.
        """
        ...
    
    def SetLocator(self, vtkIncrementalPointLocator):
        """
        V.SetLocator(vtkIncrementalPointLocator)
        C++: void SetLocator(vtkIncrementalPointLocator *locator)
        
        Set / get a spatial locator for merging points. By default, an
        instance of vtkMergePoints is used. This is used to merge
        coincident points during subdivision.
        """
        ...
    
    def SetMaximumEdgeLength(self, p_float):
        """
        V.SetMaximumEdgeLength(float)
        C++: virtual void SetMaximumEdgeLength(double _arg)
        
        Specify the maximum edge length that a triangle may have. Edges
        longer than this value are split in half and the associated
        triangles are modified accordingly.
        """
        ...
    
    def SetMaximumNumberOfPasses(self, p_int):
        """
        V.SetMaximumNumberOfPasses(int)
        C++: virtual void SetMaximumNumberOfPasses(vtkIdType _arg)
        
        Set a limit on the number of passes (i.e., levels of
        subdivision).  If the limit is hit, then the subdivision process
        stops and additional passes (needed to meet other criteria) are
        aborted. The default limit is set to a very large number (i.e.,
        no effective limit).
        """
        ...
    
    def SetMaximumNumberOfTriangles(self, p_int):
        """
        V.SetMaximumNumberOfTriangles(int)
        C++: virtual void SetMaximumNumberOfTriangles(vtkIdType _arg)
        
        Set a limit on the maximum number of triangles that can be
        created.  If the limit is hit, it may result in premature
        termination of the algorithm and the results may be less than
        satisfactory (for example non-watertight meshes may be created).
        By default, the limit is set to a very large number (i.e., no
        effective limit).
        """
        ...
    
    def SetMaximumTriangleArea(self, p_float):
        """
        V.SetMaximumTriangleArea(float)
        C++: virtual void SetMaximumTriangleArea(double _arg)
        
        Specify the maximum area that a triangle may have. Triangles
        larger than this value are subdivided to meet this threshold.
        Note that if this criterion is used it may produce non-watertight
        meshes as a result.
        """
        ...
    
    def SetOutputPointsPrecision(self, p_int):
        """
        V.SetOutputPointsPrecision(int)
        C++: virtual void SetOutputPointsPrecision(int _arg)
        
        Set/get the desired precision for the output types. See the
        documentation for the vtkAlgorithm::Precision enum for an
        explanation of the available precision settings.
        """
        ...
    
    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__ = ...


