# 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 .object import object

class vtkAMRBox(object):
    """
    vtkAMRBox() -> vtkAMRBox
    C++: vtkAMRBox()
    vtkAMRBox(other:vtkAMRBox) -> vtkAMRBox
    C++: vtkAMRBox(const vtkAMRBox &other)
    vtkAMRBox(ilo:int, jlo:int, klo:int, ihi:int, jhi:int, khi:int)
        -> vtkAMRBox
    C++: vtkAMRBox(int ilo, int jlo, int klo, int ihi, int jhi, int khi)
    vtkAMRBox(origin:(float, ...), dimensions:(int, ...), spacing:(float,
        ...), globalOrigin:(float, ...), gridDescription:int=...)
        -> vtkAMRBox
    C++: vtkAMRBox(const double *origin, const int *dimensions,
        const double *spacing, const double *globalOrigin,
        int gridDescription=VTK_XYZ_GRID)
    vtkAMRBox(lo:(int, int, int), hi:(int, int, int)) -> vtkAMRBox
    C++: vtkAMRBox(const int lo[3], const int hi[3])
    vtkAMRBox(dims:(int, int, int, int, int, int)) -> vtkAMRBox
    C++: vtkAMRBox(const int dims[6])
    
    vtkAMRBox - Encloses a rectangular region of voxel like cells.
    
    vtkAMRBox stores information for an AMR block
    
    @sa
    vtkAMRInformation
    """
    def Coarsen(self, r): # real signature unknown; restored from __doc__
        """
        Coarsen(self, r:int) -> None
        C++: void Coarsen(int r)
        
        Coarsen the box.
        """
        pass

    def ComputeDimension(self): # real signature unknown; restored from __doc__
        """
        ComputeDimension(self) -> int
        C++: int ComputeDimension()
        
        Determines the dimension of the AMR box given the box indices.
        Note, the AMR box can be on an arbitrary axis-aligned plane,
        i.e., XZ or YZ.
        """
        return 0

    def ComputeStructuredCoordinates(self, box, dataOrigin, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        ComputeStructuredCoordinates(box:vtkAMRBox, dataOrigin:(float,
            float, float), h:(float, float, float), x:(float, float,
            float), ijk:[int, int, int], pcoords:[float, float, float])
            -> int
        C++: static int ComputeStructuredCoordinates(const vtkAMRBox &box,
             const double dataOrigin[3], const double h[3],
            const double x[3], int ijk[3], double pcoords[3])
        
        Compute structured coordinates
        """
        pass

    def Contains(self, i, j, k): # real signature unknown; restored from __doc__
        """
        Contains(self, i:int, j:int, k:int) -> bool
        C++: bool Contains(int i, int j, int k)
        Contains(self, I:(int, int, int)) -> bool
        C++: bool Contains(const int I[3])
        Contains(self, __a:vtkAMRBox) -> bool
        C++: bool Contains(const vtkAMRBox &)
        
        Test to see if a given cell index is inside this box.
        """
        return False

    def Deserialize(self, buffer, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        Deserialize(self, buffer:[int, ...], bytesize:int) -> None
        C++: void Deserialize(unsigned char *buffer,
            const vtkIdType &bytesize)
        
        Deserializes this object instance from the given byte-stream.
        Pre-conditions: buffer != nullptr bytesize != 0
        """
        pass

    def DoesBoxIntersectAlongDimension(self, other, q): # real signature unknown; restored from __doc__
        """
        DoesBoxIntersectAlongDimension(self, other:vtkAMRBox, q:int)
            -> bool
        C++: bool DoesBoxIntersectAlongDimension(const vtkAMRBox &other,
            const int q)
        
        Checks if this instance of vtkAMRBox intersects with the box
        passed through the argument list along the given dimension q.
        True is returned iff the box intersects successfully. Otherwise,
        there is no intersection along the given dimension and false is
        returned.
        """
        return False

    def DoesIntersect(self, other): # real signature unknown; restored from __doc__
        """
        DoesIntersect(self, other:vtkAMRBox) -> bool
        C++: bool DoesIntersect(const vtkAMRBox &other)
        """
        return False

    def Empty(self): # real signature unknown; restored from __doc__
        """
        Empty(self) -> bool
        C++: bool Empty()
        """
        return False

    def EmptyDimension(self, i): # real signature unknown; restored from __doc__
        """
        EmptyDimension(self, i:int) -> bool
        C++: bool EmptyDimension(int i)
        
        Whether dimension i is empty, e.g. if the data set is type
        VTK_XY_PLANE
        """
        return False

    def GetBounds(self, box, origin, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetBounds(box:vtkAMRBox, origin:(float, float, float), spacing:(
            float, float, float), bounds:[float, float, float, float,
            float, float]) -> None
        C++: static void GetBounds(const vtkAMRBox &box,
            const double origin[3], const double spacing[3],
            double bounds[6])
        
        Get the bounds of this box.
        """
        pass

    def GetBoxOrigin(self, box, X0, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetBoxOrigin(box:vtkAMRBox, X0:(float, float, float), spacing:(
            float, float, float), x0:[float, float, float]) -> None
        C++: static void GetBoxOrigin(const vtkAMRBox &box,
            const double X0[3], const double spacing[3], double x0[3])
        
        Get the world space origin of this box. The origin is the
        location of the lower corner cell's lower corner node,
        """
        pass

    def GetBytesize(self): # real signature unknown; restored from __doc__
        """
        GetBytesize() -> int
        C++: static vtkIdType GetBytesize()
        
        Returns the number of bytes allocated by this instance. In
        addition, this number of bytes corresponds to the buffer size
        required to serialize any vtkAMRBox instance.
        """
        return 0

    def GetCellLinearIndex(self, box, i, j, k, imageDimension, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetCellLinearIndex(box:vtkAMRBox, i:int, j:int, k:int,
            imageDimension:[int, int, int]) -> int
        C++: static int GetCellLinearIndex(const vtkAMRBox &box,
            const int i, const int j, const int k, int imageDimension[3])
        
        Returns the linear index of the given cell structured coordinates
        """
        pass

    def GetDimensions(self, lo, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetDimensions(self, lo:[int, int, int], hi:[int, int, int])
            -> None
        C++: void GetDimensions(int lo[3], int hi[3])
        GetDimensions(self, dims:[int, int, int, int, int, int]) -> None
        C++: void GetDimensions(int dims[6])
        
        Get the dimensions of this box. (ilo,jlo,jhi),(ihi,jhi,khi)
        """
        pass

    def GetGhostVector(self, r, nghost, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetGhostVector(self, r:int, nghost:[int, int, int, int, int, int])
             -> None
        C++: void GetGhostVector(int r, int nghost[6])
        
        Given an AMR box and the refinement ratio, r, this method
        computes the number of ghost layers in each of the 6 directions,
        i.e., [imin,imax,jmin,jmax,kmin,kmax]
        """
        pass

    def GetHiCorner(self): # real signature unknown; restored from __doc__
        """
        GetHiCorner(self) -> Pointer
        C++: const int *GetHiCorner()
        """
        pass

    def GetLoCorner(self): # real signature unknown; restored from __doc__
        """
        GetLoCorner(self) -> Pointer
        C++: const int *GetLoCorner()
        
        Get the low corner index.
        """
        pass

    def GetNumberOfCells(self): # real signature unknown; restored from __doc__
        """
        GetNumberOfCells(self) -> int
        C++: vtkIdType GetNumberOfCells()
        GetNumberOfCells(self, num:[int, int, int]) -> None
        C++: void GetNumberOfCells(int num[3])
        
        Gets the number of cells enclosed by the box.
        """
        return 0

    def GetNumberOfNodes(self, ext, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetNumberOfNodes(self, ext:[int, int, int]) -> None
        C++: void GetNumberOfNodes(int ext[3])
        GetNumberOfNodes(self) -> int
        C++: vtkIdType GetNumberOfNodes()
        
        Gets the number of nodes required to construct a physical
        representation of the box.
        """
        pass

    def GetValidHiCorner(self, hi, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetValidHiCorner(self, hi:[int, int, int]) -> None
        C++: void GetValidHiCorner(int hi[3])
        
        Return a high corner. If dimension j is empty, then hi[j] is set
        from lo[j]. This is convenient For algorithm that must iterate
        over all cells
        """
        pass

    def Grow(self, byN): # real signature unknown; restored from __doc__
        """
        Grow(self, byN:int) -> None
        C++: void Grow(int byN)
        
        Grows the box in all directions.
        """
        pass

    def HasPoint(self, box, origin, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        HasPoint(box:vtkAMRBox, origin:(float, float, float), spacing:(
            float, float, float), x:float, y:float, z:float) -> bool
        C++: static bool HasPoint(const vtkAMRBox &box,
            const double origin[3], const double spacing[3], double x,
            double y, double z)
        
        Checks if the point is inside this AMRBox instance. x,y,z the
        world point
        """
        pass

    def Intersect(self, other): # real signature unknown; restored from __doc__
        """
        Intersect(self, other:vtkAMRBox) -> bool
        C++: bool Intersect(const vtkAMRBox &other)
        
        Intersect this box with another box in place.  Returns true if
        the boxes do intersect.  Note that the box is modified to be the
        intersection or is made invalid.
        """
        return False

    def Invalidate(self): # real signature unknown; restored from __doc__
        """
        Invalidate(self) -> None
        C++: void Invalidate()
        
        Set the box to be invalid;
        """
        pass

    def IsInvalid(self): # real signature unknown; restored from __doc__
        """
        IsInvalid(self) -> bool
        C++: bool IsInvalid()
        
        Check to see if the AMR box instance is invalid.
        """
        return False

    def Refine(self, r): # real signature unknown; restored from __doc__
        """
        Refine(self, r:int) -> None
        C++: void Refine(int r)
        
        Refine the box.
        """
        pass

    def RemoveGhosts(self, r): # real signature unknown; restored from __doc__
        """
        RemoveGhosts(self, r:int) -> None
        C++: void RemoveGhosts(int r)
        
        Given an AMR box and the refinement ratio, r, this shrinks the
        AMRBox
        """
        pass

    def Serialize(self, buffer, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        Serialize(self, buffer:[int, ...], bytesize:int) -> None
        C++: void Serialize(unsigned char *&buffer, vtkIdType &bytesize)
        Serialize(self, buffer:[int, ...]) -> None
        C++: void Serialize(int *buffer)
        
        Serializes this object instance into a byte-stream. buffer   --
        user-supplied pointer where the serialized object is stored.
        bytesize -- number of bytes, i.e., the size of the buffer. NOTE:
        buffer is allocated internally by this method. Pre-conditions:
        buffer == nullptr Post-conditions: buffer   != nullptr bytesize
        != 0
        """
        pass

    def SetDimensions(self, ilo, jlo, klo, ihi, jhi, khi, desc, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        SetDimensions(self, ilo:int, jlo:int, klo:int, ihi:int, jhi:int,
            khi:int, desc:int=...) -> None
        C++: void SetDimensions(int ilo, int jlo, int klo, int ihi,
            int jhi, int khi, int desc=VTK_XYZ_GRID)
        SetDimensions(self, lo:(int, int, int), hi:(int, int, int),
            desc:int=...) -> None
        C++: void SetDimensions(const int lo[3], const int hi[3],
            int desc=VTK_XYZ_GRID)
        SetDimensions(self, dims:(int, int, int, int, int, int),
            desc:int=...) -> None
        C++: void SetDimensions(const int dims[6], int desc=VTK_XYZ_GRID)
        
        Set the dimensions of the box. ilo,jlo,klo,ihi,jhi,khi
        """
        pass

    def Shift(self, i, j, k): # real signature unknown; restored from __doc__
        """
        Shift(self, i:int, j:int, k:int) -> None
        C++: void Shift(int i, int j, int k)
        Shift(self, I:(int, int, int)) -> None
        C++: void Shift(const int I[3])
        
        Shifts the box in index space
        """
        pass

    def Shrink(self, byN): # real signature unknown; restored from __doc__
        """
        Shrink(self, byN:int) -> None
        C++: void Shrink(int byN)
        """
        pass

    def __eq__(self, *args, **kwargs): # real signature unknown
        """ Return self==value. """
        pass

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

    def __ge__(self, *args, **kwargs): # real signature unknown
        """ Return self>=value. """
        pass

    def __gt__(self, *args, **kwargs): # real signature unknown
        """ Return self>value. """
        pass

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

    def __init__(self): # real signature unknown; restored from __doc__
        pass

    def __le__(self, *args, **kwargs): # real signature unknown
        """ Return self<=value. """
        pass

    def __lt__(self, *args, **kwargs): # real signature unknown
        """ Return self<value. """
        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 __ne__(self, *args, **kwargs): # real signature unknown
        """ Return self!=value. """
        pass

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