【opencv4.3.0教程】05之基础结构2之矩形结构Rect_详解

谁借莪１个温暖的怀抱￠ 2023-03-13 09:17 13阅读 0赞

**目录**

一、前言

二、温故知新

1、基础结构都有啥

2、Point\_

3、Size\_

三、Rect\_

1、定义

1.构造函数

2.基本操作

3.成员变量

4.使用时的数据类型

2、常用方法

1.定义中的方法

2.常用运算

3、代码实战

--------------------

# 一、前言 #

上一篇文章，我们讲了OpenCV中的基础结构，还讲了两个最常用也是最基本的结构，今天这篇博客，我们来讲剩下两个常见的结构。

# 二、温故知新 #

## 1、基础结构都有啥 ##

上一节课，我们讲到了基础结构，那我们都讲到哪些结构呢？跟我一起来回顾一下吧！

> 1.**Complex**：这个是复数类，跟我们数学上学到的复数是一样的。
> 
> 2.**Point\_**：表示的是二维点，包括两个坐标坐标值，也包括最常见的点的相关操作。
> 
> 3.**Point3\_**：表示三维点，包括三个坐标值：
> 
> 4.**Size\_**：表示图像或矩形大小。包括两个成员变量：width和height，表示图像或者矩阵的大小。
> 
> 5.**Rect\_**：这个用于描述二维矩形，主要有两个部分的参数：
> 
> （1）图像矩阵的左上角坐标。
> 
> （2）图像矩阵的宽度和高度。
> 
> 6.**RotatedRect**：带有旋转角度的矩形。主要有三个部分的参数：
> 
> （1）矩形的中心坐标。
> 
> （2）矩形长宽。
> 
> （3）图像旋转角度。
> 
> 7.**Range**：表示图像的连续子序列。
> 
> 8.**Scalar\_**：常用于定义像素值。
> 
> 9.**KeyPoint**：用于角点检测。
> 
> 10.**DMatch**：用于查询描述符索引、列车描述符索引、列车图像索引和描述符之间的距离。
> 
> 11.**TermCriteria**：定义迭代算法终止条件的类。我们可以使用默认构造函数初始化它，然后重写任何参数，或者可以使用构造函数的高级变量完全初始化结构。

## 2、Point\_ ##

然后，我们又详细讲解了Point\_类，讲了它的基本定义和常见用法。

Point\_类有两个成员变量：

_Tp x; //!< x coordinate of the point
        _Tp y; //!< y coordinate of the point

有多个构造函数：

//! default constructor
        Point_();
        Point_(_Tp _x, _Tp _y);
        Point_(const Point_& pt);
        Point_(Point_&& pt) CV_NOEXCEPT;
        Point_(const Size_<_Tp>& sz);
        Point_(const Vec<_Tp, 2>& v);

还有很多常用操作，因为内容比较多，就不再在这里说明啦！大家可以打开上一篇博客去详细查看哦：

> [Point\_类常用方法][Point]

## 3、Size\_ ##

然后，我们又详细讲解了Size\_类，讲了它的基本定义和常见用法。

Size\_类也有两个成员变量：

_Tp width; //!< the width
        _Tp height; //!< the height

有多个构造函数：

//! default constructor
        Size_();
        Size_(_Tp _width, _Tp _height);
        Size_(const Size_& sz);
        Size_(Size_&& sz) CV_NOEXCEPT;
        Size_(const Point_<_Tp>& pt);

还有很多常用操作，因为内容比较多，就不再在这里说明啦！大家可以打开上一篇博客去详细查看哦：

> [Size\_类常用方法][Size]

接下来让我们进入一个新的结构。

# 三、Rect\_ #

除了上面两个最基本的就是Rect\_了，我们怎么理解Rect\_呢？

> 一个明确位置且横平竖直的矩形。

比如下面这几个：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodWl5aXhpbg_size_36_color_FFF74F_t_70][]

一般来说，我们构建这个矩形，可以通过如下方法：

> 1.一个定位点，矩形的长和宽；
> 
> 2.两个定位点（要求分别为对角线）；

