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

class vtkRect_IdE(vtkVector_IdLi4EE):
    """
    vtkRect() -> vtkRect
    C++: vtkRect()
    vtkRect(x:float, y:float, width:float, height:float) -> vtkRect
    C++: vtkRect(const double &x, const double &y, const double &width,
        const double &height)
    vtkRect(init:(float, float, float, float)) -> vtkRect
    C++: explicit vtkRect(const double *init)
    vtkRect(__a:vtkRect_IdE) -> vtkRect
    C++: vtkRect(const &vtkRect<double>)
    
    vtkRect- templated base type for storage of 2D rectangles.
    
    Superclass: vtkVector[float64,4]
    
    This class is a templated data type for storing and manipulating
    rectangles. The memory layout is a contiguous array of the specified
    type, such that a float[4] can be cast to a vtkRectf and manipulated.
    Also a float[12] could be cast and used as a vtkRectf[3].
    """
    def AddPoint(self, point, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        AddPoint(self, point:(float, float)) -> None
        C++: void AddPoint(const double point[2])
        AddPoint(self, x:float, y:float) -> None
        C++: void AddPoint(double x, double y)
        
        Expand this rect to contain the point passed in.
        """
        pass

    def AddRect(self, rect): # real signature unknown; restored from __doc__
        """
        AddRect(self, rect:vtkRect_IdE) -> None
        C++: void AddRect(const vtkRect<double> &rect)
        
        Expand this rect to contain the rect passed in.
        """
        pass

    def GetBottom(self): # real signature unknown; restored from __doc__
        """
        GetBottom(self) -> float
        C++: const double &GetBottom()
        
        Get the bottom boundary of the rectangle along the Y direction.
        """
        return 0.0

    def GetBottomLeft(self): # real signature unknown; restored from __doc__
        """
        GetBottomLeft(self) -> vtkVector2_IdE
        C++: vtkVector2<double> GetBottomLeft()
        
        Get the bottom left corner of the rect as a vtkVector.
        """
        return vtkVector2_IdE

    def GetBottomRight(self): # real signature unknown; restored from __doc__
        """
        GetBottomRight(self) -> vtkVector_IdLi2EE
        C++: vtkVector<double, 2> GetBottomRight()
        
        Get the bottom right corner of the rect as a vtkVector.
        """
        return vtkVector_IdLi2EE

    def GetCenter(self): # real signature unknown; restored from __doc__
        """
        GetCenter(self) -> vtkVector2d
        C++: vtkVector2d GetCenter()
        
        Returns the center of the rect as a vtkVector2d.
        """
        return vtkVector2d

    def GetHeight(self): # real signature unknown; restored from __doc__
        """
        GetHeight(self) -> float
        C++: const double &GetHeight()
        
        Get the height of the rectangle, i.e. element 3.
        """
        return 0.0

    def GetLeft(self): # real signature unknown; restored from __doc__
        """
        GetLeft(self) -> float
        C++: const double &GetLeft()
        
        Get the left boundary of the rectangle along the X direction.
        """
        return 0.0

    def GetRight(self): # real signature unknown; restored from __doc__
        """
        GetRight(self) -> float
        C++: double GetRight()
        
        Get the right boundary of the rectangle along the X direction.
        """
        return 0.0

    def GetTop(self): # real signature unknown; restored from __doc__
        """
        GetTop(self) -> float
        C++: double GetTop()
        
        Get the top boundary of the rectangle along the Y direction.
        """
        return 0.0

    def GetTopLeft(self): # real signature unknown; restored from __doc__
        """
        GetTopLeft(self) -> vtkVector_IdLi2EE
        C++: vtkVector<double, 2> GetTopLeft()
        
        Get the top left corner of the rect as a vtkVector.
        """
        return vtkVector_IdLi2EE

    def GetTopRight(self): # real signature unknown; restored from __doc__
        """
        GetTopRight(self) -> vtkVector_IdLi2EE
        C++: vtkVector<double, 2> GetTopRight()
        
        Get the bottom left corner of the rect as a vtkVector.
        """
        return vtkVector_IdLi2EE

    def GetWidth(self): # real signature unknown; restored from __doc__
        """
        GetWidth(self) -> float
        C++: const double &GetWidth()
        
        Get the width of the rectangle, i.e. element 2.
        """
        return 0.0

    def GetX(self): # real signature unknown; restored from __doc__
        """
        GetX(self) -> float
        C++: const double &GetX()
        
        Get the x component of the rectangle bottom corner, i.e. element
        0.
        """
        return 0.0

    def GetY(self): # real signature unknown; restored from __doc__
        """
        GetY(self) -> float
        C++: const double &GetY()
        
        Get the y component of the rectangle bottom corner, i.e. element
        1.
        """
        return 0.0

    def Intersect(self, other): # real signature unknown; restored from __doc__
        """
        Intersect(self, other:vtkRect_IdE) -> bool
        C++: bool Intersect(const vtkRect<double> &other)
        
        Intersect with `other` rectangle. If
        `this->IntersectsWith(other)` is true, this method will update
        this rect to the intersection of `this` and `other` and return
        true. If `this->IntersectsWith(other)` returns false, then this
        method will return false leaving this rect unchanged.
        
        Returns true if the intersection was performed otherwise false.
        """
        return False

    def IntersectsWith(self, rect): # real signature unknown; restored from __doc__
        """
        IntersectsWith(self, rect:vtkRect_IdE) -> bool
        C++: bool IntersectsWith(const vtkRect<double> &rect)
        
        Returns true if the rect argument overlaps this rect. If the
        upper bound of one rect is equal to the lower bound of the other
        rect, then this will return false (in that case, the rects would
        be considered to be adjacent but not overlapping).
        """
        return False

    def MoveTo(self, x, y): # real signature unknown; restored from __doc__
        """
        MoveTo(self, x:float, y:float) -> None
        C++: void MoveTo(double x, double y)
        
        Move the rectangle, moving the bottom-left corner to the given
        position. The rectangles size remains unchanged.
        """
        pass

    def Set(self, x, y, width, height): # real signature unknown; restored from __doc__
        """
        Set(self, x:float, y:float, width:float, height:float) -> None
        C++: void Set(const double &x, const double &y,
            const double &width, const double &height)
        
        Set the x, y components of the rectangle, and the width/height.
        """
        pass

    def SetHeight(self, height): # real signature unknown; restored from __doc__
        """
        SetHeight(self, height:float) -> None
        C++: void SetHeight(const double &height)
        
        Set the height of the rectangle, i.e. element 3.
        """
        pass

    def SetWidth(self, width): # real signature unknown; restored from __doc__
        """
        SetWidth(self, width:float) -> None
        C++: void SetWidth(const double &width)
        
        Set the width of the rectanle, i.e. element 2.
        """
        pass

    def SetX(self, x): # real signature unknown; restored from __doc__
        """
        SetX(self, x:float) -> None
        C++: void SetX(const double &x)
        
        Set the x component of the rectangle bottom corner, i.e. element
        0.
        """
        pass

    def SetY(self, y): # real signature unknown; restored from __doc__
        """
        SetY(self, y:float) -> None
        C++: void SetY(const double &y)
        
        Set the y component of the rectangle bottom corner, i.e. element
        1.
        """
        pass

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

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        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