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

import vtkmodules.vtkCommonExecutionModel as __vtkmodules_vtkCommonExecutionModel

class vtkPointInterpolator(__vtkmodules_vtkCommonExecutionModel.vtkDataSetAlgorithm):
    """
    vtkPointInterpolator - interpolate over point cloud using various
    kernels
    
    Superclass: vtkDataSetAlgorithm
    
    vtkPointInterpolator probes a point cloud Pc (the filter Source) with
    a set of points P (the filter Input), interpolating the data values
    from Pc onto P. Note however that the descriptive phrase "point
    cloud" is a misnomer: Pc can be represented by any vtkDataSet type,
    with the points of the dataset forming Pc. Similarly, the output P
    can also be represented by any vtkDataSet type; and the
    topology/geometry structure of P is passed through to the output
    along with the newly interpolated arrays.
    
    A key input to this filter is the specification of the interpolation
    kernel, and the parameters which control the associated interpolation
    process. Interpolation kernels include Voronoi, Gaussian, Shepard,
    and SPH (smoothed particle hydrodynamics), with additional kernels to
    be added in the future.
    
    An overview of the algorithm is as follows. For each p from P, Np
    "close" points to p are found. (The meaning of what is "close" can be
    specified as either the N closest points, or all points within a
    given radius Rp. This depends on how the kernel is defined.) Once the
    Np close points are found, then the interpolation kernel is applied
    to compute new data values located on p. Note that for reasonable
    performance, finding the Np closest points requires a point locator.
    The locator may be specified as input to the algorithm. (By default,
    a vtkStaticPointLocator is used because generally it is much faster
    to build, delete, and search with. However, with highly non-uniform
    point distributions, octree- or kd-tree based locators may perform
    better.)
    
    @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.
    
    @warning
    For widely spaced points in Pc, or when p is located outside the
    bounding region of Pc, the interpolation may behave badly and the
    interpolation process will adapt as necessary to produce output. For
    example, if the N closest points within R are requested to
    interpolate p, if N=0 then the interpolation will switch to a
    different strategy (which can be controlled as in the
    NullPointsStrategy).
    
    @sa
    vtkPointInterpolator2D vtkProbeFilter vtkGaussianSplatter
    vtkCheckerboardSplatter vtkShepardMethod vtkVoronoiKernel
    vtkShepardKernel vtkGaussianKernel vtkSPHKernel
    """
    def AddExcludedArray(self, string):
        """
        V.AddExcludedArray(string)
        C++: void AddExcludedArray(const vtkStdString &excludedArray)
        
        Adds an array to the list of arrays which are to be excluded from
        the interpolation process.
        """
        ...
    
    def ClearExcludedArrays(self):
        """
        V.ClearExcludedArrays()
        C++: void ClearExcludedArrays()
        
        Clears the contents of excluded array list.
        """
        ...
    
    def GetExcludedArray(self, p_int):
        """
        V.GetExcludedArray(int) -> string
        C++: const char *GetExcludedArray(int i)
        
        Return the name of the ith excluded array.
        """
        ...
    
    def GetKernel(self):
        """
        V.GetKernel() -> vtkInterpolationKernel
        C++: virtual vtkInterpolationKernel *GetKernel()
        
        Specify an interpolation kernel. By default a vtkLinearKernel is
        used (i.e., linear combination of closest points). The
        interpolation kernel changes the basis of the interpolation.
        """
        ...
    
    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 near a
        specified interpolation position.
        """
        ...
    
    def GetMTime(self):
        """
        V.GetMTime() -> int
        C++: vtkMTimeType GetMTime() override;
        
        Get the MTime of this object also considering the locator and
        kernel.
        """
        ...
    
    def GetNullPointsStrategy(self):
        """
        V.GetNullPointsStrategy() -> int
        C++: virtual int GetNullPointsStrategy()
        
        Specify a strategy to use when encountering a "null" point during
        the interpolation process. Null points occur when the local
        neighborhood (of nearby points to interpolate from) is empty. If
        the strategy is set to MaskPoints, then an output array is
        created that marks points as being valid (=1) or null (invalid
        =0) (and the NullValue is set as well). If the strategy is set to
        NullValue (this is the default), then the output data value(s)
        are set to the NullPoint value (specified in the output point
        data). Finally, the strategy ClosestPoint is to simply use the
        closest point to perform the interpolation.
        """
        ...
    
    def GetNullValue(self):
        """
        V.GetNullValue() -> float
        C++: virtual double GetNullValue()
        
        Specify the null point value. When a null point is encountered
        then all components of each null tuple are set to this value. By
        default the null value is set to zero.
        """
        ...
    
    def GetNumberOfExcludedArrays(self):
        """
        V.GetNumberOfExcludedArrays() -> int
        C++: int GetNumberOfExcludedArrays()
        
        Return the number of excluded arrays.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Standard methods for instantiating, obtaining type information,
        and printing.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Standard methods for instantiating, obtaining type information,
        and printing.
        """
        ...
    
    def GetPassCellArrays(self):
        """
        V.GetPassCellArrays() -> bool
        C++: virtual bool GetPassCellArrays()
        
        Indicate whether to shallow copy the input cell data arrays to
        the output.  On by default.
        """
        ...
    
    def GetPassFieldArrays(self):
        """
        V.GetPassFieldArrays() -> bool
        C++: virtual bool GetPassFieldArrays()
        
        Indicate whether to pass the field-data arrays from the input to
        the output. On by default.
        """
        ...
    
    def GetPassPointArrays(self):
        """
        V.GetPassPointArrays() -> bool
        C++: virtual bool GetPassPointArrays()
        
        Indicate whether to shallow copy the input point data arrays to
        the output.  On by default.
        """
        ...
    
    def GetPromoteOutputArrays(self):
        """
        V.GetPromoteOutputArrays() -> bool
        C++: virtual bool GetPromoteOutputArrays()
        
        If enabled, then input arrays that are non-real types (i.e., not
        float or double) are promoted to float type on output. This is
        because the interpolation process may not be well behaved when
        integral types are combined using interpolation weights.
        """
        ...
    
    def GetSource(self):
        """
        V.GetSource() -> vtkDataObject
        C++: vtkDataObject *GetSource()
        
        Specify the dataset Pc that will be probed by the input points P.
         The Input P defines the dataset structure (the points and cells)
        for the output, while the Source Pc is probed (interpolated) to
        generate the scalars, vectors, etc. for the output points based
        on the point locations.
        """
        ...
    
    def GetValidPointsMaskArrayName(self):
        """
        V.GetValidPointsMaskArrayName() -> string
        C++: virtual vtkStdString GetValidPointsMaskArrayName()
        
        If the NullPointsStrategy == MASK_POINTS, then an array is
        generated for each input point. This vtkCharArray is placed into
        the output of the filter, with a non-zero value for a valid
        point, and zero otherwise. The name of this masking array is
        specified here.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Standard methods for instantiating, obtaining type information,
        and printing.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Standard methods for instantiating, obtaining type information,
        and printing.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkPointInterpolator
        C++: vtkPointInterpolator *NewInstance()
        
        Standard methods for instantiating, obtaining type information,
        and printing.
        """
        ...
    
    def PassCellArraysOff(self):
        """
        V.PassCellArraysOff()
        C++: virtual void PassCellArraysOff()
        
        Indicate whether to shallow copy the input cell data arrays to
        the output.  On by default.
        """
        ...
    
    def PassCellArraysOn(self):
        """
        V.PassCellArraysOn()
        C++: virtual void PassCellArraysOn()
        
        Indicate whether to shallow copy the input cell data arrays to
        the output.  On by default.
        """
        ...
    
    def PassFieldArraysOff(self):
        """
        V.PassFieldArraysOff()
        C++: virtual void PassFieldArraysOff()
        
        Indicate whether to pass the field-data arrays from the input to
        the output. On by default.
        """
        ...
    
    def PassFieldArraysOn(self):
        """
        V.PassFieldArraysOn()
        C++: virtual void PassFieldArraysOn()
        
        Indicate whether to pass the field-data arrays from the input to
        the output. On by default.
        """
        ...
    
    def PassPointArraysOff(self):
        """
        V.PassPointArraysOff()
        C++: virtual void PassPointArraysOff()
        
        Indicate whether to shallow copy the input point data arrays to
        the output.  On by default.
        """
        ...
    
    def PassPointArraysOn(self):
        """
        V.PassPointArraysOn()
        C++: virtual void PassPointArraysOn()
        
        Indicate whether to shallow copy the input point data arrays to
        the output.  On by default.
        """
        ...
    
    def PromoteOutputArraysOff(self):
        """
        V.PromoteOutputArraysOff()
        C++: virtual void PromoteOutputArraysOff()
        
        If enabled, then input arrays that are non-real types (i.e., not
        float or double) are promoted to float type on output. This is
        because the interpolation process may not be well behaved when
        integral types are combined using interpolation weights.
        """
        ...
    
    def PromoteOutputArraysOn(self):
        """
        V.PromoteOutputArraysOn()
        C++: virtual void PromoteOutputArraysOn()
        
        If enabled, then input arrays that are non-real types (i.e., not
        float or double) are promoted to float type on output. This is
        because the interpolation process may not be well behaved when
        integral types are combined using interpolation weights.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkPointInterpolator
        C++: static vtkPointInterpolator *SafeDownCast(vtkObjectBase *o)
        
        Standard methods for instantiating, obtaining type information,
        and printing.
        """
        ...
    
    def SetKernel(self, vtkInterpolationKernel):
        """
        V.SetKernel(vtkInterpolationKernel)
        C++: void SetKernel(vtkInterpolationKernel *kernel)
        
        Specify an interpolation kernel. By default a vtkLinearKernel is
        used (i.e., linear combination of closest points). The
        interpolation kernel changes the basis of the interpolation.
        """
        ...
    
    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 near a
        specified interpolation position.
        """
        ...
    
    def SetNullPointsStrategy(self, p_int):
        """
        V.SetNullPointsStrategy(int)
        C++: virtual void SetNullPointsStrategy(int _arg)
        
        Specify a strategy to use when encountering a "null" point during
        the interpolation process. Null points occur when the local
        neighborhood (of nearby points to interpolate from) is empty. If
        the strategy is set to MaskPoints, then an output array is
        created that marks points as being valid (=1) or null (invalid
        =0) (and the NullValue is set as well). If the strategy is set to
        NullValue (this is the default), then the output data value(s)
        are set to the NullPoint value (specified in the output point
        data). Finally, the strategy ClosestPoint is to simply use the
        closest point to perform the interpolation.
        """
        ...
    
    def SetNullPointsStrategyToClosestPoint(self):
        """
        V.SetNullPointsStrategyToClosestPoint()
        C++: void SetNullPointsStrategyToClosestPoint()
        
        Specify a strategy to use when encountering a "null" point during
        the interpolation process. Null points occur when the local
        neighborhood (of nearby points to interpolate from) is empty. If
        the strategy is set to MaskPoints, then an output array is
        created that marks points as being valid (=1) or null (invalid
        =0) (and the NullValue is set as well). If the strategy is set to
        NullValue (this is the default), then the output data value(s)
        are set to the NullPoint value (specified in the output point
        data). Finally, the strategy ClosestPoint is to simply use the
        closest point to perform the interpolation.
        """
        ...
    
    def SetNullPointsStrategyToMaskPoints(self):
        """
        V.SetNullPointsStrategyToMaskPoints()
        C++: void SetNullPointsStrategyToMaskPoints()
        
        Specify a strategy to use when encountering a "null" point during
        the interpolation process. Null points occur when the local
        neighborhood (of nearby points to interpolate from) is empty. If
        the strategy is set to MaskPoints, then an output array is
        created that marks points as being valid (=1) or null (invalid
        =0) (and the NullValue is set as well). If the strategy is set to
        NullValue (this is the default), then the output data value(s)
        are set to the NullPoint value (specified in the output point
        data). Finally, the strategy ClosestPoint is to simply use the
        closest point to perform the interpolation.
        """
        ...
    
    def SetNullPointsStrategyToNullValue(self):
        """
        V.SetNullPointsStrategyToNullValue()
        C++: void SetNullPointsStrategyToNullValue()
        
        Specify a strategy to use when encountering a "null" point during
        the interpolation process. Null points occur when the local
        neighborhood (of nearby points to interpolate from) is empty. If
        the strategy is set to MaskPoints, then an output array is
        created that marks points as being valid (=1) or null (invalid
        =0) (and the NullValue is set as well). If the strategy is set to
        NullValue (this is the default), then the output data value(s)
        are set to the NullPoint value (specified in the output point
        data). Finally, the strategy ClosestPoint is to simply use the
        closest point to perform the interpolation.
        """
        ...
    
    def SetNullValue(self, p_float):
        """
        V.SetNullValue(float)
        C++: virtual void SetNullValue(double _arg)
        
        Specify the null point value. When a null point is encountered
        then all components of each null tuple are set to this value. By
        default the null value is set to zero.
        """
        ...
    
    def SetPassCellArrays(self, bool):
        """
        V.SetPassCellArrays(bool)
        C++: virtual void SetPassCellArrays(bool _arg)
        
        Indicate whether to shallow copy the input cell data arrays to
        the output.  On by default.
        """
        ...
    
    def SetPassFieldArrays(self, bool):
        """
        V.SetPassFieldArrays(bool)
        C++: virtual void SetPassFieldArrays(bool _arg)
        
        Indicate whether to pass the field-data arrays from the input to
        the output. On by default.
        """
        ...
    
    def SetPassPointArrays(self, bool):
        """
        V.SetPassPointArrays(bool)
        C++: virtual void SetPassPointArrays(bool _arg)
        
        Indicate whether to shallow copy the input point data arrays to
        the output.  On by default.
        """
        ...
    
    def SetPromoteOutputArrays(self, bool):
        """
        V.SetPromoteOutputArrays(bool)
        C++: virtual void SetPromoteOutputArrays(bool _arg)
        
        If enabled, then input arrays that are non-real types (i.e., not
        float or double) are promoted to float type on output. This is
        because the interpolation process may not be well behaved when
        integral types are combined using interpolation weights.
        """
        ...
    
    def SetSourceConnection(self, vtkAlgorithmOutput):
        """
        V.SetSourceConnection(vtkAlgorithmOutput)
        C++: void SetSourceConnection(vtkAlgorithmOutput *algOutput)
        
        Specify the dataset Pc that will be probed by the input points P.
         The Input P defines the structure (the points and cells) for the
        output, while the Source Pc is probed (interpolated) to generate
        the scalars, vectors, etc. for the output points based on the
        point locations.
        """
        ...
    
    def SetSourceData(self, vtkDataObject):
        """
        V.SetSourceData(vtkDataObject)
        C++: void SetSourceData(vtkDataObject *source)
        
        Specify the dataset Pc that will be probed by the input points P.
         The Input P defines the dataset structure (the points and cells)
        for the output, while the Source Pc is probed (interpolated) to
        generate the scalars, vectors, etc. for the output points based
        on the point locations.
        """
        ...
    
    def SetValidPointsMaskArrayName(self, string):
        """
        V.SetValidPointsMaskArrayName(string)
        C++: virtual void SetValidPointsMaskArrayName(vtkStdString _arg)
        
        If the NullPointsStrategy == MASK_POINTS, then an array is
        generated for each input point. This vtkCharArray is placed into
        the output of the filter, with a non-zero value for a valid
        point, and zero otherwise. The name of this masking array is
        specified here.
        """
        ...
    
    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__ = ...
    CLOSEST_POINT = ...
    MASK_POINTS = ...
    NULL_VALUE = ...
    Strategy = ...
    __dict__ = ...
    __vtkname__ = ...


