# 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 vtkPixelExtent(object):
    """
    vtkPixelExtent() -> vtkPixelExtent
    C++: vtkPixelExtent()
    vtkPixelExtent(other:vtkPixelExtent) -> vtkPixelExtent
    C++: vtkPixelExtent(const vtkPixelExtent &other)
    
    vtkPixelExtent - Representation of a cartesian pixel plane and common
    operations on it.
    
    The implementation is intended to be fast and light so that it may be
    used in place of int[4] with little or no performance penalty.
    
    NOTE in most cases operation on an empty object produces incorrect
    results. If it an issue query Empty() first.
    """
    def CellToNode(self): # real signature unknown; restored from __doc__
        """
        CellToNode(self) -> None
        C++: void CellToNode()
        CellToNode(inputExt:vtkPixelExtent) -> vtkPixelExtent
        C++: static vtkPixelExtent CellToNode(
            const vtkPixelExtent &inputExt)
        
        In-place conversion from cell based to node based extent, and
        vise-versa.
        """
        pass

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

    def Contains(self, other): # real signature unknown; restored from __doc__
        """
        Contains(self, other:vtkPixelExtent) -> int
        C++: int Contains(const vtkPixelExtent &other)
        Contains(self, i:int, j:int) -> int
        C++: int Contains(int i, int j)
        
        Return non-zero if this extent contains the other.
        """
        return 0

    def Disjoint(self, other): # real signature unknown; restored from __doc__
        """
        Disjoint(self, other:vtkPixelExtent) -> int
        C++: int Disjoint(vtkPixelExtent other)
        
        Return non-zero if the extent is disjoint from the other
        """
        return 0

    def Empty(self): # real signature unknown; restored from __doc__
        """
        Empty(self) -> int
        C++: int Empty()
        
        Return true if empty.
        """
        return 0

    def GetData(self): # real signature unknown; restored from __doc__
        """
        GetData(self) -> Pointer
        C++: int *GetData()
        
        Direct access to internal data.
        """
        pass

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

    def GetEndIndex(self, last, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetEndIndex(self, last:[int, int]) -> None
        C++: void GetEndIndex(int last[2])
        """
        pass

    def GetStartIndex(self, first, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        GetStartIndex(self, first:[int, int]) -> None
        C++: void GetStartIndex(int first[2])
        GetStartIndex(self, first:[int, int], origin:(int, int)) -> None
        C++: void GetStartIndex(int first[2], const int origin[2])
        
        Get the start/end index.
        """
        pass

    def Grow(self, n): # real signature unknown; restored from __doc__
        """
        Grow(self, n:int) -> None
        C++: void Grow(int n)
        Grow(self, q:int, n:int) -> None
        C++: void Grow(int q, int n)
        Grow(inputExt:vtkPixelExtent, n:int) -> vtkPixelExtent
        C++: static vtkPixelExtent Grow(const vtkPixelExtent &inputExt,
            int n)
        Grow(inputExt:vtkPixelExtent, problemDomain:vtkPixelExtent, n:int)
             -> vtkPixelExtent
        C++: static vtkPixelExtent Grow(const vtkPixelExtent &inputExt,
            const vtkPixelExtent &problemDomain, int n)
        
        Expand the extents by n.
        """
        pass

    def GrowHigh(self, q, n): # real signature unknown; restored from __doc__
        """
        GrowHigh(self, q:int, n:int) -> None
        C++: void GrowHigh(int q, int n)
        GrowHigh(ext:vtkPixelExtent, q:int, n:int) -> vtkPixelExtent
        C++: static vtkPixelExtent GrowHigh(const vtkPixelExtent &ext,
            int q, int n)
        """
        pass

    def GrowLow(self, q, n): # real signature unknown; restored from __doc__
        """
        GrowLow(self, q:int, n:int) -> None
        C++: void GrowLow(int q, int n)
        GrowLow(ext:vtkPixelExtent, q:int, n:int) -> vtkPixelExtent
        C++: static vtkPixelExtent GrowLow(const vtkPixelExtent &ext,
            int q, int n)
        """
        pass

    def NodeToCell(self): # real signature unknown; restored from __doc__
        """
        NodeToCell(self) -> None
        C++: void NodeToCell()
        NodeToCell(inputExt:vtkPixelExtent) -> vtkPixelExtent
        C++: static vtkPixelExtent NodeToCell(
            const vtkPixelExtent &inputExt)
        """
        pass

    def SetData(self, ext): # real signature unknown; restored from __doc__
        """
        SetData(self, ext:vtkPixelExtent) -> None
        C++: void SetData(const vtkPixelExtent &ext)
        
        Set the extent.
        """
        pass

    def Shift(self): # real signature unknown; restored from __doc__
        """
        Shift(self) -> None
        C++: void Shift()
        Shift(self, ext:vtkPixelExtent) -> None
        C++: void Shift(const vtkPixelExtent &ext)
        Shift(self, n:[int, ...]) -> None
        C++: void Shift(int *n)
        Shift(self, q:int, n:int) -> None
        C++: void Shift(int q, int n)
        Shift(ij:[int, ...], n:int) -> None
        C++: static void Shift(int *ij, int n)
        Shift(ij:[int, ...], n:[int, ...]) -> None
        C++: static void Shift(int *ij, int *n)
        
        Shifts by low corner of this, moving to the origin.
        """
        pass

    def Shrink(self, n): # real signature unknown; restored from __doc__
        """
        Shrink(self, n:int) -> None
        C++: void Shrink(int n)
        Shrink(self, q:int, n:int) -> None
        C++: void Shrink(int q, int n)
        Shrink(inputExt:vtkPixelExtent, problemDomain:vtkPixelExtent,
            n:int) -> vtkPixelExtent
        C++: static vtkPixelExtent Shrink(const vtkPixelExtent &inputExt,
            const vtkPixelExtent &problemDomain, int n)
        Shrink(inputExt:vtkPixelExtent, n:int) -> vtkPixelExtent
        C++: static vtkPixelExtent Shrink(const vtkPixelExtent &inputExt,
            int n)
        
        Shrink the extent by n.
        """
        pass

    def Size(self): # real signature unknown; restored from __doc__
        """
        Size(self) -> int
        C++: size_t Size()
        Size(ext:vtkPixelExtent) -> int
        C++: static size_t Size(const vtkPixelExtent &ext)
        
        Get the total number.
        """
        return 0

    def Split(self, dir): # real signature unknown; restored from __doc__
        """
        Split(self, dir:int) -> vtkPixelExtent
        C++: vtkPixelExtent Split(int dir)
        
        Divide the extent in half in the given direction. The operation
        is done in-place the other half of the split extent is returned.
        The return will be empty if the split could not be made.
        """
        return vtkPixelExtent

    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

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