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

import vtkmodules.vtkCommonExecutionModel as __vtkmodules_vtkCommonExecutionModel

class vtkBoxClipDataSet(__vtkmodules_vtkCommonExecutionModel.vtkUnstructuredGridAlgorithm):
    """
    vtkBoxClipDataSet - clip an unstructured grid
    
    Superclass: vtkUnstructuredGridAlgorithm
    
    Clipping means that is actually 'cuts' through the cells of the
    dataset, returning tetrahedral cells inside of the box. The output of
    this filter is an unstructured grid.
    
    This filter can be configured to compute a second output. The second
    output is the part of the cell that is clipped away. Set the
    GenerateClippedData boolean on if you wish to access this output
    data.
    
    The vtkBoxClipDataSet will triangulate all types of 3D cells (i.e,
    create tetrahedra). This is necessary to preserve compatibility
    across face neighbors.
    
    To use this filter,you can decide if you will be clipping with a box
    or a hexahedral box.
    1) Set orientation if(SetOrientation(0)): box (parallel with
       coordinate axis) SetBoxClip(xmin,xmax,ymin,ymax,zmin,zmax)
       if(SetOrientation(1)): hexahedral box (Default)
       SetBoxClip(n[0],o[0],n[1],o[1],n[2],o[2],n[3],o[3],n[4],o[4],n[5],o
       [5]) PlaneNormal[] normal of each plane PlanePoint[] point on the
       plane
    2) Apply the GenerateClipScalarsOn()
    3) Execute clipping  Update();
    """
    def CellGrid(self, p_int, p_int_1, int_tuple, vtkCellArray):
        """
        V.CellGrid(int, int, (int, ...), vtkCellArray)
        C++: void CellGrid(vtkIdType typeobj, vtkIdType npts,
            const vtkIdType *cellIds, vtkCellArray *newCellArray)
        """
        ...
    
    def ClipBox(self, vtkPoints, vtkGenericCell, vtkIncrementalPointLocator, vtkCellArray, vtkPointData, vtkPointData_1, vtkCellData, p_int, vtkCellData_1):
        """
        V.ClipBox(vtkPoints, vtkGenericCell, vtkIncrementalPointLocator,
            vtkCellArray, vtkPointData, vtkPointData, vtkCellData, int,
            vtkCellData)
        C++: void ClipBox(vtkPoints *newPoints, vtkGenericCell *cell,
            vtkIncrementalPointLocator *locator, vtkCellArray *tets,
            vtkPointData *inPD, vtkPointData *outPD, vtkCellData *inCD,
            vtkIdType cellId, vtkCellData *outCD)
        """
        ...
    
    def ClipBox0D(self, vtkGenericCell, vtkIncrementalPointLocator, vtkCellArray, vtkPointData, vtkPointData_1, vtkCellData, p_int, vtkCellData_1):
        """
        V.ClipBox0D(vtkGenericCell, vtkIncrementalPointLocator,
            vtkCellArray, vtkPointData, vtkPointData, vtkCellData, int,
            vtkCellData)
        C++: void ClipBox0D(vtkGenericCell *cell,
            vtkIncrementalPointLocator *locator, vtkCellArray *verts,
            vtkPointData *inPD, vtkPointData *outPD, vtkCellData *inCD,
            vtkIdType cellId, vtkCellData *outCD)
        """
        ...
    
    def ClipBox1D(self, vtkPoints, vtkGenericCell, vtkIncrementalPointLocator, vtkCellArray, vtkPointData, vtkPointData_1, vtkCellData, p_int, vtkCellData_1):
        """
        V.ClipBox1D(vtkPoints, vtkGenericCell, vtkIncrementalPointLocator,
             vtkCellArray, vtkPointData, vtkPointData, vtkCellData, int,
            vtkCellData)
        C++: void ClipBox1D(vtkPoints *newPoints, vtkGenericCell *cell,
            vtkIncrementalPointLocator *locator, vtkCellArray *lines,
            vtkPointData *inPD, vtkPointData *outPD, vtkCellData *inCD,
            vtkIdType cellId, vtkCellData *outCD)
        """
        ...
    
    def ClipBox2D(self, vtkPoints, vtkGenericCell, vtkIncrementalPointLocator, vtkCellArray, vtkPointData, vtkPointData_1, vtkCellData, p_int, vtkCellData_1):
        """
        V.ClipBox2D(vtkPoints, vtkGenericCell, vtkIncrementalPointLocator,
             vtkCellArray, vtkPointData, vtkPointData, vtkCellData, int,
            vtkCellData)
        C++: void ClipBox2D(vtkPoints *newPoints, vtkGenericCell *cell,
            vtkIncrementalPointLocator *locator, vtkCellArray *tets,
            vtkPointData *inPD, vtkPointData *outPD, vtkCellData *inCD,
            vtkIdType cellId, vtkCellData *outCD)
        """
        ...
    
    def ClipHexahedron(self, vtkPoints, vtkGenericCell, vtkIncrementalPointLocator, vtkCellArray, vtkPointData, vtkPointData_1, vtkCellData, p_int, vtkCellData_1):
        """
        V.ClipHexahedron(vtkPoints, vtkGenericCell,
            vtkIncrementalPointLocator, vtkCellArray, vtkPointData,
            vtkPointData, vtkCellData, int, vtkCellData)
        C++: void ClipHexahedron(vtkPoints *newPoints,
            vtkGenericCell *cell, vtkIncrementalPointLocator *locator,
            vtkCellArray *tets, vtkPointData *inPD, vtkPointData *outPD,
            vtkCellData *inCD, vtkIdType cellId, vtkCellData *outCD)
        """
        ...
    
    def ClipHexahedron0D(self, vtkGenericCell, vtkIncrementalPointLocator, vtkCellArray, vtkPointData, vtkPointData_1, vtkCellData, p_int, vtkCellData_1):
        """
        V.ClipHexahedron0D(vtkGenericCell, vtkIncrementalPointLocator,
            vtkCellArray, vtkPointData, vtkPointData, vtkCellData, int,
            vtkCellData)
        C++: void ClipHexahedron0D(vtkGenericCell *cell,
            vtkIncrementalPointLocator *locator, vtkCellArray *verts,
            vtkPointData *inPD, vtkPointData *outPD, vtkCellData *inCD,
            vtkIdType cellId, vtkCellData *outCD)
        """
        ...
    
    def ClipHexahedron1D(self, vtkPoints, vtkGenericCell, vtkIncrementalPointLocator, vtkCellArray, vtkPointData, vtkPointData_1, vtkCellData, p_int, vtkCellData_1):
        """
        V.ClipHexahedron1D(vtkPoints, vtkGenericCell,
            vtkIncrementalPointLocator, vtkCellArray, vtkPointData,
            vtkPointData, vtkCellData, int, vtkCellData)
        C++: void ClipHexahedron1D(vtkPoints *newPoints,
            vtkGenericCell *cell, vtkIncrementalPointLocator *locator,
            vtkCellArray *lines, vtkPointData *inPD, vtkPointData *outPD,
            vtkCellData *inCD, vtkIdType cellId, vtkCellData *outCD)
        """
        ...
    
    def ClipHexahedron2D(self, vtkPoints, vtkGenericCell, vtkIncrementalPointLocator, vtkCellArray, vtkPointData, vtkPointData_1, vtkCellData, p_int, vtkCellData_1):
        """
        V.ClipHexahedron2D(vtkPoints, vtkGenericCell,
            vtkIncrementalPointLocator, vtkCellArray, vtkPointData,
            vtkPointData, vtkCellData, int, vtkCellData)
        C++: void ClipHexahedron2D(vtkPoints *newPoints,
            vtkGenericCell *cell, vtkIncrementalPointLocator *locator,
            vtkCellArray *tets, vtkPointData *inPD, vtkPointData *outPD,
            vtkCellData *inCD, vtkIdType cellId, vtkCellData *outCD)
        """
        ...
    
    def CreateDefaultLocator(self):
        """
        V.CreateDefaultLocator()
        C++: void CreateDefaultLocator()
        
        Create default locator. Used to create one when none is
        specified. The locator is used to merge coincident points.
        """
        ...
    
    def CreateTetra(self, p_int, int_tuple, vtkCellArray):
        """
        V.CreateTetra(int, (int, ...), vtkCellArray)
        C++: void CreateTetra(vtkIdType npts, const vtkIdType *cellIds,
            vtkCellArray *newCellArray)
        """
        ...
    
    def GenerateClippedOutputOff(self):
        """
        V.GenerateClippedOutputOff()
        C++: virtual void GenerateClippedOutputOff()
        
        Control whether a second output is generated. The second output
        contains the polygonal data that's been clipped away.
        """
        ...
    
    def GenerateClippedOutputOn(self):
        """
        V.GenerateClippedOutputOn()
        C++: virtual void GenerateClippedOutputOn()
        
        Control whether a second output is generated. The second output
        contains the polygonal data that's been clipped away.
        """
        ...
    
    def GenerateClipScalarsOff(self):
        """
        V.GenerateClipScalarsOff()
        C++: virtual void GenerateClipScalarsOff()
        
        If this flag is enabled, then the output scalar values will be
        interpolated, and not the input scalar data.
        """
        ...
    
    def GenerateClipScalarsOn(self):
        """
        V.GenerateClipScalarsOn()
        C++: virtual void GenerateClipScalarsOn()
        
        If this flag is enabled, then the output scalar values will be
        interpolated, and not the input scalar data.
        """
        ...
    
    def GetClippedOutput(self):
        """
        V.GetClippedOutput() -> vtkUnstructuredGrid
        C++: vtkUnstructuredGrid *GetClippedOutput()
        
        Return the Clipped output.
        """
        ...
    
    def GetGenerateClippedOutput(self):
        """
        V.GetGenerateClippedOutput() -> int
        C++: virtual vtkTypeBool GetGenerateClippedOutput()
        
        Control whether a second output is generated. The second output
        contains the polygonal data that's been clipped away.
        """
        ...
    
    def GetGenerateClipScalars(self):
        """
        V.GetGenerateClipScalars() -> int
        C++: virtual vtkTypeBool GetGenerateClipScalars()
        
        If this flag is enabled, then the output scalar values will be
        interpolated, and not the input scalar data.
        """
        ...
    
    def GetLocator(self):
        """
        V.GetLocator() -> vtkIncrementalPointLocator
        C++: virtual vtkIncrementalPointLocator *GetLocator()
        
        Specify a spatial locator for merging points. By default, an
        instance of vtkMergePoints is used.
        """
        ...
    
    def GetMTime(self):
        """
        V.GetMTime() -> int
        C++: vtkMTimeType GetMTime() override;
        
        Return the mtime also considering the locator.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Given a the name of a base class of this class type, return the
        distance of inheritance between this class type and the named
        class (how many generations of inheritance are there between this
        class and the named class). If the named class is not in this
        class's inheritance tree, return a negative value. Valid
        responses will always be nonnegative. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def GetNumberOfOutputs(self):
        """
        V.GetNumberOfOutputs() -> int
        C++: virtual int GetNumberOfOutputs()
        
        Return the Clipped output.
        """
        ...
    
    def GetOrientation(self):
        """
        V.GetOrientation() -> int
        C++: virtual unsigned int GetOrientation()
        
        Tells if clipping happens with a box parallel with coordinate
        axis (0) or with an hexahedral box (1). Initial value is 1.
        """
        ...
    
    def InterpolateEdge(self, vtkDataSetAttributes, p_int, p_int_1, p_int_2, p_float):
        """
        V.InterpolateEdge(vtkDataSetAttributes, int, int, int, float)
        C++: static void InterpolateEdge(vtkDataSetAttributes *attributes,
             vtkIdType toId, vtkIdType fromId1, vtkIdType fromId2,
            double t)
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Return 1 if this class is the same type of (or a subclass of) the
        named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Return 1 if this class type is the same type of (or a subclass
        of) the named class. Returns 0 otherwise. This method works in
        combination with vtkTypeMacro found in vtkSetGet.h.
        """
        ...
    
    def MinEdgeF(self, int_tuple, int_tuple_1, *int):
        """
        V.MinEdgeF((int, ...), (int, ...), [int, ...])
        C++: void MinEdgeF(const unsigned int *id_v,
            const vtkIdType *cellIds, unsigned int *edgF)
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkBoxClipDataSet
        C++: vtkBoxClipDataSet *NewInstance()
        """
        ...
    
    def PyramidToTetra(self, int_tuple, int_tuple_1, vtkCellArray):
        """
        V.PyramidToTetra((int, ...), (int, ...), vtkCellArray)
        C++: void PyramidToTetra(const vtkIdType *pyramId,
            const vtkIdType *cellIds, vtkCellArray *newCellArray)
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkBoxClipDataSet
        C++: static vtkBoxClipDataSet *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def SetBoxClip(self, p_float, p_float_1, p_float_2, p_float_3, p_float_4, p_float_5):
        """
        V.SetBoxClip(float, float, float, float, float, float)
        C++: void SetBoxClip(double xmin, double xmax, double ymin,
            double ymax, double zmin, double zmax)
        V.SetBoxClip((float, ...), (float, ...), (float, ...), (float,
            ...), (float, ...), (float, ...), (float, ...), (float, ...),
            (float, ...), (float, ...), (float, ...), (float, ...))
        C++: void SetBoxClip(const double *n0, const double *o0,
            const double *n1, const double *o1, const double *n2,
            const double *o2, const double *n3, const double *o3,
            const double *n4, const double *o4, const double *n5,
            const double *o5)
        
        Specify the Box with which to perform the clipping. If the box is
        not parallel to axis, you need to especify normal vector of each
        plane and a point on the plane.
        """
        ...
    
    def SetGenerateClippedOutput(self, p_int):
        """
        V.SetGenerateClippedOutput(int)
        C++: virtual void SetGenerateClippedOutput(vtkTypeBool _arg)
        
        Control whether a second output is generated. The second output
        contains the polygonal data that's been clipped away.
        """
        ...
    
    def SetGenerateClipScalars(self, p_int):
        """
        V.SetGenerateClipScalars(int)
        C++: virtual void SetGenerateClipScalars(vtkTypeBool _arg)
        
        If this flag is enabled, then the output scalar values will be
        interpolated, and not the input scalar data.
        """
        ...
    
    def SetLocator(self, vtkIncrementalPointLocator):
        """
        V.SetLocator(vtkIncrementalPointLocator)
        C++: void SetLocator(vtkIncrementalPointLocator *locator)
        
        Specify a spatial locator for merging points. By default, an
        instance of vtkMergePoints is used.
        """
        ...
    
    def SetOrientation(self, p_int):
        """
        V.SetOrientation(int)
        C++: virtual void SetOrientation(unsigned int _arg)
        
        Tells if clipping happens with a box parallel with coordinate
        axis (0) or with an hexahedral box (1). Initial value is 1.
        """
        ...
    
    def WedgeToTetra(self, int_tuple, int_tuple_1, vtkCellArray):
        """
        V.WedgeToTetra((int, ...), (int, ...), vtkCellArray)
        C++: void WedgeToTetra(const vtkIdType *wedgeId,
            const vtkIdType *cellIds, vtkCellArray *newCellArray)
        """
        ...
    
    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__ = ...


