【opencv4.3.0教程】07之像素基本操作 1 获取像素指针及控制像素范围

系统管理员 2023-03-14 13:14 0阅读 0赞

**目录**

一、前言

二、温故知新——基本数据类型

1、最基本之Mat类

2、四大天王之Point\_、Size\_、Rect\_、Scalar\_

3、各大分堂主

三、像素及相关概念

1、像素

2、灰度图与彩图

四、像素基本操作

1、获取像素指针

1.理论讲解

2.代码实战

2、控制像素范围

1.理论讲解

2.代码实战

说在后面的话

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

# 一、前言 #

上几篇文章，我们讲完了OpenCV中的常见基础结构。

从这篇博客开始，我们要踏上新的征程，我们要从像素的角度，来一起了解图像，一起了解OpenCV。今天这篇博客，我们讲最基本的图像像素操作，让我们一起，复习一下之前学的基本数据类型，然后一起走进今天的内容吧！

# 二、温故知新——基本数据类型 #

我想大家应该还记得我们之前学的数据类型，主要有如下：

## 1、最基本之Mat类 ##

Mat类是我们学到的最基本的数据类型，从这节课开始往后的每节课，都会涉及到Mat类。Mat常用于声明或定义一个图像，偶尔也用于声明一个二维矩阵。

具体内容大家请看：

> [Mat类详解][Mat]

## 2、四大天王之Point\_、Size\_、Rect\_、Scalar\_ ##

四大天王，这个名字也是很形象了，因为这个是除了Mat类之外最常用的四个类型，经常需要辅助Mat类做一些操作。他们分别是：

> 表示 **点** 的 Point\_；
> 
> 表示 **尺寸** 的 Size\_；
> 
> 表示 **矩形** 的 Rect\_；
> 
> 表示 **颜色** 的 Scalar\_；

具体内容大家请看：

> [Point\_与Size\_][Point_Size]
> 
> [Rect\_][Rect]
> 
> [Scalar\_][Scalar]

## 3、各大分堂主 ##

其他数据类型虽然不如上面四个常用，但是他们在自己的领域不可替代，会协助Mat类和上面四个常用类型做更多的事，实现更加丰富的功能：

> 表示 **复数** 的 Complex；
> 
> 表示 **三维点** 的 Point\_；
> 
> 表示 **旋转矩形** 的 RotatedRect；
> 
> 表示 **序列** 的 Range；
> 
> 表示 **角点** 的 KeyPoint；
> 
> 表示 **索引与描述符距离** 的 DMatch；
> 
> 表示 **迭代算法终止条件** 的 TermCriteria；

具体内容大家请看：

> [OpenCV基本结构][Point_Size]

# 三、像素及相关概念 #

## 1、像素 ##

首先我们先来了解一下像素

> 像素是计算机屏幕上所能显示的最小单位。用来表示图像的单位。每一个单位都会有其色彩数值。

## 2、灰度图与彩图 ##

我们经常能够见到的是黑白图像和彩色图像，其中黑白图像只有一个通道，彩色图像有三个通道，这些通道中每个像素点上的取值范围都是0-255；

对于黑白图像，0表示纯黑色，255表示纯白色，介于0-255之间的图像是灰色，根据数值的不同，灰色的程度也不同。我们也把这样的图像称之为**灰度图像**。

一个10×10的灰度图像排布如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodWl5aXhpbg_size_16_color_F74FFF_t_70][]

对于彩色图像，有三个通道，每个通道各表示一种颜色，分别是BGR，也就是蓝绿红。以红色通道为例，如果取值为0，表示黑色，如果取值为255表示红色。我们之前学习Scalar\_也学到了光学三原色，我们可以通过三种颜色构造出不同的颜色来。当三个通道的数值都为255时，图像为纯白色。

一个10×10的彩色图像排布如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodWl5aXhpbg_size_16_color_FFF74F_t_70][]

# 四、像素基本操作 #

## 1、获取像素指针 ##

### 1.理论讲解 ###

操作像素之前，肯定要做的就是获取指向像素的指针，然后才能对像素进行操作。所以第一个就是要获取像素的指针。

但是我们看上面的图， 我么发现，对于灰度图和彩图，他们是不一样的，而且对于彩图来说，它是怎么存放的呢？

在计算机中，Mat是以序列的形式存放，对于灰度图，是这样的：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodWl5aXhpbg_size_46_color_F1474F_t_70][]

对于彩色图，我们要先知道，我们是一个像素一个像素排列，在像素内，是先B再G最后R。所以一幅彩色图像的表示如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodWl5aXhpbg_size_46_color_FFFFFF_t_70][]