这是我们最基本的理解方式，了解了这些，就让我们从定义出发，一步一步来了解它吧！

## 1、定义 ##

跟上一次一样，我们先从定义入手，对它有个最基本的认识：

template<typename _Tp> class Rect_
    {
    public:
        typedef _Tp value_type;
    
        //! default constructor
        Rect_();
        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;
        //! 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;
        //! true if empty
        bool empty() const;
    
        //! conversion to another data type
        template<typename _Tp2> operator Rect_<_Tp2>() const;
    
        //! checks whether the rectangle contains the point
        bool contains(const Point_<_Tp>& pt) const;
    
        _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
    };
    
    typedef Rect_<int> Rect2i;
    typedef Rect_<float> Rect2f;
    typedef Rect_<double> Rect2d;
    typedef Rect2i Rect;
    
    template<typename _Tp> class DataType< Rect_<_Tp> >
    {
    public:
        typedef Rect_<_Tp>                               value_type;
        typedef Rect_<typename DataType<_Tp>::work_type> work_type;
        typedef _Tp                                      channel_type;
    
        enum { generic_type = 0,
               channels     = 4,
               fmt          = traits::SafeFmt<channel_type>::fmt + ((channels - 1) << 8)
    #ifdef OPENCV_TRAITS_ENABLE_DEPRECATED
               ,depth        = DataType<channel_type>::depth
               ,type         = CV_MAKETYPE(depth, channels)
    #endif
             };
    
        typedef Vec<channel_type, channels> vec_type;
    };
    
    namespace traits {
    template<typename _Tp>
    struct Depth< Rect_<_Tp> > { enum { value = Depth<_Tp>::value }; };
    template<typename _Tp>
    struct Type< Rect_<_Tp> > { enum { value = CV_MAKETYPE(Depth<_Tp>::value, 4) }; };
    } // namespace

这里面最基本的定义主要包括如下三部分：

### 1.构造函数 ###

几个构造函数，用于生成Rect对象：

//! default constructor
        Rect_();
        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);

对于第一个构造函数，可以创建一个空的矩形，左上角顶点坐标为（0,0），矩形的长宽均为0。一般这种无参构造函数都是创建空的对象，值的初始化要么为空，要么为0。

我们上面说到，想要构造一个矩形，可以有两种方式：

**第一种方式是使用一个点的坐标和长宽。**

（1）对于这种方式，我们既可以给四个参数：横坐标、纵坐标、长、宽：

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

（2）也可以使用我们昨天提到的两个类型：Point\_和Size\_。

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

**第二种方式是使用两个对角线顶点：**

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

除了上面的两种方法，我们还有一种方法就是使用另外的矩形为该矩形赋值：

Rect_(const Rect_& r);
        Rect_(Rect_&& r) CV_NOEXCEPT;

### 2.基本操作 ###

在定义中，还有如下基本操作：

Rect_& operator = ( const Rect_& r );
        Rect_& operator = ( Rect_&& r ) CV_NOEXCEPT;
        //! 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;
        //! true if empty
        bool empty() const;
    
        //! conversion to another data type
        template<typename _Tp2> operator Rect_<_Tp2>() const;
    
        //! checks whether the rectangle contains the point
        bool contains(const Point_<_Tp>& pt) const;

我们分类说明一下，方便大家理解：

**第一类，基本赋值操作**：

Rect_& operator = ( const Rect_& r );
        Rect_& operator = ( Rect_&& r ) CV_NOEXCEPT;

这个跟上面讲到的使用别的矩形为矩形赋值的功能是一致的；

**第二类，求顶点，获取矩形的左上角顶点和右下角顶点的坐标**：

//! 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;
        //! true if empty
        bool empty() const;

**第四类，转化为其他类型**：

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

**第五类，判断矩形是否包含某点，跟在点中的函数是一个含义**：

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

### 3.成员变量 ###

四个类体成员变量，包括横纵坐标，还有矩形的长和宽：

_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

### 4.使用时的数据类型 ###

