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

import vtkmodules.vtkCommonExecutionModel as __vtkmodules_vtkCommonExecutionModel

class vtkDeformPointSet(__vtkmodules_vtkCommonExecutionModel.vtkPointSetAlgorithm):
    """
    vtkDeformPointSet - use a control polyhedron to deform an input
    vtkPointSet
    
    Superclass: vtkPointSetAlgorithm
    
    vtkDeformPointSet is a filter that uses a control polyhdron to deform
    an input dataset of type vtkPointSet. The control polyhedron (or
    mesh) must be a closed, manifold surface.
    
    The filter executes as follows. In initial pipeline execution, the
    control mesh and input vtkPointSet are assumed in undeformed
    position, and an initial set of interpolation weights are computed
    for each point in the vtkPointSet (one interpolation weight value for
    each point in the control mesh). The filter then stores these
    interpolation weights after filter execution. The next time the
    filter executes, assuming that the number of points/cells in the
    control mesh and vtkPointSet have not changed, the points in the
    vtkPointSet are recomputed based on the original weights. Hence if
    the control mesh has been deformed, it will in turn cause deformation
    in the vtkPointSet. This can be used to animate or edit the geometry
    of the vtkPointSet.
    
    @warning
    Note that a set of interpolation weights per point in the vtkPointSet
    is maintained. The number of interpolation weights is the number of
    points in the control mesh. Hence keep the control mesh small in size
    or a n^2 data explostion will occur.
    
    @warning
    The filter maintains interpolation weights between executions (after
    the initial execution pass computes the interpolation weights). You
    can explicitly cause the filter to reinitialize by setting the
    InitializeWeights boolean to true. By default, the filter will
    execute and then set InitializeWeights to false.
    
    @warning
    This work was motivated by the work of Tao Ju et al in "Mesh Value
    Coordinates for Closed Triangular Meshes." The MVC algorithm is
    currently used to generate interpolation weights. However, in the
    future this filter may be extended to provide other interpolation
    functions.
    
    @warning
    A final note: point data and cell data are passed from the input to
    the output. Only the point coordinates of the input vtkPointSet are
    modified.
    
    @sa
    vtkMeanValueCoordinatesInterpolator vtkProbePolyhedron vtkPolyhedron
    """
    def GetControlMeshData(self):
        """
        V.GetControlMeshData() -> vtkPolyData
        C++: vtkPolyData *GetControlMeshData()
        
        Specify the control mesh to deform the input vtkPointSet. The
        control mesh must be a closed, non-self-intersecting, manifold
        mesh.
        """
        ...
    
    def GetInitializeWeights(self):
        """
        V.GetInitializeWeights() -> int
        C++: virtual vtkTypeBool GetInitializeWeights()
        
        Specify whether to regenerate interpolation weights or not.
        Initially the filter will reexecute no matter what this flag is
        set to (initial weights must be computed). Also, this flag is
        ignored if the number of input points/cells or the number of
        control mesh points/cells changes between executions. Thus flag
        is used to force reexecution and recomputation of weights.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Standard methods for instantiable (i.e., concrete) class.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Standard methods for instantiable (i.e., concrete) class.
        """
        ...
    
    def InitializeWeightsOff(self):
        """
        V.InitializeWeightsOff()
        C++: virtual void InitializeWeightsOff()
        
        Specify whether to regenerate interpolation weights or not.
        Initially the filter will reexecute no matter what this flag is
        set to (initial weights must be computed). Also, this flag is
        ignored if the number of input points/cells or the number of
        control mesh points/cells changes between executions. Thus flag
        is used to force reexecution and recomputation of weights.
        """
        ...
    
    def InitializeWeightsOn(self):
        """
        V.InitializeWeightsOn()
        C++: virtual void InitializeWeightsOn()
        
        Specify whether to regenerate interpolation weights or not.
        Initially the filter will reexecute no matter what this flag is
        set to (initial weights must be computed). Also, this flag is
        ignored if the number of input points/cells or the number of
        control mesh points/cells changes between executions. Thus flag
        is used to force reexecution and recomputation of weights.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Standard methods for instantiable (i.e., concrete) class.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Standard methods for instantiable (i.e., concrete) class.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkDeformPointSet
        C++: vtkDeformPointSet *NewInstance()
        
        Standard methods for instantiable (i.e., concrete) class.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkDeformPointSet
        C++: static vtkDeformPointSet *SafeDownCast(vtkObjectBase *o)
        
        Standard methods for instantiable (i.e., concrete) class.
        """
        ...
    
    def SetControlMeshConnection(self, vtkAlgorithmOutput):
        """
        V.SetControlMeshConnection(vtkAlgorithmOutput)
        C++: void SetControlMeshConnection(vtkAlgorithmOutput *algOutput)
        
        Specify the point locations used to probe input. Any geometry can
        be used. New style. Equivalent to SetInputConnection(1,
        algOutput).
        """
        ...
    
    def SetControlMeshData(self, vtkPolyData):
        """
        V.SetControlMeshData(vtkPolyData)
        C++: void SetControlMeshData(vtkPolyData *controlMesh)
        
        Specify the control mesh to deform the input vtkPointSet. The
        control mesh must be a closed, non-self-intersecting, manifold
        mesh.
        """
        ...
    
    def SetInitializeWeights(self, p_int):
        """
        V.SetInitializeWeights(int)
        C++: virtual void SetInitializeWeights(vtkTypeBool _arg)
        
        Specify whether to regenerate interpolation weights or not.
        Initially the filter will reexecute no matter what this flag is
        set to (initial weights must be computed). Also, this flag is
        ignored if the number of input points/cells or the number of
        control mesh points/cells changes between executions. Thus flag
        is used to force reexecution and recomputation of weights.
        """
        ...
    
    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__ = ...


