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

import vtkmodules.vtkCommonExecutionModel as __vtkmodules_vtkCommonExecutionModel

class vtk3DLinearGridCrinkleExtractor(__vtkmodules_vtkCommonExecutionModel.vtkDataObjectAlgorithm):
    """
    vtk3DLinearGridCrinkleExtractor - fast extraction of cells
    intersected by a plane
    
    Superclass: vtkDataObjectAlgorithm
    
    vtk3DLinearGridCrinkleExtractor is a specialized filter that, given a
    specified implicit function, extracts unstructured grid cells that
    intersect the implicit function. (Since the surface of these cells
    roughly follows the implicit function but is "bumpy", it is referred
    to as a "crinkle" suface.) This filter operates on
    vtkUnstructuredGrids consisting of 3D linear cells: tetrahedra,
    hexahedra, voxels, pyramids, and/or wedges. (The cells are linear in
    the sense that each cell edge is a straight line.)  The filter is
    designed for high-speed, specialized operation. All other cell types
    are skipped and produce no output.
    
    To use this filter you must specify an input unstructured grid or
    vtkCompositeDataSet (containing unstructured grids) and an implicit
    function to cut with.
    
    The RemoveUnusedPoints data member controls whether the filter remaps
    the input points to the output. Since the algorithm simply extracts a
    subset of the original data (points and cells), it is possible simply
    to pass the input points to the output, which is much faster (factor
    of ~2X) then mapping the input points to the output. Of course, not
    removing the unused points means extra points in the output dataset,
    but because the input points are shallow copied to the output, no
    additional memory is consumed.
    
    @warning
    When the input is of type vtkCompositeDataSet the filter will process
    the unstructured grid(s) contained in the composite data set. As a
    result the output of this filter is then a vtkMultiBlockDataSet
    containing multiple vtkUnstructuredGrids. When a vtkUnstructuredGrid
    is provided as input the output is a single vtkUnstructuredGrid.
    
    @warning
    Input cells that are not of 3D linear type (tetrahedron, hexahedron,
    wedge, pyramid, and voxel) are simply skipped and not processed.
    
    @warning
    The filter is templated on types of input and output points, and
    input scalar type. To reduce object file bloat, only real points
    (float,double) are processed.
    
    @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
    The vtkExtractGeometry filter is similar to this filter when
    ExtractOnlyBoundaryCells is enabled.
    
    @sa
    vtk3DLinearGrid vtk3DLinearGridPlaneCutter vtkExtractGeometry
    """
    def CanFullyProcessDataObject(self, vtkDataObject):
        """
        V.CanFullyProcessDataObject(vtkDataObject) -> bool
        C++: static bool CanFullyProcessDataObject(vtkDataObject *object)
        
        Returns true if the data object passed in is fully supported by
        this filter, i.e., all cell types are linear. For composite
        datasets, this means all dataset leaves have only linear cell
        types that can be processed by this filter.
        """
        ...
    
    def CopyCellDataOff(self):
        """
        V.CopyCellDataOff()
        C++: virtual void CopyCellDataOff()
        
        Indicate whether to copy input cell data/attributes onto the
        output cells. By default this option is off.
        """
        ...
    
    def CopyCellDataOn(self):
        """
        V.CopyCellDataOn()
        C++: virtual void CopyCellDataOn()
        
        Indicate whether to copy input cell data/attributes onto the
        output cells. By default this option is off.
        """
        ...
    
    def CopyPointDataOff(self):
        """
        V.CopyPointDataOff()
        C++: virtual void CopyPointDataOff()
        
        Indicate whether to copy input point data/attributes onto the
        output points. By default this option is on.
        """
        ...
    
    def CopyPointDataOn(self):
        """
        V.CopyPointDataOn()
        C++: virtual void CopyPointDataOn()
        
        Indicate whether to copy input point data/attributes onto the
        output points. By default this option is on.
        """
        ...
    
    def GetCopyCellData(self):
        """
        V.GetCopyCellData() -> bool
        C++: virtual bool GetCopyCellData()
        
        Indicate whether to copy input cell data/attributes onto the
        output cells. By default this option is off.
        """
        ...
    
    def GetCopyPointData(self):
        """
        V.GetCopyPointData() -> bool
        C++: virtual bool GetCopyPointData()
        
        Indicate whether to copy input point data/attributes onto the
        output points. By default this option is on.
        """
        ...
    
    def GetImplicitFunction(self):
        """
        V.GetImplicitFunction() -> vtkImplicitFunction
        C++: virtual vtkImplicitFunction *GetImplicitFunction()
        
        Specify the implicit function which is used to select the output
        cell faces. Note that the implicit function invocation must be
        thread safe. Also, there is a fast path for vtkPlane implicit
        functions.
        """
        ...
    
    def GetMTime(self):
        """
        V.GetMTime() -> int
        C++: vtkMTimeType GetMTime() override;
        
        Overloaded GetMTime() because of delegation to the helper
        vtkImplicitFunction.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Standard methods for construction, type info, and printing.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Standard methods for construction, type info, and printing.
        """
        ...
    
    def GetNumberOfThreadsUsed(self):
        """
        V.GetNumberOfThreadsUsed() -> int
        C++: int GetNumberOfThreadsUsed()
        
        Return the number of threads actually used during execution. This
        is valid only after algorithm execution.
        """
        ...
    
    def GetOutputPointsPrecision(self):
        """
        V.GetOutputPointsPrecision() -> int
        C++: int GetOutputPointsPrecision()
        
        Set/get the desired precision for the output points. See the
        documentation for the vtkAlgorithm::Precision enum for an
        explanation of the available precision settings.
        """
        ...
    
    def GetRemoveUnusedPoints(self):
        """
        V.GetRemoveUnusedPoints() -> bool
        C++: virtual bool GetRemoveUnusedPoints()
        
        Indicate whether to eliminate unused output points. When this
        flag is disabled, the input points and associated point data are
        simply shallow copied to the output (which improves performance).
         When enabled, any points that are not used by the output cells
        are not sent to the output, nor is associated point data copied.
        By default this option is disabled. Removing unused points does
        have a significant performance impact.
        """
        ...
    
    def GetSequentialProcessing(self):
        """
        V.GetSequentialProcessing() -> bool
        C++: virtual bool GetSequentialProcessing()
        
        Force sequential processing (i.e. single thread) of the crinkle
        cut process. By default, sequential processing is off. Note this
        flag only applies if the class has been compiled with
        VTK_SMP_IMPLEMENTATION_TYPE set to something other than
        Sequential. (If set to Sequential, then the filter always runs in
        serial mode.) This flag is typically used for benchmarking
        purposes.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Standard methods for construction, type info, and printing.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Standard methods for construction, type info, and printing.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtk3DLinearGridCrinkleExtractor
        C++: vtk3DLinearGridCrinkleExtractor *NewInstance()
        
        Standard methods for construction, type info, and printing.
        """
        ...
    
    def RemoveUnusedPointsOff(self):
        """
        V.RemoveUnusedPointsOff()
        C++: virtual void RemoveUnusedPointsOff()
        
        Indicate whether to eliminate unused output points. When this
        flag is disabled, the input points and associated point data are
        simply shallow copied to the output (which improves performance).
         When enabled, any points that are not used by the output cells
        are not sent to the output, nor is associated point data copied.
        By default this option is disabled. Removing unused points does
        have a significant performance impact.
        """
        ...
    
    def RemoveUnusedPointsOn(self):
        """
        V.RemoveUnusedPointsOn()
        C++: virtual void RemoveUnusedPointsOn()
        
        Indicate whether to eliminate unused output points. When this
        flag is disabled, the input points and associated point data are
        simply shallow copied to the output (which improves performance).
         When enabled, any points that are not used by the output cells
        are not sent to the output, nor is associated point data copied.
        By default this option is disabled. Removing unused points does
        have a significant performance impact.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtk3DLinearGridCrinkleExtractor
        C++: static vtk3DLinearGridCrinkleExtractor *SafeDownCast(
            vtkObjectBase *o)
        
        Standard methods for construction, type info, and printing.
        """
        ...
    
    def SequentialProcessingOff(self):
        """
        V.SequentialProcessingOff()
        C++: virtual void SequentialProcessingOff()
        
        Force sequential processing (i.e. single thread) of the crinkle
        cut process. By default, sequential processing is off. Note this
        flag only applies if the class has been compiled with
        VTK_SMP_IMPLEMENTATION_TYPE set to something other than
        Sequential. (If set to Sequential, then the filter always runs in
        serial mode.) This flag is typically used for benchmarking
        purposes.
        """
        ...
    
    def SequentialProcessingOn(self):
        """
        V.SequentialProcessingOn()
        C++: virtual void SequentialProcessingOn()
        
        Force sequential processing (i.e. single thread) of the crinkle
        cut process. By default, sequential processing is off. Note this
        flag only applies if the class has been compiled with
        VTK_SMP_IMPLEMENTATION_TYPE set to something other than
        Sequential. (If set to Sequential, then the filter always runs in
        serial mode.) This flag is typically used for benchmarking
        purposes.
        """
        ...
    
    def SetCopyCellData(self, bool):
        """
        V.SetCopyCellData(bool)
        C++: virtual void SetCopyCellData(bool _arg)
        
        Indicate whether to copy input cell data/attributes onto the
        output cells. By default this option is off.
        """
        ...
    
    def SetCopyPointData(self, bool):
        """
        V.SetCopyPointData(bool)
        C++: virtual void SetCopyPointData(bool _arg)
        
        Indicate whether to copy input point data/attributes onto the
        output points. By default this option is on.
        """
        ...
    
    def SetImplicitFunction(self, vtkImplicitFunction):
        """
        V.SetImplicitFunction(vtkImplicitFunction)
        C++: virtual void SetImplicitFunction(vtkImplicitFunction *)
        
        Specify the implicit function which is used to select the output
        cell faces. Note that the implicit function invocation must be
        thread safe. Also, there is a fast path for vtkPlane implicit
        functions.
        """
        ...
    
    def SetOutputPointsPrecision(self, p_int):
        """
        V.SetOutputPointsPrecision(int)
        C++: void SetOutputPointsPrecision(int precision)
        
        Set/get the desired precision for the output points. See the
        documentation for the vtkAlgorithm::Precision enum for an
        explanation of the available precision settings.
        """
        ...
    
    def SetRemoveUnusedPoints(self, bool):
        """
        V.SetRemoveUnusedPoints(bool)
        C++: virtual void SetRemoveUnusedPoints(bool _arg)
        
        Indicate whether to eliminate unused output points. When this
        flag is disabled, the input points and associated point data are
        simply shallow copied to the output (which improves performance).
         When enabled, any points that are not used by the output cells
        are not sent to the output, nor is associated point data copied.
        By default this option is disabled. Removing unused points does
        have a significant performance impact.
        """
        ...
    
    def SetSequentialProcessing(self, bool):
        """
        V.SetSequentialProcessing(bool)
        C++: virtual void SetSequentialProcessing(bool _arg)
        
        Force sequential processing (i.e. single thread) of the crinkle
        cut process. By default, sequential processing is off. Note this
        flag only applies if the class has been compiled with
        VTK_SMP_IMPLEMENTATION_TYPE set to something other than
        Sequential. (If set to Sequential, then the filter always runs in
        serial mode.) This flag is typically used for benchmarking
        purposes.
        """
        ...
    
    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__ = ...