当我们定义了Rect\_类之后，跟上面一样，我们要定义具体的使用过程中的类型：

typedef Rect_<int> Rect2i;
    typedef Rect_<float> Rect2f;
    typedef Rect_<double> Rect2d;
    typedef Rect2i Rect;

## 2、常用方法 ##

接下来我们要说的就是方法，这里有很多实现了上面的类定义时的方法，我们在上面也具体讲解了，在这里我们讲一下具体的实战。

### 1.定义中的方法 ###

定义中的方法包括构造函数和几个常用方法，构造函数如下：

template<typename _Tp> inline
    Rect_<_Tp>::Rect_()
        : x(0), y(0), width(0), height(0) {}
    
    template<typename _Tp> inline
    Rect_<_Tp>::Rect_(_Tp _x, _Tp _y, _Tp _width, _Tp _height)
        : x(_x), y(_y), width(_width), height(_height) {}
    
    template<typename _Tp> inline
    Rect_<_Tp>::Rect_(const Rect_<_Tp>& r)
        : x(r.x), y(r.y), width(r.width), height(r.height) {}
    
    template<typename _Tp> inline
    Rect_<_Tp>::Rect_(Rect_<_Tp>&& r) CV_NOEXCEPT
        : x(std::move(r.x)), y(std::move(r.y)), width(std::move(r.width)), height(std::move(r.height)) {}
    
    template<typename _Tp> inline
    Rect_<_Tp>::Rect_(const Point_<_Tp>& org, const Size_<_Tp>& sz)
        : x(org.x), y(org.y), width(sz.width), height(sz.height) {}
    
    template<typename _Tp> inline
    Rect_<_Tp>::Rect_(const Point_<_Tp>& pt1, const Point_<_Tp>& pt2)
    {
        x = std::min(pt1.x, pt2.x);
        y = std::min(pt1.y, pt2.y);
        width = std::max(pt1.x, pt2.x) - x;
        height = std::max(pt1.y, pt2.y) - y;
    }

常用方法如下：

template<typename _Tp> inline
    Point_<_Tp> Rect_<_Tp>::tl() const
    {
        return Point_<_Tp>(x,y);
    }
    
    template<typename _Tp> inline
    Point_<_Tp> Rect_<_Tp>::br() const
    {
        return Point_<_Tp>(x + width, y + height);
    }
    
    template<typename _Tp> inline
    Size_<_Tp> Rect_<_Tp>::size() const
    {
        return Size_<_Tp>(width, height);
    }
    
    template<typename _Tp> inline
    _Tp Rect_<_Tp>::area() const
    {
        const _Tp result = width * height;
        CV_DbgAssert(!std::numeric_limits<_Tp>::is_integer
            || width == 0 || result / width == height); // make sure the result fits in the return value
        return result;
    }
    
    template<typename _Tp> inline
    bool Rect_<_Tp>::empty() const
    {
        return width <= 0 || height <= 0;
    }
    
    template<typename _Tp> template<typename _Tp2> inline
    Rect_<_Tp>::operator Rect_<_Tp2>() const
    {
        return Rect_<_Tp2>(saturate_cast<_Tp2>(x), saturate_cast<_Tp2>(y), saturate_cast<_Tp2>(width), saturate_cast<_Tp2>(height));
    }
    
    template<typename _Tp> inline
    bool Rect_<_Tp>::contains(const Point_<_Tp>& pt) const
    {
        return x <= pt.x && pt.x < x + width && y <= pt.y && pt.y < y + height;
    }

我们使用构造函数创建几个矩形：

Rect r1 = Rect();
    	Rect r2 = Rect(1, 2, 3, 4);
    	Rect r3 = Rect(Point(5, 5), Size(10, 10));
    	Rect r4 = Rect(Point(5, 6), Point(10, 10));
    	Rect r5 = Rect(r4);

然后我们调用常用方法，查看一下效果：

