Template class for 2D rectangles [詳解]

#include <types.hpp>

公開型
typedef _Tp	value_type

公開メンバ関数
	Rect_ ()
	default constructor

	Rect_ (_Tp _x, _Tp _y, _Tp _width, _Tp _height)

	Rect_ (const Rect_ &r)

	Rect_ (Rect_ &&r) CV_NOEXCEPT

	Rect_ (const Point_< _Tp > &org, const Size_< _Tp > &sz)

	Rect_ (const Point_< _Tp > &pt1, const Point_< _Tp > &pt2)

Rect_ &	operator= (const Rect_ &r)

Rect_ &	operator= (Rect_ &&r) CV_NOEXCEPT

Point_< _Tp >	tl () const
	the top-left corner

Point_< _Tp >	br () const
	the bottom-right corner

Size_< _Tp >	size () const
	size (width, height) of the rectangle

_Tp	area () const
	area (width*height) of the rectangle

bool	empty () const
	true if empty

template<typename _Tp2 >
	operator Rect_< _Tp2 > () const
	conversion to another data type

bool	contains (const Point_< _Tp > &pt) const
	checks whether the rectangle contains the point

公開変数類
_Tp	x
	x coordinate of the top-left corner

_Tp	y
	y coordinate of the top-left corner

_Tp	width
	width of the rectangle

_Tp	height
	height of the rectangle

詳解

template<typename _Tp>
class cv::Rect_< _Tp >

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 \leq pt.x < x+width, y \leq pt.y < y+height$

Virtually every loop over an image ROI in OpenCV (where ROI is specified by Rect_<int> ) is implemented as:

for(int y = roi.y; y < roi.y + roi.height; y++)
    for(int x = roi.x; x < roi.x + roi.width; x++)
    {
        // ...
    }

In addition to the class members, the following operations on rectangles are implemented:

$\texttt{rect} = \texttt{rect} \pm \texttt{point}$ (shifting a rectangle by a certain offset)
$\texttt{rect} = \texttt{rect} \pm \texttt{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 rect1 and rect2 )
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 (rect1 $\subseteq$ rect2):

template<typename _Tp> inline bool
operator <= (const Rect_<_Tp>& r1, const Rect_<_Tp>& r2)
{
    return (r1 & r2) == r1;
}

For your convenience, the Rect_<> alias is available: cv::Rect

このクラス詳解は次のファイルから抽出されました:

core/types.hpp

公開型

公開メンバ関数

公開変数類

詳解