然后再按照上面的灰度图那样进行排列。

所以根据上面的，我们可以知道：

> **对于灰度图：**
> 
> 一幅尺寸为 **m×n** （m行n列）的灰度图像，存储为长为 **m×n** 的序列；
> 
> 想要访问第 **i**行，第 **j** 列的像素，就是访问序列中的第 **(i-1)×n+j** 个像素，因为第1个像素序号是0，那这个像素的序号就是 **(i-1)×n+j-1** 。
> 
> **对于彩色图：**
> 
> 一幅尺寸为 **m×n** （m行n列）的彩色图像，存储为长为 **m×n×3** 的序列；
> 
> 想要访问第 **i**行，第 **j** 列的元素就没有那么简单了：
> 
> （1）首先上面就有 **(i-1)** 行像素，每行有 **n×3** 个元素，就是有 **(i-1)×n×3** 个元素。
> 
> （2）其次对于当前行，前面有 (**j-1)** 个像素，就是有 **(j-1)×3** 个元素。
> 
> （3）最后是对于当前位置的像素，我们知道顺序是BGR，所以B是0，G是1，R是2。
> 
> 总的来说就是：访问第 **i**行，第 **j** 列的像素，B是 **(i-1)×n×3+(j-1)×3** ，G是 **(i-1)×n×3+(j-1)×3+1** ，R是 **(i-1)×n×3+(j-1)×3+2** 。

对于彩色图像来说，如果真的按照上面讲的这样，就真的很麻烦了，所以在OpenCV里，对于彩色图像，我们提供了非常方便的获取像素指针的方式。

### 2.代码实战 ###

**1.灰度图像**

我们知道获取像素指针其实就是提供了一个访问像素的途径，在这里，我们用到一个**at**方法：

如果我们想获取坐标为(x,y)的像素，我们可以使用如下方法：

src_gray.at<uchar>(y, x); //行在前，列在后，y表示行，x表示列

上面会返回一个uchar类型的数据，但是我们是需要一其数值，所以我们可以定义一个整型数据来获取，举个例子：

int sc1 = src_gray.at<uchar>(src_gray.rows/2, src_gray.cols/2);

当然我们也可以使用我们之前学习Scalar类型来获取，因为是单通道，所以后三个位置全为0：

Scalar sc2 = src_gray.at<uchar>(src_gray.rows / 2, src_gray.cols / 2);

上面我们是先使用y，再使用x，这是因为我们是按照行列访问，如果我们是按照点访问，就需要用到我们之前学的点结构了：

src_gray.at<uchar>(Point(x, y));

示例如下：

Scalar sc3 = src_gray.at<uchar>(Point(src_gray.cols / 2, src_gray.rows / 2));

输出代码及结果如下：

cout << "scalar of src_gray(Scalar) : " << sc1 << endl;
    	cout << "scalar of src_gray(int) : " << sc2 << endl;
    	cout << "scalar of src_gray(Point) : " << sc3 << endl;

![20200518175615694.png][]

**2.彩色图像**

我们依然使用**at**方法但是这个时候，我们就不能直接使用int类型了，而且我们也要用到一个新的类型**Vec3b**：

Vec3b sc4 = src.at<Vec3b>(src.rows / 2, src_gray.cols / 2);
    	int B = sc4.val[0];
    	int G = sc4.val[1];
    	int R = sc4.val[2];
    	Scalar sc5 = src.at<Vec3b>(Point(src.cols / 2, src_gray.rows / 2));
    	cout << "scalar of src(Vec3b) : [" << B << ", " << G << ", " << R << "] " << endl;
    	cout << "scalar of src(Scalar) : " << sc5 << endl;

![2020051818314144.png][]

跟上面一样使用**at**方法，但因为是三通道的，所以我们用到新的类型**Vec3b**，定义如下：

typedef Vec<uchar, 3> Vec3b;

我们可以这样理解：**这是一个包含三个uchar类型数据的一个结构**。

然后我们想要获取三个通道的值，我们就依次获取其值就好：

int B = sc4.val[0];
    	int G = sc4.val[1];
    	int R = sc4.val[2];

## 2、控制像素范围 ##

### 1.理论讲解 ###

我们获取到的值，它们是有范围的，我们在最开始也说了，对于灰度图来说，像素的取值范围是0-255，对于彩色图像来说，每个通道的取值范围也是0-255，那我们在操作像素的时候，一旦超过这个范围怎么办呢？

在OpenCV中，我们提供了一个方法来控制其取值范围：