cout << "r1 = " << r1 << endl;
    	cout << "r2 = " << r2 << endl;
    	cout << "r3 = " << r3 << endl;
    	cout << "r4 = " << r4 << endl;
    	cout << "r5 = " << r5 << endl;
    	cout << "【r5 info】" << endl;
    	cout << "r5.x = " << r5.x << endl;
    	cout << "r5.y = " << r5.y << endl;
    	cout << "r5.width = " << r5.width << endl;
    	cout << "r5.height = " << r5.height << endl;
    	cout << "r5.size = " << r5.size() << endl;
    	cout << "r5.area = " << r5.area() << endl;
    	cout << "r5.br = " << r5.br() << endl;
    	cout << "r5.tl = " << r5.tl() << endl;
    
    	if (r4 == r5) cout << "r4 = r5" << endl;
    	else cout << "r4 != r5" << endl;
    	if (r5.contains(Point())) cout << "Point" << Point() << " 在 Rect" << r5 << "中！" << endl;
    	else cout << "Point" << Point() << " 不在 Rect" << r5 << "中！" << endl;

执行结果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodWl5aXhpbg_size_26_color_FF74FF_t_70][]

### 2.常用运算 ###

常用运算包括赋值运算，四则运算等，具体如下：

**1.让左上角定位点移位的加赋值与减赋值，及其相关运算：**

template<typename _Tp> static inline
    Rect_<_Tp>& operator += ( Rect_<_Tp>& a, const Point_<_Tp>& b )
    {
        a.x += b.x;
        a.y += b.y;
        return a;
    }
    
    template<typename _Tp> static inline
    Rect_<_Tp>& operator -= ( Rect_<_Tp>& a, const Point_<_Tp>& b )
    {
        a.x -= b.x;
        a.y -= b.y;
        return a;
    }
    
    template<typename _Tp> static inline
    Rect_<_Tp> operator + (const Rect_<_Tp>& a, const Point_<_Tp>& b)
    {
        return Rect_<_Tp>( a.x + b.x, a.y + b.y, a.width, a.height );
    }
    
    template<typename _Tp> static inline
    Rect_<_Tp> operator - (const Rect_<_Tp>& a, const Point_<_Tp>& b)
    {
        return Rect_<_Tp>( a.x - b.x, a.y - b.y, a.width, a.height );
    }

**2.改变矩形尺寸的加赋值与减赋值，及其相关运算**：

template<typename _Tp> static inline
    Rect_<_Tp>& operator += ( Rect_<_Tp>& a, const Size_<_Tp>& b )
    {
        a.width += b.width;
        a.height += b.height;
        return a;
    }
    
    template<typename _Tp> static inline
    Rect_<_Tp>& operator -= ( Rect_<_Tp>& a, const Size_<_Tp>& b )
    {
        const _Tp width = a.width - b.width;
        const _Tp height = a.height - b.height;
        CV_DbgAssert(width >= 0 && height >= 0);
        a.width = width;
        a.height = height;
        return a;
    }
    
    template<typename _Tp> static inline
    Rect_<_Tp> operator + (const Rect_<_Tp>& a, const Size_<_Tp>& b)
    {
        return Rect_<_Tp>( a.x, a.y, a.width + b.width, a.height + b.height );
    }
    
    template<typename _Tp> static inline
    Rect_<_Tp> operator - (const Rect_<_Tp>& a, const Size_<_Tp>& b)
    {
        const _Tp width = a.width - b.width;
        const _Tp height = a.height - b.height;
        CV_DbgAssert(width >= 0 && height >= 0);
        return Rect_<_Tp>( a.x, a.y, width, height );
    }

3.两个矩形的公共矩形，如果没有，就是空：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodWl5aXhpbg_size_26_color_FF74FF_t_70 1][]

template<typename _Tp> static inline
    Rect_<_Tp>& operator &= ( Rect_<_Tp>& a, const Rect_<_Tp>& b )
    {
        _Tp x1 = std::max(a.x, b.x);
        _Tp y1 = std::max(a.y, b.y);
        a.width = std::min(a.x + a.width, b.x + b.width) - x1;
        a.height = std::min(a.y + a.height, b.y + b.height) - y1;
        a.x = x1;
        a.y = y1;
        if( a.width <= 0 || a.height <= 0 )
            a = Rect();
        return a;
    }
    
    template<typename _Tp> static inline
    Rect_<_Tp> operator & (const Rect_<_Tp>& a, const Rect_<_Tp>& b)
    {
        Rect_<_Tp> c = a;
        return c &= b;
    }

