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

import vtkmodules.vtkCommonExecutionModel as __vtkmodules_vtkCommonExecutionModel

class vtkPCACurvatureEstimation(__vtkmodules_vtkCommonExecutionModel.vtkPolyDataAlgorithm):
    """
    vtkPCACurvatureEstimation - generate curvature estimates using
    principal component analysis
    
    Superclass: vtkPolyDataAlgorithm
    
    vtkPCACurvatureEstimation generates point normals using PCA
    (principal component analysis).  Basically this estimates a local
    tangent plane around sample point p by considering a small
    neighborhood of points around p, and fitting a plane to the
    neighborhood (via PCA). A good introductory reference is Hoppe's
    "Surface reconstruction from unorganized points."
    
    To use this filter, specify a neighborhood size. This may have to be
    set via experimentation. Optionally a point locator can be specified
    (instead of the default locator), which is used to accelerate
    searches around a sample point. Finally, the user should specify how
    to generate consistently-oriented normals. As computed by PCA,
    normals may point in +/- orientation, which may not be consistent
    with neighboring normals.
    
    The output of this filter is the same as the input except that a
    normal per point is produced. (Note that these are unit normals.)
    While any vtkPointSet type can be provided as input, the output is
    represented by an explicit representation of points via a
    vtkPolyData. This output polydata will populate its instance of
    vtkPoints, but no cells will be defined (i.e., no vtkVertex or
    vtkPolyVertex are contained in the output).
    
    @warning
    This class has been threaded with vtkSMPTools. Using TBB or other
    non-sequential type (set in the CMake variable
    VTK_SMP_IMPLEMENTATION_TYPE) may improve performance significantly.
    
    @sa
    vtkPCANormalEstimation
    """
    def GetLocator(self):
        """
        V.GetLocator() -> vtkAbstractPointLocator
        C++: virtual vtkAbstractPointLocator *GetLocator()
        
        Specify a point locator. By default a vtkStaticPointLocator is
        used. The locator performs efficient searches to locate points
        around a sample point.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Standard methods for instantiating, obtaining type information,
        and printing information.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Standard methods for instantiating, obtaining type information,
        and printing information.
        """
        ...
    
    def GetSampleSize(self):
        """
        V.GetSampleSize() -> int
        C++: virtual int GetSampleSize()
        
        For each sampled point, specify the number of the closest,
        surrounding points used to estimate the normal (the so called
        k-neighborhood). By default 25 points are used. Smaller numbers
        may speed performance at the cost of accuracy.
        """
        ...
    
    def GetSampleSizeMaxValue(self):
        """
        V.GetSampleSizeMaxValue() -> int
        C++: virtual int GetSampleSizeMaxValue()
        
        For each sampled point, specify the number of the closest,
        surrounding points used to estimate the normal (the so called
        k-neighborhood). By default 25 points are used. Smaller numbers
        may speed performance at the cost of accuracy.
        """
        ...
    
    def GetSampleSizeMinValue(self):
        """
        V.GetSampleSizeMinValue() -> int
        C++: virtual int GetSampleSizeMinValue()
        
        For each sampled point, specify the number of the closest,
        surrounding points used to estimate the normal (the so called
        k-neighborhood). By default 25 points are used. Smaller numbers
        may speed performance at the cost of accuracy.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Standard methods for instantiating, obtaining type information,
        and printing information.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Standard methods for instantiating, obtaining type information,
        and printing information.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkPCACurvatureEstimation
        C++: vtkPCACurvatureEstimation *NewInstance()
        
        Standard methods for instantiating, obtaining type information,
        and printing information.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkPCACurvatureEstimation
        C++: static vtkPCACurvatureEstimation *SafeDownCast(
            vtkObjectBase *o)
        
        Standard methods for instantiating, obtaining type information,
        and printing information.
        """
        ...
    
    def SetLocator(self, vtkAbstractPointLocator):
        """
        V.SetLocator(vtkAbstractPointLocator)
        C++: void SetLocator(vtkAbstractPointLocator *locator)
        
        Specify a point locator. By default a vtkStaticPointLocator is
        used. The locator performs efficient searches to locate points
        around a sample point.
        """
        ...
    
    def SetSampleSize(self, p_int):
        """
        V.SetSampleSize(int)
        C++: virtual void SetSampleSize(int _arg)
        
        For each sampled point, specify the number of the closest,
        surrounding points used to estimate the normal (the so called
        k-neighborhood). By default 25 points are used. Smaller numbers
        may speed performance at the cost of accuracy.
        """
        ...
    
    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__ = ...