/// saturate_cast (used in image & signal processing) ///
    
    /** @brief Template function for accurate conversion from one primitive type to another.
    
     The function saturate_cast resembles the standard C++ cast operations, such as static_cast\<T\>()
     and others. It perform an efficient and accurate conversion from one primitive type to another
     (see the introduction chapter). saturate in the name means that when the input value v is out of the
     range of the target type, the result is not formed just by taking low bits of the input, but instead
     the value is clipped. For example:
     @code
     uchar a = saturate_cast<uchar>(-100); // a = 0 (UCHAR_MIN)
     short b = saturate_cast<short>(33333.33333); // b = 32767 (SHRT_MAX)
     @endcode
     Such clipping is done when the target type is unsigned char , signed char , unsigned short or
     signed short . For 32-bit integers, no clipping is done.
    
     When the parameter is a floating-point value and the target type is an integer (8-, 16- or 32-bit),
     the floating-point value is first rounded to the nearest integer and then clipped if needed (when
     the target type is 8- or 16-bit).
    
     @param v Function parameter.
     @sa add, subtract, multiply, divide, Mat::convertTo
     */
    template<typename _Tp> static inline _Tp saturate_cast(uchar v)    { return _Tp(v); }
    /** @overload */
    template<typename _Tp> static inline _Tp saturate_cast(schar v)    { return _Tp(v); }
    /** @overload */
    template<typename _Tp> static inline _Tp saturate_cast(ushort v)   { return _Tp(v); }
    /** @overload */
    template<typename _Tp> static inline _Tp saturate_cast(short v)    { return _Tp(v); }
    /** @overload */
    template<typename _Tp> static inline _Tp saturate_cast(unsigned v) { return _Tp(v); }
    /** @overload */
    template<typename _Tp> static inline _Tp saturate_cast(int v)      { return _Tp(v); }
    /** @overload */
    template<typename _Tp> static inline _Tp saturate_cast(float v)    { return _Tp(v); }
    /** @overload */
    template<typename _Tp> static inline _Tp saturate_cast(double v)   { return _Tp(v); }
    /** @overload */
    template<typename _Tp> static inline _Tp saturate_cast(int64 v)    { return _Tp(v); }
    /** @overload */
    template<typename _Tp> static inline _Tp saturate_cast(uint64 v)   { return _Tp(v); }
    
    template<> inline uchar saturate_cast<uchar>(schar v)        { return (uchar)std::max((int)v, 0); }
    template<> inline uchar saturate_cast<uchar>(ushort v)       { return (uchar)std::min((unsigned)v, (unsigned)UCHAR_MAX); }
    template<> inline uchar saturate_cast<uchar>(int v)          { return (uchar)((unsigned)v <= UCHAR_MAX ? v : v > 0 ? UCHAR_MAX : 0); }
    template<> inline uchar saturate_cast<uchar>(short v)        { return saturate_cast<uchar>((int)v); }
    template<> inline uchar saturate_cast<uchar>(unsigned v)     { return (uchar)std::min(v, (unsigned)UCHAR_MAX); }
    template<> inline uchar saturate_cast<uchar>(float v)        { int iv = cvRound(v); return saturate_cast<uchar>(iv); }
    template<> inline uchar saturate_cast<uchar>(double v)       { int iv = cvRound(v); return saturate_cast<uchar>(iv); }
    template<> inline uchar saturate_cast<uchar>(int64 v)        { return (uchar)((uint64)v <= (uint64)UCHAR_MAX ? v : v > 0 ? UCHAR_MAX : 0); }
    template<> inline uchar saturate_cast<uchar>(uint64 v)       { return (uchar)std::min(v, (uint64)UCHAR_MAX); }
    
    template<> inline schar saturate_cast<schar>(uchar v)        { return (schar)std::min((int)v, SCHAR_MAX); }
    template<> inline schar saturate_cast<schar>(ushort v)       { return (schar)std::min((unsigned)v, (unsigned)SCHAR_MAX); }
    template<> inline schar saturate_cast<schar>(int v)          { return (schar)((unsigned)(v-SCHAR_MIN) <= (unsigned)UCHAR_MAX ? v : v > 0 ? SCHAR_MAX : SCHAR_MIN); }
    template<> inline schar saturate_cast<schar>(short v)        { return saturate_cast<schar>((int)v); }
    template<> inline schar saturate_cast<schar>(unsigned v)     { return (schar)std::min(v, (unsigned)SCHAR_MAX); }
    template<> inline schar saturate_cast<schar>(float v)        { int iv = cvRound(v); return saturate_cast<schar>(iv); }
    template<> inline schar saturate_cast<schar>(double v)       { int iv = cvRound(v); return saturate_cast<schar>(iv); }
    template<> inline schar saturate_cast<schar>(int64 v)        { return (schar)((uint64)((int64)v-SCHAR_MIN) <= (uint64)UCHAR_MAX ? v : v > 0 ? SCHAR_MAX : SCHAR_MIN); }
    template<> inline schar saturate_cast<schar>(uint64 v)       { return (schar)std::min(v, (uint64)SCHAR_MAX); }
    
    template<> inline ushort saturate_cast<ushort>(schar v)      { return (ushort)std::max((int)v, 0); }
    template<> inline ushort saturate_cast<ushort>(short v)      { return (ushort)std::max((int)v, 0); }
    template<> inline ushort saturate_cast<ushort>(int v)        { return (ushort)((unsigned)v <= (unsigned)USHRT_MAX ? v : v > 0 ? USHRT_MAX : 0); }
    template<> inline ushort saturate_cast<ushort>(unsigned v)   { return (ushort)std::min(v, (unsigned)USHRT_MAX); }
    template<> inline ushort saturate_cast<ushort>(float v)      { int iv = cvRound(v); return saturate_cast<ushort>(iv); }
    template<> inline ushort saturate_cast<ushort>(double v)     { int iv = cvRound(v); return saturate_cast<ushort>(iv); }
    template<> inline ushort saturate_cast<ushort>(int64 v)      { return (ushort)((uint64)v <= (uint64)USHRT_MAX ? v : v > 0 ? USHRT_MAX : 0); }
    template<> inline ushort saturate_cast<ushort>(uint64 v)     { return (ushort)std::min(v, (uint64)USHRT_MAX); }
    
    template<> inline short saturate_cast<short>(ushort v)       { return (short)std::min((int)v, SHRT_MAX); }
    template<> inline short saturate_cast<short>(int v)          { return (short)((unsigned)(v - SHRT_MIN) <= (unsigned)USHRT_MAX ? v : v > 0 ? SHRT_MAX : SHRT_MIN); }
    template<> inline short saturate_cast<short>(unsigned v)     { return (short)std::min(v, (unsigned)SHRT_MAX); }
    template<> inline short saturate_cast<short>(float v)        { int iv = cvRound(v); return saturate_cast<short>(iv); }
    template<> inline short saturate_cast<short>(double v)       { int iv = cvRound(v); return saturate_cast<short>(iv); }
    template<> inline short saturate_cast<short>(int64 v)        { return (short)((uint64)((int64)v - SHRT_MIN) <= (uint64)USHRT_MAX ? v : v > 0 ? SHRT_MAX : SHRT_MIN); }
    template<> inline short saturate_cast<short>(uint64 v)       { return (short)std::min(v, (uint64)SHRT_MAX); }
    
    template<> inline int saturate_cast<int>(unsigned v)         { return (int)std::min(v, (unsigned)INT_MAX); }
    template<> inline int saturate_cast<int>(int64 v)            { return (int)((uint64)(v - INT_MIN) <= (uint64)UINT_MAX ? v : v > 0 ? INT_MAX : INT_MIN); }
    template<> inline int saturate_cast<int>(uint64 v)           { return (int)std::min(v, (uint64)INT_MAX); }
    template<> inline int saturate_cast<int>(float v)            { return cvRound(v); }
    template<> inline int saturate_cast<int>(double v)           { return cvRound(v); }
    
    template<> inline unsigned saturate_cast<unsigned>(schar v)  { return (unsigned)std::max(v, (schar)0); }
    template<> inline unsigned saturate_cast<unsigned>(short v)  { return (unsigned)std::max(v, (short)0); }
    template<> inline unsigned saturate_cast<unsigned>(int v)    { return (unsigned)std::max(v, (int)0); }
    template<> inline unsigned saturate_cast<unsigned>(int64 v)  { return (unsigned)((uint64)v <= (uint64)UINT_MAX ? v : v > 0 ? UINT_MAX : 0); }
    template<> inline unsigned saturate_cast<unsigned>(uint64 v) { return (unsigned)std::min(v, (uint64)UINT_MAX); }
    // we intentionally do not clip negative numbers, to make -1 become 0xffffffff etc.
    template<> inline unsigned saturate_cast<unsigned>(float v)  { return static_cast<unsigned>(cvRound(v)); }
    template<> inline unsigned saturate_cast<unsigned>(double v) { return static_cast<unsigned>(cvRound(v)); }
    
    template<> inline uint64 saturate_cast<uint64>(schar v)      { return (uint64)std::max(v, (schar)0); }
    template<> inline uint64 saturate_cast<uint64>(short v)      { return (uint64)std::max(v, (short)0); }
    template<> inline uint64 saturate_cast<uint64>(int v)        { return (uint64)std::max(v, (int)0); }
    template<> inline uint64 saturate_cast<uint64>(int64 v)      { return (uint64)std::max(v, (int64)0); }
    
    template<> inline int64 saturate_cast<int64>(uint64 v)       { return (int64)std::min(v, (uint64)LLONG_MAX); }
    
    /** @overload */
    template<typename _Tp> static inline _Tp saturate_cast(float16_t v) { return saturate_cast<_Tp>((float)v); }
    
    // in theory, we could use a LUT for 8u/8s->16f conversion,
    // but with hardware support for FP32->FP16 conversion the current approach is preferable
    template<> inline float16_t saturate_cast<float16_t>(uchar v)   { return float16_t((float)v); }
    template<> inline float16_t saturate_cast<float16_t>(schar v)   { return float16_t((float)v); }
    template<> inline float16_t saturate_cast<float16_t>(ushort v)  { return float16_t((float)v); }
    template<> inline float16_t saturate_cast<float16_t>(short v)   { return float16_t((float)v); }
    template<> inline float16_t saturate_cast<float16_t>(unsigned v){ return float16_t((float)v); }
    template<> inline float16_t saturate_cast<float16_t>(int v)     { return float16_t((float)v); }
    template<> inline float16_t saturate_cast<float16_t>(uint64 v)  { return float16_t((float)v); }
    template<> inline float16_t saturate_cast<float16_t>(int64 v)   { return float16_t((float)v); }
    template<> inline float16_t saturate_cast<float16_t>(float v)   { return float16_t(v); }
    template<> inline float16_t saturate_cast<float16_t>(double v)  { return float16_t((float)v); }
    
    //! @}
    
    } // cv

