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

import vtkmodules.vtkCommonExecutionModel as __vtkmodules_vtkCommonExecutionModel

class vtkContour3DLinearGrid(__vtkmodules_vtkCommonExecutionModel.vtkDataObjectAlgorithm):
    """
    vtkContour3DLinearGrid - fast generation of isosurface from 3D linear
    cells
    
    Superclass: vtkDataObjectAlgorithm
    
    vtkContour3DLinearGrid is a specialized filter that generates
    isocontours from an input vtkUnstructuredGrid 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. (Note: the
    filter will also process input vtkCompositeDataSets containing
    vtkUnstructuredGrids.)
    
    To use this filter you must specify an input unstructured grid or
    vtkCompositeDataSet, and one or more contour values.  You can either
    use the method SetValue() to specify each contour value, or use
    GenerateValues() to generate a series of evenly spaced contours.
    
    The filter performance varies depending on optional output
    information. Basically if point merging is required (when
    PointMerging, InterpolateAttributes, and/or ComputeNormals is
    enabled), a sorting process is required to eliminate duplicate output
    points in the isosurface. Otherwise when point merging is not
    required, a fast path process produces independent triangles
    representing the isosurface. In many situations the results of the
    fast path are quite good and do not require additional processing.
    
    Note that another performance option exists, using a vtkScalarTree,
    which is an object that accelerates isosurface extraction, at the
    initial cost of building the scalar tree. (This feature is useful for
    exploratory isosurface extraction when the isovalue is frequently
    changed.) In some cases this can improve performance, however this
    algorithm is so highly tuned that random memory jumps (due to random
    access of cells provided by the scalar tree) can actually negatively
    impact performance, especially if the input dataset type consists of
    homogeneous cell types.
    
    @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 vtkPolyData. When a vtkUnstructuredGrid is
    provided as input the output is a single vtkPolyData.
    
    @warning
    The fast path simply produces output points and triangles (the fast
    path executes when MergePoints if off; InterpolateAttributes is off;
    and ComputeNormals is off). Since the fast path does not merge
    points, it produces many more output points, typically on the order
    of 5-6x more than when MergePoints is enabled. Adding in the other
    options point merging, field interpolation, and normal generation
    results in additional performance impacts. By default the fast path
    is enabled.
    
    @warning
    When a vtkCompositeDataSet is provided as input, and UseScalarTree is
    enabled and a ScalarTree specified, then the specified scalar tree is
    cloned to create new ones for each dataset in the composite dataset.
    Otherwise (i.e., when vtkUnstructuredGrid input) the specified scalar
    tree is directly used (no cloning required).
    
    @warning
    Internal to this filter, a caching iterator is used to traverse the
    cells that compose the vtkUnstructuredGrid. Maximum performance is
    obtained if the cells are all of one type (i.e., input grid of
    homogeneous cell types); repeated switching from different types may
    have detrimental effects on performance.
    
    @warning
    For unstructured data, gradients are not computed. Normals are
    computed if requested; they are "pseudo-normals" in that the normals
    of output triangles that use a common point are averaged at the
    point. Alternatively use vtkPolyDataNormals to compute the surface
    normals.
    
    @warning
    The output of this filter is subtly different than the more general
    filter vtkContourGrid. vtkContourGrid eliminates small, degenerate
    triangles with concident points which are consequently not sent to
    the output. In practice this makes little impact on visual appearance
    but may have repercussions if the output is used for modelling and/or
    analysis.
    
    @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, and a limited subset of scalar types.
    
    @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
    vtkContourGrid vtkContourFilter vtkFlyingEdges3D vtkMarchingCubes
    vtkPolyDataNormals vtkStaticEdgeLocatorTemplate.h vtkScalarTree
    vtkSpanSpace
    """
    def CanFullyProcessDataObject(self, vtkDataObject, string):
        """
        V.CanFullyProcessDataObject(vtkDataObject, string) -> bool
        C++: static bool CanFullyProcessDataObject(vtkDataObject *object,
            const char *scalarArrayName)
        
        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. The second array is
        the name of the array to process.
        """
        ...
    
    def ComputeNormalsOff(self):
        """
        V.ComputeNormalsOff()
        C++: virtual void ComputeNormalsOff()
        
        Indicate whether to compute output point normals. An averaging
        method is used to average shared triangle normals. By default
        this if off. This is a relatively expensive option so use
        judiciously.
        """
        ...
    
    def ComputeNormalsOn(self):
        """
        V.ComputeNormalsOn()
        C++: virtual void ComputeNormalsOn()
        
        Indicate whether to compute output point normals. An averaging
        method is used to average shared triangle normals. By default
        this if off. This is a relatively expensive option so use
        judiciously.
        """
        ...
    
    def GenerateValues(self, p_int, p_float=..., p_float=...):
        """
        V.GenerateValues(int, [float, float])
        C++: void GenerateValues(int numContours, double range[2])
        V.GenerateValues(int, float, float)
        C++: void GenerateValues(int numContours, double rangeStart,
            double rangeEnd)
        
        Methods to set / get contour values.
        """
        ...
    
    def GetComputeNormals(self):
        """
        V.GetComputeNormals() -> int
        C++: virtual vtkTypeBool GetComputeNormals()
        
        Indicate whether to compute output point normals. An averaging
        method is used to average shared triangle normals. By default
        this if off. This is a relatively expensive option so use
        judiciously.
        """
        ...
    
    def GetInterpolateAttributes(self):
        """
        V.GetInterpolateAttributes() -> int
        C++: virtual vtkTypeBool GetInterpolateAttributes()
        
        Indicate whether to interpolate input attributes onto the
        isosurface. By default this option is off.
        """
        ...
    
    def GetLargeIds(self):
        """
        V.GetLargeIds() -> bool
        C++: bool GetLargeIds()
        
        Inform the user as to whether large ids were used during filter
        execution. This flag only has meaning after the filter has
        executed. Large ids are used when the id of the larges cell or
        point is greater than signed 32-bit precision. (Smaller ids
        reduce memory usage and speed computation. Note that LargeIds are
        only available on 64-bit architectures.)
        """
        ...
    
    def GetMergePoints(self):
        """
        V.GetMergePoints() -> int
        C++: virtual vtkTypeBool GetMergePoints()
        
        Indicate whether to merge coincident points. This takes extra
        time and produces fewer output points, creating a "watertight"
        contour surface. By default this is off.
        """
        ...
    
    def GetMTime(self):
        """
        V.GetMTime() -> int
        C++: vtkMTimeType GetMTime() override;
        
        Overloaded GetMTime() because of delegation to the internal
        vtkContourValues class.
        """
        ...
    
    def GetNumberOfContours(self):
        """
        V.GetNumberOfContours() -> int
        C++: vtkIdType GetNumberOfContours()
        
        Methods to set / get contour values.
        """
        ...
    
    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 types. See the
        documentation for the vtkAlgorithm::Precision enum for an
        explanation of the available precision settings.
        """
        ...
    
    def GetScalarTree(self):
        """
        V.GetScalarTree() -> vtkScalarTree
        C++: virtual vtkScalarTree *GetScalarTree()
        
        Specify the scalar tree to use. By default a vtkSpanSpace scalar
        tree is used.
        """
        ...
    
    def GetSequentialProcessing(self):
        """
        V.GetSequentialProcessing() -> int
        C++: virtual vtkTypeBool GetSequentialProcessing()
        
        Force sequential processing (i.e. single thread) of the
        contouring 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 GetUseScalarTree(self):
        """
        V.GetUseScalarTree() -> int
        C++: virtual vtkTypeBool GetUseScalarTree()
        
        Enable the use of a scalar tree to accelerate contour extraction.
        By default this is off. If enabled, and a scalar tree is not
        specified, then a vtkSpanSpace instance will be constructed and
        used.
        """
        ...
    
    def GetValue(self, p_int):
        """
        V.GetValue(int) -> float
        C++: double GetValue(int i)
        
        Methods to set / get contour values.
        """
        ...
    
    def GetValues(self):
        """
        V.GetValues() -> (float, ...)
        C++: double *GetValues()
        V.GetValues([float, ...])
        C++: void GetValues(double *contourValues)
        
        Methods to set / get contour values.
        """
        ...
    
    def InterpolateAttributesOff(self):
        """
        V.InterpolateAttributesOff()
        C++: virtual void InterpolateAttributesOff()
        
        Indicate whether to interpolate input attributes onto the
        isosurface. By default this option is off.
        """
        ...
    
    def InterpolateAttributesOn(self):
        """
        V.InterpolateAttributesOn()
        C++: virtual void InterpolateAttributesOn()
        
        Indicate whether to interpolate input attributes onto the
        isosurface. By default this option is off.
        """
        ...
    
    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 MergePointsOff(self):
        """
        V.MergePointsOff()
        C++: virtual void MergePointsOff()
        
        Indicate whether to merge coincident points. This takes extra
        time and produces fewer output points, creating a "watertight"
        contour surface. By default this is off.
        """
        ...
    
    def MergePointsOn(self):
        """
        V.MergePointsOn()
        C++: virtual void MergePointsOn()
        
        Indicate whether to merge coincident points. This takes extra
        time and produces fewer output points, creating a "watertight"
        contour surface. By default this is off.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkContour3DLinearGrid
        C++: vtkContour3DLinearGrid *NewInstance()
        
        Standard methods for construction, type info, and printing.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkContour3DLinearGrid
        C++: static vtkContour3DLinearGrid *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
        contouring 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
        contouring 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 SetComputeNormals(self, p_int):
        """
        V.SetComputeNormals(int)
        C++: virtual void SetComputeNormals(vtkTypeBool _arg)
        
        Indicate whether to compute output point normals. An averaging
        method is used to average shared triangle normals. By default
        this if off. This is a relatively expensive option so use
        judiciously.
        """
        ...
    
    def SetInterpolateAttributes(self, p_int):
        """
        V.SetInterpolateAttributes(int)
        C++: virtual void SetInterpolateAttributes(vtkTypeBool _arg)
        
        Indicate whether to interpolate input attributes onto the
        isosurface. By default this option is off.
        """
        ...
    
    def SetMergePoints(self, p_int):
        """
        V.SetMergePoints(int)
        C++: virtual void SetMergePoints(vtkTypeBool _arg)
        
        Indicate whether to merge coincident points. This takes extra
        time and produces fewer output points, creating a "watertight"
        contour surface. By default this is off.
        """
        ...
    
    def SetNumberOfContours(self, p_int):
        """
        V.SetNumberOfContours(int)
        C++: void SetNumberOfContours(int number)
        
        Methods to set / get contour values.
        """
        ...
    
    def SetOutputPointsPrecision(self, p_int):
        """
        V.SetOutputPointsPrecision(int)
        C++: void SetOutputPointsPrecision(int precision)
        
        Set/get the desired precision for the output types. See the
        documentation for the vtkAlgorithm::Precision enum for an
        explanation of the available precision settings.
        """
        ...
    
    def SetScalarTree(self, vtkScalarTree):
        """
        V.SetScalarTree(vtkScalarTree)
        C++: virtual void SetScalarTree(vtkScalarTree *)
        
        Specify the scalar tree to use. By default a vtkSpanSpace scalar
        tree is used.
        """
        ...
    
    def SetSequentialProcessing(self, p_int):
        """
        V.SetSequentialProcessing(int)
        C++: virtual void SetSequentialProcessing(vtkTypeBool _arg)
        
        Force sequential processing (i.e. single thread) of the
        contouring 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 SetUseScalarTree(self, p_int):
        """
        V.SetUseScalarTree(int)
        C++: virtual void SetUseScalarTree(vtkTypeBool _arg)
        
        Enable the use of a scalar tree to accelerate contour extraction.
        By default this is off. If enabled, and a scalar tree is not
        specified, then a vtkSpanSpace instance will be constructed and
        used.
        """
        ...
    
    def SetValue(self, p_int, p_float):
        """
        V.SetValue(int, float)
        C++: void SetValue(int i, double value)
        
        Methods to set / get contour values.
        """
        ...
    
    def UseScalarTreeOff(self):
        """
        V.UseScalarTreeOff()
        C++: virtual void UseScalarTreeOff()
        
        Enable the use of a scalar tree to accelerate contour extraction.
        By default this is off. If enabled, and a scalar tree is not
        specified, then a vtkSpanSpace instance will be constructed and
        used.
        """
        ...
    
    def UseScalarTreeOn(self):
        """
        V.UseScalarTreeOn()
        C++: virtual void UseScalarTreeOn()
        
        Enable the use of a scalar tree to accelerate contour extraction.
        By default this is off. If enabled, and a scalar tree is not
        specified, then a vtkSpanSpace instance will be constructed and
        used.
        """
        ...
    
    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__ = ...


