# encoding: utf-8
# module vtkmodules.vtkCommonDataModel
# from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\vtkmodules\vtkCommonDataModel.cp311-win_amd64.pyd
# by generator 1.147
# no doc

# imports
import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore
import vtkmodules.vtkCommonMath as __vtkmodules_vtkCommonMath
import vtkmodules.vtkCommonTransforms as __vtkmodules_vtkCommonTransforms


from .vtkDataSet import vtkDataSet

class vtkRectilinearGrid(vtkDataSet):
    """
    vtkRectilinearGrid - a dataset that is topologically regular with
    variable spacing in the three coordinate directions
    
    Superclass: vtkDataSet
    
    vtkRectilinearGrid is a data object that is a concrete implementation
    of vtkDataSet. vtkRectilinearGrid represents a geometric structure
    that is topologically regular with variable spacing in the three
    coordinate directions x-y-z.
    
    To define a vtkRectilinearGrid, you must specify the dimensions of
    the data and provide three arrays of values specifying the
    coordinates along the x-y-z axes. The coordinate arrays are specified
    using three vtkDataArray objects (one for x, one for y, one for z).
    
    @warning
    Make sure that the dimensions of the grid match the number of
    coordinates in the x-y-z directions. If not, unpredictable results
    (including program failure) may result. Also, you must supply
    coordinates in all three directions, even if the dataset topology is
    2D, 1D, or 0D.
    """
    def ComputeBounds(self): # real signature unknown; restored from __doc__
        """
        ComputeBounds(self) -> None
        C++: void ComputeBounds() override;
        
        Compute the data bounding box from data points. THIS METHOD IS
        NOT THREAD SAFE.
        """
        pass

    def ComputeCellId(self, ijk, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        ComputeCellId(self, ijk:[int, int, int]) -> int
        C++: vtkIdType ComputeCellId(int ijk[3])
        
        Given a location in structured coordinates (i-j-k), return the
        cell id.
        """
        pass

    def ComputePointId(self, ijk, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        ComputePointId(self, ijk:[int, int, int]) -> int
        C++: vtkIdType ComputePointId(int ijk[3])
        
        Given a location in structured coordinates (i-j-k), return the
        point id.
        """
        pass

    def ComputeStructuredCoordinates(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        ComputeStructuredCoordinates(self, x:[float, float, float],
            ijk:[int, int, int], pcoords:[float, float, float]) -> int
        C++: int ComputeStructuredCoordinates(double x[3], int ijk[3],
            double pcoords[3])
        
        Convenience function computes the structured coordinates for a
        point x[3]. The cell is specified by the array ijk[3], and the
        parametric coordinates in the cell are specified with pcoords[3].
        The function returns a 0 if the point x is outside of the grid,
        and a 1 if inside the grid.
        """
        pass

    def CopyStructure(self, ds): # real signature unknown; restored from __doc__
        """
        CopyStructure(self, ds:vtkDataSet) -> None
        C++: void CopyStructure(vtkDataSet *ds) override;
        
        Copy the geometric and topological structure of an input
        rectilinear grid object.
        """
        pass

    def Crop(self, updateExtent, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        Crop(self, updateExtent:(int, ...)) -> None
        C++: void Crop(const int *updateExtent) override;
        
        Reallocates and copies to set the Extent to the UpdateExtent.
        This is used internally when the exact extent is requested, and
        the source generated more than the update extent.
        """
        pass

    def DeepCopy(self, src): # real signature unknown; restored from __doc__
        """
        DeepCopy(self, src:vtkDataObject) -> None
        C++: void DeepCopy(vtkDataObject *src) override;
        """
        pass

    def ExtendedNew(self): # real signature unknown; restored from __doc__
        """
        ExtendedNew() -> vtkRectilinearGrid
        C++: static vtkRectilinearGrid *ExtendedNew()
        """
        return vtkRectilinearGrid

    def FindAndGetCell(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        FindAndGetCell(self, x:[float, float, float], cell:vtkCell,
            cellId:int, tol2:float, subId:int, pcoords:[float, float,
            float], weights:[float, ...]) -> vtkCell
        C++: vtkCell *FindAndGetCell(double x[3], vtkCell *cell,
            vtkIdType cellId, double tol2, int &subId, double pcoords[3],
            double *weights) override;
        
        Locate the cell that contains a point and return the cell. Also
        returns the subcell id, parametric coordinates and weights for
        subsequent interpolation. This method combines the derived class
        methods int FindCell and vtkCell *GetCell. Derived classes may
        provide a more efficient implementation. See for example
        vtkStructuredPoints. THIS METHOD IS NOT THREAD SAFE.
        """
        pass

    def FindCell(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        FindCell(self, x:[float, float, float], cell:vtkCell, cellId:int,
            tol2:float, subId:int, pcoords:[float, float, float],
            weights:[float, ...]) -> int
        C++: vtkIdType FindCell(double x[3], vtkCell *cell,
            vtkIdType cellId, double tol2, int &subId, double pcoords[3],
            double *weights) override;
        FindCell(self, x:[float, float, float], cell:vtkCell,
            gencell:vtkGenericCell, cellId:int, tol2:float, subId:int,
            pcoords:[float, float, float], weights:[float, ...]) -> int
        C++: vtkIdType FindCell(double x[3], vtkCell *cell,
            vtkGenericCell *gencell, vtkIdType cellId, double tol2,
            int &subId, double pcoords[3], double *weights) override;
        
        Locate cell based on global coordinate x and tolerance squared.
        If cell and cellId is non-nullptr, then search starts from this
        cell and looks at immediate neighbors.  Returns cellId >= 0 if
        inside, < 0 otherwise.  The parametric coordinates are provided
        in pcoords[3]. The interpolation weights are returned in
        weights[]. (The number of weights is equal to the number of
        points in the found cell). Tolerance is used to control how close
        the point is to be considered "in" the cell. THIS METHOD IS NOT
        THREAD SAFE.
        """
        pass

    def FindPoint(self, x, y, z): # real signature unknown; restored from __doc__
        """
        FindPoint(self, x:float, y:float, z:float) -> int
        C++: vtkIdType FindPoint(double x, double y, double z)
        FindPoint(self, x:[float, float, float]) -> int
        C++: vtkIdType FindPoint(double x[3]) override;
        
        Locate the closest point to the global coordinate x. Return the
        point id. If point id < 0; then no point found. (This may arise
        when point is outside of dataset.) THIS METHOD IS THREAD SAFE IF
        FIRST CALLED FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED
        """
        return 0

    def GetActualMemorySize(self): # real signature unknown; restored from __doc__
        """
        GetActualMemorySize(self) -> int
        C++: unsigned long GetActualMemorySize() override;
        
        Return the actual size of the data in kibibytes (1024 bytes).
        This number is valid only after the pipeline has updated. The
        memory size returned is guaranteed to be greater than or equal to
        the memory required to represent the data (e.g., extra space in
        arrays, etc. are not included in the return value). THIS METHOD
        IS THREAD SAFE.
        """
        return 0

    def GetCell(self, cellId): # real signature unknown; restored from __doc__
        """
        GetCell(self, cellId:int) -> vtkCell
        C++: vtkCell *GetCell(vtkIdType cellId) override;
        GetCell(self, i:int, j:int, k:int) -> vtkCell
        C++: vtkCell *GetCell(int i, int j, int k) override;
        GetCell(self, cellId:int, cell:vtkGenericCell) -> None
        C++: void GetCell(vtkIdType cellId, vtkGenericCell *cell)
            override;
        
        Get cell with cellId such that: 0 <= cellId < NumberOfCells. The
        returned vtkCell is an object owned by this instance, hence the
        return value must not be deleted by the caller.
        
        @warning Repeat calls to this function for different face ids
            will change
        the data stored in the internal member object whose pointer is
        returned by this function.
        
        @warning THIS METHOD IS NOT THREAD SAFE. For a thread-safe
            version, please use
        void GetCell(vtkIdType cellId, vtkGenericCell* cell).
        """
        return vtkCell

    def GetCellBounds(self, cellId, bounds, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetCellBounds(self, cellId:int, bounds:[float, float, float,
            float, float, float]) -> None
        C++: void GetCellBounds(vtkIdType cellId, double bounds[6])
            override;
        
        Get the bounds of the cell with cellId such that: 0 <= cellId <
        NumberOfCells. A subclass may be able to determine the bounds of
        cell without using an expensive GetCell() method. A default
        implementation is provided that actually uses a GetCell() call. 
        This is to ensure the method is available to all datasets. 
        Subclasses should override this method to provide an efficient
        implementation. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A
        SINGLE THREAD AND THE DATASET IS NOT MODIFIED
        """
        pass

    def GetCellDims(self, cellDims, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetCellDims(self, cellDims:[int, int, int]) -> None
        C++: void GetCellDims(int cellDims[3])
        
        Given the node dimensions of this grid instance, this method
        computes the node dimensions. The value in each dimension can
        will have a lowest value of "1" such that computing the total
        number of cells can be achieved by simply by
        cellDims[0]*cellDims[1]*cellDims[2].
        """
        pass

    def GetCellNeighbors(self, cellId, ptIds, cellIds): # real signature unknown; restored from __doc__
        """
        GetCellNeighbors(self, cellId:int, ptIds:vtkIdList,
            cellIds:vtkIdList) -> None
        C++: void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,
            vtkIdList *cellIds) override;
        GetCellNeighbors(self, cellId:int, ptIds:vtkIdList,
            cellIds:vtkIdList, seedLoc:[int, ...]) -> None
        C++: void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,
            vtkIdList *cellIds, int *seedLoc)
        
        Topological inquiry to get all cells using list of points
        exclusive of cell specified (e.g., cellId). Note that the list
        consists of only cells that use ALL the points provided. THIS
        METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND
        THE DATASET IS NOT MODIFIED
        """
        pass

    def GetCellPoints(self, cellId, ptIds): # real signature unknown; restored from __doc__
        """
        GetCellPoints(self, cellId:int, ptIds:vtkIdList) -> None
        C++: void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds)
            override;
        GetCellPoints(self, cellId:int, npts:int, pts:(int, ...),
            ptIds:vtkIdList) -> None
        C++: virtual void GetCellPoints(vtkIdType cellId, vtkIdType &npts,
             vtkIdType const *&pts, vtkIdList *ptIds)
        
        Topological inquiry to get points defining cell. THIS METHOD IS
        THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET
        IS NOT MODIFIED
        """
        pass

    def GetCellSize(self, cellId): # real signature unknown; restored from __doc__
        """
        GetCellSize(self, cellId:int) -> int
        C++: vtkIdType GetCellSize(vtkIdType cellId) override;
        
        Get the size of cell with cellId such that: 0 <= cellId <
        NumberOfCells. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A
        SINGLE THREAD AND THE DATASET IS NOT MODIFIED
        
        @warning This method MUST be overridden for performance reasons.
        Default implementation is very unefficient.
        """
        return 0

    def GetCellType(self, cellId): # real signature unknown; restored from __doc__
        """
        GetCellType(self, cellId:int) -> int
        C++: int GetCellType(vtkIdType cellId) override;
        
        Get type of cell with cellId such that: 0 <= cellId <
        NumberOfCells. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A
        SINGLE THREAD AND THE DATASET IS NOT MODIFIED
        """
        return 0

    def GetData(self, info): # real signature unknown; restored from __doc__
        """
        GetData(info:vtkInformation) -> vtkRectilinearGrid
        C++: static vtkRectilinearGrid *GetData(vtkInformation *info)
        GetData(v:vtkInformationVector, i:int=0) -> vtkRectilinearGrid
        C++: static vtkRectilinearGrid *GetData(vtkInformationVector *v,
            int i=0)
        
        Retrieve an instance of this class from an information object.
        """
        return vtkRectilinearGrid

    def GetDataDimension(self): # real signature unknown; restored from __doc__
        """
        GetDataDimension(self) -> int
        C++: int GetDataDimension()
        
        Return the dimensionality of the data.
        """
        return 0

    def GetDataObjectType(self): # real signature unknown; restored from __doc__
        """
        GetDataObjectType(self) -> int
        C++: int GetDataObjectType() override;
        
        Return what type of dataset this is.
        """
        return 0

    def GetDimensions(self): # real signature unknown; restored from __doc__
        """
        GetDimensions(self) -> (int, int, int)
        C++: virtual int *GetDimensions()
        
        Get dimensions of this rectilinear grid dataset.
        """
        pass

    def GetExtent(self): # real signature unknown; restored from __doc__
        """
        GetExtent(self) -> (int, int, int, int, int, int)
        C++: virtual int *GetExtent()
        """
        pass

    def GetExtentType(self): # real signature unknown; restored from __doc__
        """
        GetExtentType(self) -> int
        C++: int GetExtentType() override;
        
        Structured extent. The extent type is a 3D extent
        """
        return 0

    def GetMaxCellSize(self): # real signature unknown; restored from __doc__
        """
        GetMaxCellSize(self) -> int
        C++: int GetMaxCellSize() override;
        
        Convenience method returns largest cell size in dataset. This is
        generally used to allocate memory for supporting data structures.
        THIS METHOD IS THREAD SAFE
        """
        return 0

    def GetNumberOfCells(self): # real signature unknown; restored from __doc__
        """
        GetNumberOfCells(self) -> int
        C++: vtkIdType GetNumberOfCells() override;
        
        Standard vtkDataSet API methods. See vtkDataSet for more
        information.
        """
        return 0

    def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBase(self, type:str) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Given 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.
        """
        return 0

    def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__
        """
        GetNumberOfGenerationsFromBaseType(type:str) -> 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.
        """
        return 0

    def GetNumberOfPoints(self): # real signature unknown; restored from __doc__
        """
        GetNumberOfPoints(self) -> int
        C++: vtkIdType GetNumberOfPoints() override;
        
        Determine the number of points composing the dataset. THIS METHOD
        IS THREAD SAFE
        """
        return 0

    def GetNumberOfScalarComponents(self, meta_data): # real signature unknown; restored from __doc__
        """
        GetNumberOfScalarComponents(meta_data:vtkInformation) -> int
        C++: static int GetNumberOfScalarComponents(
            vtkInformation *meta_data)
        GetNumberOfScalarComponents(self) -> int
        C++: int GetNumberOfScalarComponents()
        """
        return 0

    def GetPoint(self, ptId): # real signature unknown; restored from __doc__
        """
        GetPoint(self, ptId:int) -> (float, float, float)
        C++: double *GetPoint(vtkIdType ptId) override;
        GetPoint(self, id:int, x:[float, float, float]) -> None
        C++: void GetPoint(vtkIdType id, double x[3]) override;
        GetPoint(self, i:int, j:int, k:int, p:[float, float, float])
            -> None
        C++: void GetPoint(const int i, const int j, const int k,
            double p[3])
        
        Get point coordinates with ptId such that: 0 <= ptId <
        NumberOfPoints. THIS METHOD IS NOT THREAD SAFE.
        """
        pass

    def GetPointCells(self, ptId, cellIds): # real signature unknown; restored from __doc__
        """
        GetPointCells(self, ptId:int, cellIds:vtkIdList) -> None
        C++: void GetPointCells(vtkIdType ptId, vtkIdList *cellIds)
            override;
        
        Topological inquiry to get cells using point. THIS METHOD IS
        THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET
        IS NOT MODIFIED
        """
        pass

    def GetPoints(self, pnts): # real signature unknown; restored from __doc__
        """
        GetPoints(self, pnts:vtkPoints) -> None
        C++: void GetPoints(vtkPoints *pnts)
        
        Given a user-supplied vtkPoints container object, this method
        fills in all the points of the RectilinearGrid.
        """
        pass

    def GetScalarType(self, meta_data): # real signature unknown; restored from __doc__
        """
        GetScalarType(meta_data:vtkInformation) -> int
        C++: static int GetScalarType(vtkInformation *meta_data)
        GetScalarType(self) -> int
        C++: int GetScalarType()
        """
        return 0

    def GetScalarTypeAsString(self): # real signature unknown; restored from __doc__
        """
        GetScalarTypeAsString(self) -> str
        C++: const char *GetScalarTypeAsString()
        """
        return ""

    def GetXCoordinates(self): # real signature unknown; restored from __doc__
        """
        GetXCoordinates(self) -> vtkDataArray
        C++: virtual vtkDataArray *GetXCoordinates()
        """
        pass

    def GetYCoordinates(self): # real signature unknown; restored from __doc__
        """
        GetYCoordinates(self) -> vtkDataArray
        C++: virtual vtkDataArray *GetYCoordinates()
        """
        pass

    def GetZCoordinates(self): # real signature unknown; restored from __doc__
        """
        GetZCoordinates(self) -> vtkDataArray
        C++: virtual vtkDataArray *GetZCoordinates()
        """
        pass

    def HasAnyBlankCells(self): # real signature unknown; restored from __doc__
        """
        HasAnyBlankCells(self) -> bool
        C++: bool HasAnyBlankCells() override;
        
        Returns 1 if there is any visibility constraint on the cells, 0
        otherwise.
        """
        return False

    def HasAnyBlankPoints(self): # real signature unknown; restored from __doc__
        """
        HasAnyBlankPoints(self) -> bool
        C++: bool HasAnyBlankPoints() override;
        
        Returns 1 if there is any visibility constraint on the points, 0
        otherwise.
        """
        return False

    def HasNumberOfScalarComponents(self, meta_data): # real signature unknown; restored from __doc__
        """
        HasNumberOfScalarComponents(meta_data:vtkInformation) -> bool
        C++: static bool HasNumberOfScalarComponents(
            vtkInformation *meta_data)
        """
        return False

    def HasScalarType(self, meta_data): # real signature unknown; restored from __doc__
        """
        HasScalarType(meta_data:vtkInformation) -> bool
        C++: static bool HasScalarType(vtkInformation *meta_data)
        """
        return False

    def Initialize(self): # real signature unknown; restored from __doc__
        """
        Initialize(self) -> None
        C++: void Initialize() override;
        
        Restore object to initial state. Release memory back to system.
        """
        pass

    def IsA(self, type): # real signature unknown; restored from __doc__
        """
        IsA(self, type:str) -> 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.
        """
        return 0

    def IsCellVisible(self, cellId): # real signature unknown; restored from __doc__
        """
        IsCellVisible(self, cellId:int) -> int
        C++: unsigned char IsCellVisible(vtkIdType cellId)
        
        Return non-zero value if specified point is visible. These
        methods should be called only after the dimensions of the grid
        are set.
        """
        return 0

    def IsPointVisible(self, ptId): # real signature unknown; restored from __doc__
        """
        IsPointVisible(self, ptId:int) -> int
        C++: unsigned char IsPointVisible(vtkIdType ptId)
        
        Return non-zero value if specified point is visible. These
        methods should be called only after the dimensions of the grid
        are set.
        """
        return 0

    def IsTypeOf(self, type): # real signature unknown; restored from __doc__
        """
        IsTypeOf(type:str) -> 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.
        """
        return 0

    def NewInstance(self): # real signature unknown; restored from __doc__
        """
        NewInstance(self) -> vtkRectilinearGrid
        C++: vtkRectilinearGrid *NewInstance()
        """
        return vtkRectilinearGrid

    def SafeDownCast(self, o): # real signature unknown; restored from __doc__
        """
        SafeDownCast(o:vtkObjectBase) -> vtkRectilinearGrid
        C++: static vtkRectilinearGrid *SafeDownCast(vtkObjectBase *o)
        """
        return vtkRectilinearGrid

    def SetDimensions(self, i, j, k): # real signature unknown; restored from __doc__
        """
        SetDimensions(self, i:int, j:int, k:int) -> None
        C++: void SetDimensions(int i, int j, int k)
        SetDimensions(self, dim:(int, int, int)) -> None
        C++: void SetDimensions(const int dim[3])
        
        Set dimensions of rectilinear grid dataset. This also sets the
        extent.
        """
        pass

    def SetExtent(self, extent, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        SetExtent(self, extent:[int, int, int, int, int, int]) -> None
        C++: void SetExtent(int extent[6])
        SetExtent(self, xMin:int, xMax:int, yMin:int, yMax:int, zMin:int,
            zMax:int) -> None
        C++: void SetExtent(int xMin, int xMax, int yMin, int yMax,
            int zMin, int zMax)
        
        Different ways to set the extent of the data array.  The extent
        should be set before the "Scalars" are set or allocated. The
        Extent is stored in the order (X, Y, Z).
        """
        pass

    def SetNumberOfScalarComponents(self, n, meta_data): # real signature unknown; restored from __doc__
        """
        SetNumberOfScalarComponents(n:int, meta_data:vtkInformation)
            -> None
        C++: static void SetNumberOfScalarComponents(int n,
            vtkInformation *meta_data)
        
        Set/Get the number of scalar components for points. As with the
        SetScalarType method this is setting pipeline info.
        """
        pass

    def SetScalarType(self, __a, meta_data): # real signature unknown; restored from __doc__
        """
        SetScalarType(__a:int, meta_data:vtkInformation) -> None
        C++: static void SetScalarType(int, vtkInformation *meta_data)
        
        Set/Get the scalar data type for the points. This is setting
        pipeline info.
        """
        pass

    def SetXCoordinates(self, __a): # real signature unknown; restored from __doc__
        """
        SetXCoordinates(self, __a:vtkDataArray) -> None
        C++: virtual void SetXCoordinates(vtkDataArray *)
        
        Specify the grid coordinates in the x-direction.
        """
        pass

    def SetYCoordinates(self, __a): # real signature unknown; restored from __doc__
        """
        SetYCoordinates(self, __a:vtkDataArray) -> None
        C++: virtual void SetYCoordinates(vtkDataArray *)
        
        Specify the grid coordinates in the y-direction.
        """
        pass

    def SetZCoordinates(self, __a): # real signature unknown; restored from __doc__
        """
        SetZCoordinates(self, __a:vtkDataArray) -> None
        C++: virtual void SetZCoordinates(vtkDataArray *)
        
        Specify the grid coordinates in the z-direction.
        """
        pass

    def ShallowCopy(self, src): # real signature unknown; restored from __doc__
        """
        ShallowCopy(self, src:vtkDataObject) -> None
        C++: void ShallowCopy(vtkDataObject *src) override;
        
        Shallow and Deep copy.
        """
        pass

    def __delattr__(self, *args, **kwargs): # real signature unknown
        """ Implement delattr(self, name). """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setattr__(self, *args, **kwargs): # real signature unknown
        """ Implement setattr(self, name, value). """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass

    __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Pointer to the C++ object."""


    __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkRectilinearGrid', 'ExtendedNew': <method 'ExtendedNew' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'IsTypeOf': <method 'IsTypeOf' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'IsA': <method 'IsA' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'SafeDownCast': <method 'SafeDownCast' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'NewInstance': <method 'NewInstance' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetNumberOfGenerationsFromBaseType': <method 'GetNumberOfGenerationsFromBaseType' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetNumberOfGenerationsFromBase': <method 'GetNumberOfGenerationsFromBase' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetDataObjectType': <method 'GetDataObjectType' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'CopyStructure': <method 'CopyStructure' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'Initialize': <method 'Initialize' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetNumberOfCells': <method 'GetNumberOfCells' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetNumberOfPoints': <method 'GetNumberOfPoints' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetPoint': <method 'GetPoint' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetCell': <method 'GetCell' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetCellBounds': <method 'GetCellBounds' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'FindPoint': <method 'FindPoint' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'FindCell': <method 'FindCell' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'FindAndGetCell': <method 'FindAndGetCell' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetCellType': <method 'GetCellType' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetCellSize': <method 'GetCellSize' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetCellPoints': <method 'GetCellPoints' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetPointCells': <method 'GetPointCells' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'ComputeBounds': <method 'ComputeBounds' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetMaxCellSize': <method 'GetMaxCellSize' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetCellNeighbors': <method 'GetCellNeighbors' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'IsPointVisible': <method 'IsPointVisible' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'IsCellVisible': <method 'IsCellVisible' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'HasAnyBlankPoints': <method 'HasAnyBlankPoints' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'HasAnyBlankCells': <method 'HasAnyBlankCells' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetCellDims': <method 'GetCellDims' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetPoints': <method 'GetPoints' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'SetDimensions': <method 'SetDimensions' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetDimensions': <method 'GetDimensions' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetDataDimension': <method 'GetDataDimension' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'ComputeStructuredCoordinates': <method 'ComputeStructuredCoordinates' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'ComputePointId': <method 'ComputePointId' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'ComputeCellId': <method 'ComputeCellId' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'SetXCoordinates': <method 'SetXCoordinates' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetXCoordinates': <method 'GetXCoordinates' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'SetYCoordinates': <method 'SetYCoordinates' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetYCoordinates': <method 'GetYCoordinates' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'SetZCoordinates': <method 'SetZCoordinates' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetZCoordinates': <method 'GetZCoordinates' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'SetExtent': <method 'SetExtent' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetExtent': <method 'GetExtent' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetActualMemorySize': <method 'GetActualMemorySize' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'ShallowCopy': <method 'ShallowCopy' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'DeepCopy': <method 'DeepCopy' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetExtentType': <method 'GetExtentType' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'Crop': <method 'Crop' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetData': <method 'GetData' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'SetScalarType': <method 'SetScalarType' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetScalarType': <method 'GetScalarType' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'HasScalarType': <method 'HasScalarType' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetScalarTypeAsString': <method 'GetScalarTypeAsString' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'SetNumberOfScalarComponents': <method 'SetNumberOfScalarComponents' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'GetNumberOfScalarComponents': <method 'GetNumberOfScalarComponents' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, 'HasNumberOfScalarComponents': <method 'HasNumberOfScalarComponents' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, '__new__': <built-in method __new__ of type object at 0x00007FF81D64A550>, '__repr__': <slot wrapper '__repr__' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, '__str__': <slot wrapper '__str__' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, '__getattribute__': <slot wrapper '__getattribute__' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, '__setattr__': <slot wrapper '__setattr__' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, '__delattr__': <slot wrapper '__delattr__' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, '__dict__': <attribute '__dict__' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, '__this__': <attribute '__this__' of 'vtkmodules.vtkCommonDataModel.vtkRectilinearGrid' objects>, '__doc__': 'vtkRectilinearGrid - a dataset that is topologically regular with\\nvariable spacing in the three coordinate directions\\n\\nSuperclass: vtkDataSet\\n\\nvtkRectilinearGrid is a data object that is a concrete implementation\\nof vtkDataSet. vtkRectilinearGrid represents a geometric structure\\nthat is topologically regular with variable spacing in the three\\ncoordinate directions x-y-z.\\n\\nTo define a vtkRectilinearGrid, you must specify the dimensions of\\nthe data and provide three arrays of values specifying the\\ncoordinates along the x-y-z axes. The coordinate arrays are specified\\nusing three vtkDataArray objects (one for x, one for y, one for z).\\n\\n@warning\\nMake sure that the dimensions of the grid match the number of\\ncoordinates in the x-y-z directions. If not, unpredictable results\\n(including program failure) may result. Also, you must supply\\ncoordinates in all three directions, even if the dataset topology is\\n2D, 1D, or 0D.\\n\\n'})"
    __vtkname__ = 'vtkRectilinearGrid'