template class cv::Rect_

Overview

Template class for 2D rectangles. More…

#include <types.hpp>

template <typename _Tp>
class Rect_
{
public:
    // typedefs

    typedef _Tp value_type;

    // fields

    _Tp height;
    _Tp width;
    _Tp x;
    _Tp y;

    // construction

    Rect_();

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

    Rect_(const Rect_& r);

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

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

    // methods

    _Tp
    area() const;

    Point_<_Tp>
    br() const;

    bool
    contains(const Point_<_Tp>& pt) const;

    template <typename _Tp2>
    operator Rect_< _Tp2 >() const;

    Rect_&
    operator=(const Rect_& r);

    Size_<_Tp>
    size() const;

    Point_<_Tp>
    tl() const;
};

Detailed Documentation

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

Construction

Rect_()

various constructors

Methods

_Tp
area() const

area (width*height) of the rectangle

Point_<_Tp>
br() const

the bottom-right corner

bool
contains(const Point_<_Tp>& pt) const

checks whether the rectangle contains the point

template <typename _Tp2>
operator Rect_< _Tp2 >() const

conversion to another data type

Size_<_Tp>
size() const

size (width, height) of the rectangle

Point_<_Tp>
tl() const

the top-left corner