**4.两个矩形的最小包围矩形**：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodWl5aXhpbg_size_26_color_FF74FF_t_70 2][]

template<typename _Tp> static inline
    Rect_<_Tp>& operator |= ( Rect_<_Tp>& a, const Rect_<_Tp>& b )
    {
        if (a.empty()) {
            a = b;
        }
        else if (!b.empty()) {
            _Tp x1 = std::min(a.x, b.x);
            _Tp y1 = std::min(a.y, b.y);
            a.width = std::max(a.x + a.width, b.x + b.width) - x1;
            a.height = std::max(a.y + a.height, b.y + b.height) - y1;
            a.x = x1;
            a.y = y1;
        }
        return a;
    }
    
    template<typename _Tp> static inline
    Rect_<_Tp> operator | (const Rect_<_Tp>& a, const Rect_<_Tp>& b)
    {
        Rect_<_Tp> c = a;
        return c |= b;
    }

**5.判断两个矩形是否相等**：

template<typename _Tp> static inline
    bool operator == (const Rect_<_Tp>& a, const Rect_<_Tp>& b)
    {
        return a.x == b.x && a.y == b.y && a.width == b.width && a.height == b.height;
    }
    
    template<typename _Tp> static inline
    bool operator != (const Rect_<_Tp>& a, const Rect_<_Tp>& b)
    {
        return a.x != b.x || a.y != b.y || a.width != b.width || a.height != b.height;
    }

比较简单，我们就通过代码实战来巩固一下吧！

## 3、代码实战 ##

接下来我们走进实战，为我们以后的使用打好基础吧。

Rect rect1 = Rect(Point(5, 5), Point(15, 15));
    	Rect rect2 = Rect(Point(7, 7), Point(20, 20));
    	Point point1 = Point(3, 3);
    	Size size1 = Size(4, 4);
    
    	rect1 += point1;
    	cout << "rect1 += point1 =  " << rect1 << endl;
    	rect1 = rect1 - point1;
    	cout << "rect1 - point1  =  " << rect1 << endl;
    
    	rect2 += size1;
    	cout << "rect2 += size1  =  " << rect2 << endl;
    	rect2 = rect2 - size1;
    	cout << "rect2 - size1   =  " << rect2 << endl;
    	 
    	cout << "rect1 & rect2   =  " << (rect1 & rect2) << endl;
    	cout << "rect1 | rect2   =  " << (rect1 | rect2) << endl;

![20200513193443828.png][]

今天的内容就到这里啦，大家一定要多做练习呀！

[Point]: https://blog.csdn.net/shuiyixin/article/details/106046827#%E4%B8%89%E3%80%81%E5%B8%B8%E7%94%A8%E6%88%90%E5%91%98%E5%8F%8A%E6%96%B9%E6%B3%95%E4%BB%8B%E7%BB%8D
[Size]: https://blog.csdn.net/shuiyixin/article/details/106046827#2%E3%80%81%E5%B8%B8%E7%94%A8%E6%96%B9%E6%B3%95
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodWl5aXhpbg_size_36_color_FFF74F_t_70]: /images/20230312/b896dca8b57647b980a117025f6e51be.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodWl5aXhpbg_size_26_color_FF74FF_t_70]: /images/20230312/66be66fbdccb4c4fa5ff68b8ea92aee7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodWl5aXhpbg_size_26_color_FF74FF_t_70 1]: /images/20230312/4913c6b21ef0491d98b822401a0c75f8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodWl5aXhpbg_size_26_color_FF74FF_t_70 2]: https://img-blog.csdnimg.cn/20200513191207148.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodWl5aXhpbg==,size_26,color_FF74FF,t_70
[20200513193443828.png]: https://img-blog.csdnimg.cn/20200513193443828.png