public class Rect extends Object
template
// 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
//! 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:
Rect_.x and Rect_.y in OpenCV. Though, in your
algorithms you may count x and y from the
bottom-left corner.
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 += 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
operator <= (const Rect_<_Tp>& r1, const Rect_<_Tp>& r2)
return (r1 & r2) == r1;
For your convenience, the Rect_<> alias is available:
typedef Rect_
| Constructor and Description |
|---|
Rect() |
Rect(double[] vals) |
Rect(int x,
int y,
int width,
int height) |
Rect(Point p1,
Point p2) |
Rect(Point p,
Size s) |
public Rect(int x,
int y,
int width,
int height)
public Rect()
public Rect(double[] vals)
Copyright © 2014. All rights reserved.