这里有很多定义，其实这个定义的含义很简单：

> 大于255的值，变为255；
> 
> 小于0的值，变为0；
> 
> 其他的不改变；

这样我们就可以把范围控制在0-255之间。如果有学过激活函数的同学对这个形式就很清晰了，这个也可以算作图像像素的激活函数。

### 2.代码实战 ###

我们讲完了功能，我们做个实验，我们定义三个数据，然后使用这个定义控制其范围：

int a = saturate_cast<uchar>(-100); //返回 0
    	cout <<"a = "<< a << endl;
    	int b = saturate_cast<uchar>(100); //返回 100
    	cout << "b = " << b << endl;
    	int c = saturate_cast<uchar>(1000); //返回 255
    	cout << "c = " << c << endl;

执行结果如下：

![20200518185315748.png][]

# 说在后面的话 #

从今天这节内容开始，我们就要走进像素的世界了。也从今天开始，我们就要进入Mat的世界，带领Mat一起征战OpenCV的世界。

这个世界我们会遇到很多困难，但是不要担心，因为我们从未畏惧。

讲真，写这个很心累，教别人和自己学完全不是一个档次。学东西的时候，自己明白了就好，但是讲东西的时候，要给别人彻底讲明白。我不知道我的讲解水平如何，但是我的每一篇博客都是认真去写的，希望大家能够提出宝贵意见。我们一起加油！

[Mat]: https://blog.csdn.net/shuiyixin/article/details/106014341
[Point_Size]: https://blog.csdn.net/shuiyixin/article/details/106046827
[Rect]: https://blog.csdn.net/shuiyixin/article/details/106085233
[Scalar]: https://blog.csdn.net/shuiyixin/article/details/106111460
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodWl5aXhpbg_size_16_color_F74FFF_t_70]: /images/20230312/906f41d3003b47379430dd851af13e68.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodWl5aXhpbg_size_16_color_FFF74F_t_70]: /images/20230312/63d88ddad4cf449c8cffb30ca91787a3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodWl5aXhpbg_size_46_color_F1474F_t_70]: /images/20230312/0e9f405718a24c9a88b90ea2fe12f0ea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NodWl5aXhpbg_size_46_color_FFFFFF_t_70]: /images/20230312/9af51248122d4972bf171ce39a598644.png
[20200518175615694.png]: /images/20230312/e785d48bf1e34c59a52059a5cce88a73.png
[2020051818314144.png]: /images/20230312/6d87fe7b3be346f7a5aebc58d237e5d1.png
[20200518185315748.png]: /images/20230312/7d3240661953405a99b910d77da9a170.png