org.opencv.core.Rect Maven / Gradle / Ivy

package org.opencv.core;

/**
 * template class CV_EXPORTS Rect_ 

 *
 * // C++ code:
 *
 *
 * public:
 *
 * typedef _Tp value_type;
 *
 * //! various constructors
 *
 * Rect_();
 *
 * Rect_(_Tp _x, _Tp _y, _Tp _width, _Tp _height);
 *
 * Rect_(const Rect_& r);
 *
 * Rect_(const CvRect& r);
 *
 * Rect_(const Point_<_Tp>& org, const Size_<_Tp>& sz);
 *
 * Rect_(const Point_<_Tp>& pt1, const Point_<_Tp>& pt2);
 *
 * Rect_& operator = (const Rect_& r);
 *
 * //! the top-left corner
 *
 * Point_<_Tp> tl() const;
 *
 * //! the bottom-right corner
 *
 * Point_<_Tp> br() const;
 *
 * //! size (width, height) of the rectangle
 *
 * Size_<_Tp> size() const;
 *
 * //! area (width*height) of the rectangle
 *
 * _Tp area() const;
 *
 * //! conversion to another data type
 *
 * template operator Rect_<_Tp2>() const;
 *
 * //! conversion to the old-style CvRect
 *
 * operator CvRect() const;
 *
 * //! checks whether the rectangle contains the point
 *
 * bool contains(const Point_<_Tp>& pt) const;
 *
 * _Tp x, y, width, height; //< the top-left corner, as well as width and height
 * of the rectangle
 *
 * };
 *
 * Template class for 2D rectangles, described by the following parameters:
 * 
 * 
 *    Coordinates of the top-left corner. This is a default interpretation
 * of Rect_.x and Rect_.y in OpenCV. Though, in your
 * algorithms you may count x and y from the
 * bottom-left corner.
 *   
 Rectangle width and height.
 * 
 *
 * OpenCV typically assumes that the top and left boundary of the rectangle are
 * inclusive, while the right and bottom boundaries are not. For example, the
 * method Rect_.contains returns true if
 *
 * x <= pt.x < x+width,<BR>y <= pt.y < y+height
 *
 * Virtually every loop over an imageROI in OpenCV (where ROI is specified by
 * Rect_) is implemented as: 

 *
 * // C++ code:
 *
 * for(int y = roi.y; y < roi.y + rect.height; y++)
 *
 * for(int x = roi.x; x < roi.x + rect.width; x++)
 *
 *
 * //...
 *
 *
 * In addition to the class members, the following operations on rectangles are
 * implemented: 
 * 
 *    rect = rect +- point (shifting a rectangle by a certain
 * offset)
 *   
 rect = rect +- size (expanding or shrinking a rectangle by a
 * certain amount)
 *   
 rect += point, rect -= point, rect += size, rect -= size
 * (augmenting operations)
 *   
 rect = rect1 & rect2 (rectangle intersection)
 *   
 rect = rect1 | rect2 (minimum area rectangle containing
 * rect2 and rect3)
 *   
 rect &= rect1, rect |= rect1 (and the corresponding
 * augmenting operations)
 *   
 rect == rect1, rect != rect1 (rectangle comparison)
 * 
 *
 * This is an example how the partial ordering on rectangles can be established
 * (rect1subseteq rect2): 

 *
 * // C++ code:
 *
 * template inline bool
 *
 * operator <= (const Rect_<_Tp>& r1, const Rect_<_Tp>& r2)
 *
 *
 * return (r1 & r2) == r1;
 *
 *
 * For your convenience, the Rect_<> alias is available:
 *
 * typedef Rect_ Rect;
 *
 * @see org.opencv.core.Rect_
 */
public class Rect {

    public int x, y, width, height;

    public Rect(int x, int y, int width, int height) {
        this.x = x;
        this.y = y;
        this.width = width;
        this.height = height;
    }

    public Rect() {
        this(0, 0, 0, 0);
    }

    public Rect(Point p1, Point p2) {
        x = (int) (p1.x < p2.x ? p1.x : p2.x);
        y = (int) (p1.y < p2.y ? p1.y : p2.y);
        width = (int) (p1.x > p2.x ? p1.x : p2.x) - x;
        height = (int) (p1.y > p2.y ? p1.y : p2.y) - y;
    }

    public Rect(Point p, Size s) {
        this((int) p.x, (int) p.y, (int) s.width, (int) s.height);
    }

    public Rect(double[] vals) {
        set(vals);
    }

    public void set(double[] vals) {
        if (vals != null) {
            x = vals.length > 0 ? (int) vals[0] : 0;
            y = vals.length > 1 ? (int) vals[1] : 0;
            width = vals.length > 2 ? (int) vals[2] : 0;
            height = vals.length > 3 ? (int) vals[3] : 0;
        } else {
            x = 0;
            y = 0;
            width = 0;
            height = 0;
        }
    }

    public Rect clone() {
        return new Rect(x, y, width, height);
    }

    public Point tl() {
        return new Point(x, y);
    }

    public Point br() {
        return new Point(x + width, y + height);
    }

    public Size size() {
        return new Size(width, height);
    }

    public double area() {
        return width * height;
    }

    public boolean contains(Point p) {
        return x <= p.x && p.x < x + width && y <= p.y && p.y < y + height;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        long temp;
        temp = Double.doubleToLongBits(height);
        result = prime * result + (int) (temp ^ (temp >>> 32));
        temp = Double.doubleToLongBits(width);
        result = prime * result + (int) (temp ^ (temp >>> 32));
        temp = Double.doubleToLongBits(x);
        result = prime * result + (int) (temp ^ (temp >>> 32));
        temp = Double.doubleToLongBits(y);
        result = prime * result + (int) (temp ^ (temp >>> 32));
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof Rect)) return false;
        Rect it = (Rect) obj;
        return x == it.x && y == it.y && width == it.width && height == it.height;
    }

    @Override
    public String toString() {
        return "{" + x + ", " + y + ", " + width + "x" + height + "}";
    }
}