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

import vtkmodules.vtkCommonExecutionModel as __vtkmodules_vtkCommonExecutionModel

class vtkPCANormalEstimation(__vtkmodules_vtkCommonExecutionModel.vtkPolyDataAlgorithm):
    """
    vtkPCANormalEstimation - generate point normals using local tangent
    planes
    
    Superclass: vtkPolyDataAlgorithm
    
    vtkPCANormalEstimation generates point normals using PCA (principal
    component analysis).  Basically this estimates a local tangent plane
    around each 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. In addition, the user may optionally specify
    a point locator (instead of the default locator), which is used to
    accelerate searches around the sample point. Finally, the user should
    specify how to generate consistently-oriented normals. As computed by
    PCA, normals may point in arbitrary +/- orientation, which may not be
    consistent with neighboring normals. There are three methods to
    address normal consistency: 1) leave the normals as computed, 2)
    adjust the +/- sign of the normals so that the normals all point
    towards a specified point, and
    3) perform a traversal of the point cloud and flip neighboring
       normals so that they are mutually consistent.
    
    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
    vtkPCACurvatureEstimation
    """
    def FlipNormalsOff(self):
        """
        V.FlipNormalsOff()
        C++: virtual void FlipNormalsOff()
        
        The normal orientation can be flipped by enabling this flag.
        """
        ...
    
    def FlipNormalsOn(self):
        """
        V.FlipNormalsOn()
        C++: virtual void FlipNormalsOn()
        
        The normal orientation can be flipped by enabling this flag.
        """
        ...
    
    def GetFlipNormals(self):
        """
        V.GetFlipNormals() -> bool
        C++: virtual bool GetFlipNormals()
        
        The normal orientation can be flipped by enabling this flag.
        """
        ...
    
    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 GetNormalOrientation(self):
        """
        V.GetNormalOrientation() -> int
        C++: virtual int GetNormalOrientation()
        
        Configure how the filter addresses consistency in normal
        oreientation. When initially computed using PCA, a point normal
        may point in the + or - direction, which may not be consistent
        with neighboring points. To address this, various strategies have
        been used to create consistent normals. The simplest approach is
        to do nothing (AsComputed). Another simple approach is to flip
        the normal based on its direction with respect to a specified
        point (i.e., point normals will point towrads the specified
        point). Finally, a full traversal of points across the graph of
        neighboring, connected points produces the best results but is
        computationally expensive.
        """
        ...
    
    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 GetOrientationPoint(self):
        """
        V.GetOrientationPoint() -> (float, float, float)
        C++: virtual double *GetOrientationPoint()
        
        If the normal orientation is to be consistent with a specified
        direction, then an orientation point should be set. The sign of
        the normals will be modified so that they point towards this
        point. By default, the specified orientation point is (0,0,0).
        """
        ...
    
    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() -> vtkPCANormalEstimation
        C++: vtkPCANormalEstimation *NewInstance()
        
        Standard methods for instantiating, obtaining type information,
        and printing information.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkPCANormalEstimation
        C++: static vtkPCANormalEstimation *SafeDownCast(vtkObjectBase *o)
        
        Standard methods for instantiating, obtaining type information,
        and printing information.
        """
        ...
    
    def SetFlipNormals(self, bool):
        """
        V.SetFlipNormals(bool)
        C++: virtual void SetFlipNormals(bool _arg)
        
        The normal orientation can be flipped by enabling this flag.
        """
        ...
    
    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 SetNormalOrientation(self, p_int):
        """
        V.SetNormalOrientation(int)
        C++: virtual void SetNormalOrientation(int _arg)
        
        Configure how the filter addresses consistency in normal
        oreientation. When initially computed using PCA, a point normal
        may point in the + or - direction, which may not be consistent
        with neighboring points. To address this, various strategies have
        been used to create consistent normals. The simplest approach is
        to do nothing (AsComputed). Another simple approach is to flip
        the normal based on its direction with respect to a specified
        point (i.e., point normals will point towrads the specified
        point). Finally, a full traversal of points across the graph of
        neighboring, connected points produces the best results but is
        computationally expensive.
        """
        ...
    
    def SetNormalOrientationToAsComputed(self):
        """
        V.SetNormalOrientationToAsComputed()
        C++: void SetNormalOrientationToAsComputed()
        
        Configure how the filter addresses consistency in normal
        oreientation. When initially computed using PCA, a point normal
        may point in the + or - direction, which may not be consistent
        with neighboring points. To address this, various strategies have
        been used to create consistent normals. The simplest approach is
        to do nothing (AsComputed). Another simple approach is to flip
        the normal based on its direction with respect to a specified
        point (i.e., point normals will point towrads the specified
        point). Finally, a full traversal of points across the graph of
        neighboring, connected points produces the best results but is
        computationally expensive.
        """
        ...
    
    def SetNormalOrientationToGraphTraversal(self):
        """
        V.SetNormalOrientationToGraphTraversal()
        C++: void SetNormalOrientationToGraphTraversal()
        
        Configure how the filter addresses consistency in normal
        oreientation. When initially computed using PCA, a point normal
        may point in the + or - direction, which may not be consistent
        with neighboring points. To address this, various strategies have
        been used to create consistent normals. The simplest approach is
        to do nothing (AsComputed). Another simple approach is to flip
        the normal based on its direction with respect to a specified
        point (i.e., point normals will point towrads the specified
        point). Finally, a full traversal of points across the graph of
        neighboring, connected points produces the best results but is
        computationally expensive.
        """
        ...
    
    def SetNormalOrientationToPoint(self):
        """
        V.SetNormalOrientationToPoint()
        C++: void SetNormalOrientationToPoint()
        
        Configure how the filter addresses consistency in normal
        oreientation. When initially computed using PCA, a point normal
        may point in the + or - direction, which may not be consistent
        with neighboring points. To address this, various strategies have
        been used to create consistent normals. The simplest approach is
        to do nothing (AsComputed). Another simple approach is to flip
        the normal based on its direction with respect to a specified
        point (i.e., point normals will point towrads the specified
        point). Finally, a full traversal of points across the graph of
        neighboring, connected points produces the best results but is
        computationally expensive.
        """
        ...
    
    def SetOrientationPoint(self, p_float, p_float_1, p_float_2):
        """
        V.SetOrientationPoint(float, float, float)
        C++: virtual void SetOrientationPoint(double _arg1, double _arg2,
            double _arg3)
        V.SetOrientationPoint((float, float, float))
        C++: virtual void SetOrientationPoint(const double _arg[3])
        
        If the normal orientation is to be consistent with a specified
        direction, then an orientation point should be set. The sign of
        the normals will be modified so that they point towards this
        point. By default, the specified orientation point is (0,0,0).
        """
        ...
    
    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__ = ...
    AS_COMPUTED = ...
    GRAPH_TRAVERSAL = ...
    POINT = ...
    Style = ...
    __dict__ = ...
    __vtkname__ = ...


