## 哈希切割、Top K问题

> **问题一：给一个超过100G大小的log file, log中存着IP地址, 设计算法找到出现次数最多的IP地址？**
> **问题二：与上题目条件相同，如何找出Top K的IP？**
> **问题三：直接用Linux命令如何实现？**







对于问题一：

- 很显然100G的文件直接存入内存中的代价太高了，所以我们需要将文件切分为1000份，逐个加载到内存中
- 将切分后的每个文件中的IP加载到哈希表，由于需要统计次数，所以需要使用哈希表的 `Key-Value` 模型，使用哈希函数将IP转换为位置`int index = IPHash(char* ip)%1000`
- 这样的话相同的IP就会映射到相同的位置，执行Value++即可统计次数
- 最后只要一个Key对应着最大的Value即是我们想要的结果

对于问题二：
要想统计次数最多的前K个IP，这里需要建K个元素的小堆，每次选出的IP与堆顶元素比较如果大于堆顶元素就替换掉堆顶元素并且向下调堆，这样到最后堆中的数据就是出现次数最多的前K个IP
对于问题三：
`cat logfile | sort -r | uniq | awk NR==排行数`
先使用sort -r进行次数由多到少的排序，再使用uniq去重，最后使用awk获取结果

![mark](https://img.zouchanglin.cn///20200201/8kdGXbvdYoiG.png)



## 位图应用

> **问题四：给定100亿个整数，设计算法找到只出现一次的整数？**
> **问题五：给两个文件，分别有100亿个整数，只有1G内存，如何找到两个文件的交集？**

对于问题四：
分析一下100亿个数字需要的内存：4×100 ×10^8 / 1024/1024/1024 = 37.252G
很显然与题目一类似，可以将这100亿个数字分100份分别存储在文件中，通过`int index = NumHash(int num) %100` 哈希切分，在每份文件中找出只出现一次的数字，最后将这100分文件结果归纳在一起即可找出！
但是可以使用位图来解决这种 **存在与否、出现一次** 的问题，如果是判断存不存在之类的问题可以使用一个位就可以表示，如：0表示不存在，1表示存在，在本题目中统计只出现一次则需要使用一个位来表示，0表示不存在或者出现多次，1表示只出现一次！

对于问题五：
也是只有1G内存，在这里两个文件则需要使用两个位图，然后根据两个位图的交集，也就是将两个位图`&`操作来求出两个文件的交集！

## 位图变形

> **问题六：1个文件有100亿个int,1G内存,设计算法找到出现次数不超过2次的所有整数**

对于问题六：
这个问题实际上是问题四的变形，分析可知不超过两次的情况直接使用两个比特位来完成，00表示0次，01表示一次，10表示两次，11表示超过两次，这样处理问题无论怎么变化都是有效的！

## 布隆过滤器

> **问题七：给两个文件,分别有100亿个query(查询),我们只有1G内存,如何找到两个文件交集?分别给出精确算法和近似算法?**
> **问题八：如何扩展BloomFilter使得它支持删除元素的操作？**
> **问题九：如何扩展BloomFilter使得它支持计数操作？**

对于问题七：

- 精确算法
  现有100亿条查询，预估每一条大小为20字节，算出大小为96.7G，很显然需要特殊的处理，思想和问题一是一致的，先使用哈希函数做分割，可以把这两个文件分别分割为1000个文件，这样问题就变成了逐个求这1000个文件和另外1000个文件的交集，最后再整合结果即可！
- 近似算法
  使用布隆进行过滤，将其中的某一个文件映射到位图当中，取另一文件的内容进行比对，如果不存在，那么就不是交集，如果存在，可视为交集！
  注意：虽然布隆在映射时会映射多个位置，但判断是否在位图中存在时还是可能出现误差，故此方法为近似算法！

对于问题八和问题九：
布隆的删除和计数可归为一类问题，原本布隆是一个元素映射到多个位置上，这个位置上的值是一个Key,现在将其改为数据存在的个数，每当映射到相同的位置，该位置上的数进行加1，最后每个位置上的值表示出现某一元素映射到该位的次数！标准的BloomFilter只支持插入和查找两种操作，如果表达的集合是静态集合的时候，在初始化集合大小，确定hash k的个数，控制错误率的基础上，BloomFilter可以很好的满足需求。但是对于一些动态集合，BloomFilter不满足需求了，其不支持删除操作，现引入Counting BloomFilter，能解决相关问题，具体见：https://blog.csdn.net/fuwei736349065/article/details/75642933

## 倒排索引

> **问题十：给上千个文件,每个文件大小为1K—100M。给n个词,设计算法对每个词找到所有包含它的文件,你只有100K内存**

![mark](https://img.zouchanglin.cn///20200201/QkMvAsIm1ueU.png)

这种做法就是根据文件中的Key去建立哈希表，采用拉链法，凡是包含key的文件都会被挂载到对应的位置，搜索引擎就是这种做法，很显然那些能被百度排在最前面的位置的网页很可能就是在拉链的前几个位置，所以会呈现在前面！

哈希与海量数据处理

## 关于卷积

卷积是分析数学中一种重要的运算。卷积是一种线性运算,图像处理中常见的mask运算都是卷积，广泛应用于图像滤波。高斯变换就是用高斯函数对图像进行卷积，卷积操作是图像变换的基础。





如果我们称$(f * g)(n)$是f、g的卷积：

连续型卷积的公式
$$
(f * g)(n)=\int_{-\infty}^{\infty} f(\tau) g(n-\tau) d \tau
$$

离散型卷积的公式
$$
(f * g)(n)=\int_{\tau=-\infty}^{\infty} f(\tau) g(n-\tau)
$$

从中我们可以得出：
$$
n=\tau+(n-\tau)
$$

假设现有两个骰子，随机掷骰子点数和为4

![mark](https://img.zouchanglin.cn///20200201/kbGXUiIrXGb7.png)

那么这样的概率就是`f(1)*g(3)+f(2)*g(2)+f(3)*g(1)`符合:

$$
(f * g)(4)=\sum_{m=1}^{3} f(4-m) g(m)
$$

下面这张图可以很好的帮助理解卷积：

![]( https://img.zouchanglin.cn/EUpmz82dcn.gif)

用一个模板和一幅图像进行卷积，对于图像上的一个点，让模板的原点和该点重合，然后模板上的点和图像上对应的点相乘，然后各点的积相加，就得到了该点的卷积值。对图像上的每个点都这样处理。由于大多数模板都是对称的，所以模板不旋转。卷积是一种积分运算，用来求两个曲线重叠区域面积。可以看作加权求和，可以用来消除噪声、特征增强。

把一个点的像素值用它周围的点的像素值的加权平均代替。
卷积是一种线性运算,图像处理中常见的mask运算都是卷积，广泛应用于图像滤波。
卷积关系最重要的一种情况，就是在信号与线性系统或数字信号处理中的卷积定理。利用该定理，可以将时间域或空间域中的卷积运算等价为频率域的相乘运算，从而利用FFT等快速算法，实现有效的计算，节省运算代价。

## 卷积核

这个核本质上是一个大小固定，由数值参数构成的数组，数组的标定点通常位于数组的中心。数组的大小被称为核支撑。单就技术而言，核支撑实际上仅仅由核数组的非零部分组成。
上图中不停移动的白色块变是卷积核！

## 卷积函数：cvFilter2D、filter2D()

### cvFilter2D()

opencv中的c语言函数，参数如下：

src：输入图像.
dst：输出图像.
kernel：卷积核, 单通道浮点矩阵. 如果想要应用不同的核于不同的通道，先用 cvSplit 函数分解图像到单个色彩通道上，然后单独处理。
anchor：核的锚点表示一个被滤波的点在核内的位置。 锚点应该处于核内部。缺省值 (-1, -1) 表示锚点在核中心。
函数 cvFilter2D 对图像进行线性滤波，支持 In-place 操作。当核运算部分超出输入图像时，函数从最近邻的图像内部象素差值得到边界外面的象素值。

```cpp
void cvFilter2D( const CvArr* src, CvArr* dst,
                 const CvMat* kernel,
                 CvPoint anchor = cvPoint(-1,-1));
```

### filter2D()

opencv中的c++函数，参数如下：

InputArray src: 输入图像
OutputArray dst: 输出图像，和输入图像具有相同的尺寸和通道数量
int ddepth: 目标图像深度，如果没写将生成与原图像深度相同的图像。原图像和目标图像支持的
当ddepth输入值为-1时，目标图像和原图像深度保持一致
InputArray kernel: 卷积核(或者是相关核), 一个单通道浮点型矩阵。如果想在图像不同的通道使用不同的kernel，可以先使用split()函数将图像通道事先分开
Point anchor: 内核的基准点(anchor)，其默认值为(-1, -1)说明位于kernel的中心位置。基准点即kernel中与进行处理的像素点重合的点
double delta: 在储存目标图像前可选的添加到像素的值，默认值为0
int borderType: 像素向外逼近的方法，默认值是BORDER_DEFAULT,即对全部边界进行计算。
该函数使用于任意线性滤波器的图像，支持就地操作。当其中心移动到图像外，函数可以根据指定的边界模式进行插值运算。**函数实质上是计算kernel与图像的相关性而不是卷积!**

```cpp
CV_EXPORTS_W void filter2D( InputArray src, OutputArray dst, int ddepth,
                            InputArray kernel, Point anchor=Point(-1,-1),
                            double delta=0, int borderType=BORDER_DEFAULT );
```

### 原理

对于图像的每一个像素点，计算它的邻域像素和滤波器矩阵的对应元素的乘积，然后加起来，作为该像素位置的值，这样就完成了滤波过程！

## 卷积与相关

对图像和滤波矩阵进行逐个元素相乘再求和的操作就相当于将一个二维的函数移动到另一个二维函数的所有位置，这个操作就叫卷积或者相关。卷积和相关的差别是，卷积需要先对滤波矩阵进行180的翻转，但如果矩阵是对称的，那么两者就没有什么差别了。
图像卷积操作的本质是矩阵卷积。某些特殊的卷积核会使图像产生特殊的效果：

## 图像处理

下面把均把相关性计算看成是卷积运算，从本质上来说其实就是卷积运算，相当于把矩阵旋转了180°所以看成是卷积！

### 边缘检测卷积核

![mark](https://img.zouchanglin.cn///20200201/xfJ8cehKnRgv.png)

### 图像锐化卷积核

```
-1, -1, -1,
-1,  9, -1,
-1, -1, -1
```
图像的锐化和边缘检测很像，首先找到边缘，然后把边缘加到原来的图像上面，这样就强化了图像的边缘，使图像看起来更加锐利了。这两者操作统一起来就是锐化滤波器了，也就是在边缘检测滤波器的基础上，再在中心的位置加1，这样滤波后的图像就会和原始的图像具有同样的亮度了，但是会更加锐利。

![mark](https://img.zouchanglin.cn///20200201/ONg2WuK8gTyq.png)

### 更加强调边缘的卷积核

```
1,  1,  1,
1, -7,  1,
1,  1,  1
```

![mark](https://img.zouchanglin.cn///20200201/uvbWV6H1vymP.png)

### 浮雕效果的卷积核

```
-6, -3, 0,
-3,  1, 3,
0,  3, 6
```

![mark](https://img.zouchanglin.cn///20200201/twa8VgsdocK5.png)

### 模糊图像的卷积核

Smooth/Blur 是图像处理中最简单和常用的操作之一，使用该操作的原因之一就为了给图像预处理时候减低噪声，使用Smooth/Blur操作其背后是数学的卷积计算

![mark](https://img.zouchanglin.cn///20200201/WVYQGk8aQgYG.png)

![mark](https://img.zouchanglin.cn///20200201/tkJIBrFXx9zQ.png)

卷积过程：6x6上面是个3x3的窗口，从左向右，从上向下移动，黄色的每个像个像素点值之和取平均值赋给中心红色像素作为它卷积处理之后新的像素值。每次移动一个像素格。

#### 归一化滤波（均值滤波）
$$
k=\frac{1}{\left(k_{\text {width }} * k_{\text {width }}\right)}\left[\begin{array}{ccccc}
1 & 1 & 1 & \ldots & 1 \\\\
1 & 1 & 1 & \ldots & 1 \\\\
1 & 1 & 1 & \ldots & 1 \\\\
1 & 1 & 1 & \ldots & 1 \\\\
\ldots & \ldots & \ldots & \ldots & 1 \\\\
1 & 1 & 1 & \ldots & 1
\end{array}\right]
$$

#### 高斯滤波
$$
G_{0}(x, y)=A e *\left(\frac{-\left(x-\mu_{X}\right)^{2}}{2 \sigma_{X}^{2}}+\frac{-\left(\mathrm{y}-\mu_{y}\right)^{2}}{2 \sigma_{y}^{2}}\right)
$$

均值模糊

```
blur(Mat src, Mat dst, Size(xradius, yradius), Point(-1,-1));
```

高斯模糊
$$
dst(x, y)=\sum_{0 \leq x<\text { ker nel.cols }} \text { kernel }(x, y) * \operatorname{src}\left(x+x^{1}-\text { anchor. } x, y+y^{1}-\text { anchor.y }\right)
$$

```
GaussianBlur(Mat src, Mat dst, Size(11, 11), sigmax, sigmay);
```

![mark](https://img.zouchanglin.cn///20200201/IeqktBPOyloY.png)

其中Size（x, y）, x, y 必须是正数而且是奇数

![mark](https://img.zouchanglin.cn///20200201/p7bdTSBROcjY.png)

```cpp
#include <iostream>
#include <opencv2\opencv.hpp>

using namespace cv;
using namespace std;

int main(int argc, char *argv[]) {	
	Mat src = imread("C:\\Users\\Tim\\Desktop\\Image\\book.png");

	namedWindow("src_window", CV_WINDOW_AUTOSIZE);
	imshow("src_window", src);

	Mat dst = Mat::zeros(src.size(), src.type());

	//定义卷积核

	//边缘检测
	//Mat C = (Mat_<double>(3, 3) << -1, -2, -1, 0, 0, 0, 1, 2, 1); // Sobel算子 横向边缘检测
	//Mat C = (Mat_<double>(3, 3) << -1,  0, 1, -2, 0, 2, -1, 0, 1); // Sobel算子 纵向边缘检测
	//Mat C = (Mat_<double>(3, 3) << -1, -1, -1, 0, 0, 0, 1, 1, 1); // Prewitt算子 横向边缘检测
	//Mat C = (Mat_<double>(3, 3) << -1, 0, 1, -1, 0, 1, -1, 0, 1); // Prewitt算子 纵向边缘检测
	//Mat C = (Mat_<double>(3, 3) << -1, -1, -1, -1, 8, -1, -1, -1, -1); // Laplacian算子 边缘检测

	//图像锐化
	//Mat C = (Mat_<double>(3, 3) << -1, -1, -1, -1, 9, -1, -1, -1, -1);
	//Mat C = (Mat_<double>(3, 3) << 1, 1, 1, 1, -7, 1, 1, 1, 1);//更加强调边缘的锐化

	//浮雕
	//Mat C = (Mat_<double>(3, 3) << -6, -3, 0, -3, 1, 3, 0, 3, 6);
	filter2D(src, dst, src.depth(), C, Point(-1, -1));

	namedWindow("dst_window", CV_WINDOW_AUTOSIZE);
	imshow("dst_window", dst);

	moveWindow("src_window", 1, 1);
	moveWindow("dst_window", 1, 1);
	waitKey(0);
	return 0;
}
```

```cpp
#include <iostream>
#include <opencv2\opencv.hpp>

using namespace cv;
using namespace std;

int main(int argc, char *argv[]){

	//Mat src = imread("C:\\Users\\Tim\\Desktop\\Image\\a.jpg");
	Mat src = imread("C:\\Users\\Tim\\Desktop\\test.png");
	if (src.empty()){
		cout << "load image filed..." << endl;
		return -1;
	}

	namedWindow("src_window", CV_WINDOW_AUTOSIZE);
	imshow("src_window", src);

	namedWindow("dst_window", CV_WINDOW_AUTOSIZE);
	Mat dst;
	//3*3均值滤波模糊
	blur(src, dst, Size(3, 3), Point(-1, -1));
	//GaussianBlur(src, dst, Size(3, 3), 11, 11);//高斯滤波
	imshow("dst_window", dst);
	waitKey(0);
	return 0;
}
```

#### 中值滤波
中值滤波对椒盐噪声有很好的抑制作用
椒盐噪声也称为脉冲噪声，是图像中经常见到的一种噪声，它是一种随机出现的白点或者黑点，可能是亮的区域有黑色像素或是在暗的区域有白色像素（或是两者皆有）。盐和胡椒噪声的成因可能是影像讯号受到突如其来的强烈干扰而产生、类比数位转换器或位元传输错误等。例如失效的感应器导致像素值为最小值，饱和的感应器导致像素值为最大值。

- 中值滤波器
中值滤波器（Median filtering） 如其名所隐含的，它将一个像素的值用该像素邻域中强度值的中间值来取代（计算中间值的过程中，也会将该像素的原始值包含），中值滤波器在处理盐和胡椒噪声上能提供绝佳的噪声降低效能。
- 伪中值滤波器
为了改进中值滤波器的计算速率，伪中值滤波器（Pseudo-median filtering） 以近似的方法算出中间值。

![](https://img.zouchanglin.cn///20200201/Bef1Tc5lT507.png)

- ##### 双边滤波

- 均值模糊无法克服边缘像素信息丢失缺陷。原因是均值滤波是基于平均权重

- 高斯模糊部分克服了该缺陷，但是无法完全避免，因为没有考虑像素值的不同

- 高斯双边模糊 – 是边缘保留的滤波方法，避免了边缘信息丢失，保留了图像轮廓不变

双边滤波就是在对像素进行卷积时，不单单用位置（定义域）信息，还要用到值域信息。你看看高斯卷积的模板，就能明白什么是位置信息。值域信息就是当前像素与邻域像素的差别，差别越大（也就是边界位置），权重越小，这个小权重施加到高斯模板上，就会让高斯权重变小，模糊变弱，也就起到了在边界处弱化高斯模糊的作用，双边滤波的保边作用就是这样实现的。而在平坦区域，值域与领域像素差别小，几乎为零（指数函数用到了），那么权重最大接近1，施加到高斯权重上几乎对高斯不起作用，也就是在平坦区实际执行的就是高斯滤波。
计算公式如下：
$$
\mathrm{g}(i, j)=\frac{\sum_{k, l} f(k, l) \omega(i, j, k, l)}{\sum_{k, l} \omega(i, j, k, l)}
$$

其中$w(i,j,k,l)$的计算方法如下:
$$
\begin{array}{c}
d(i, j, k, l)=\exp \left(-\frac{(i-k)^{2}+(j-l)^{2}}{2 \sigma_{d}^{2}}\right) \\\\
r(i, j, k, l)=\exp \left(-\frac{\|f(i, j)-f(k-l)\|^{2}}{2 \sigma_{r}^{2}}\right) \\\\
r(i, j, k, l)=\exp \left(-\frac{(i-k)^{2}+(j-l)^{2}}{2 \sigma_{d}^{2}}-\frac{\|f(i, j)-f(k-l)\|^{2}}{2 \sigma_{r}^{2}}\right)
\end{array}
$$

d函数是根据像素距离选择权重，距离越近权重越大，这一点和方框滤波，高斯滤波方式相同。而r函数则是根据像素的差异来分配权值。如果两个像素值越接近，即使相距较远，也比差异大而距离近的像素点权重大。正是r函数的作用，使得边缘，即相距近但差异大的像素点的特性得以保留!

![](https://img.zouchanglin.cn///20200201/cq97LmaNpSCq.png)

#### 模糊相关函数

中值模糊medianBlur（Mat src, Mat dest, ksize）
双边模糊bilateralFilter(src, dest, d=15, 150, 3);
5 –计算的半径，半径之内的像数都会被纳入计算，如果提供-1 则根据sigma space参数取值
50 – sigma color 决定多少差值之内的像素会被计算
3 – sigma space 如果d的值大于0则声明无效，否则根据它来计算d值
中值模糊的ksize大小必须是大于1而且必须是奇数。

```cpp
#include <iostream>
#include <opencv2\opencv.hpp>

using namespace cv;
using namespace std;

int main(int argc, char **argv)
{

	Mat src = imread("C:\\Users\\Tim\\Desktop\\Image\\notbeautify1.png");
	//Mat src = imread("C:\\Users\\Tim\\Desktop\\Image\\AI.png");

	Mat dst;
	if (src.empty())
	{
		cout << "load image filed..." << endl;
		return -1;
	}

	namedWindow("src_window", CV_WINDOW_AUTOSIZE);
	imshow("src_window", src);


	//中值滤波去掉椒盐噪声
	//medianBlur(src, dst, 3);

	//双边滤波
	bilateralFilter(src, dst, 15, 100, 3);
	namedWindow("medianBlur_dst", CV_WINDOW_AUTOSIZE);
	imshow("medianBlur_dst", dst);


	Mat gblur;
	GaussianBlur(src, gblur, Size(15, 15), 3, 3);
	namedWindow("HelloWorld",CV_WINDOW_AUTOSIZE);
	namedWindow("bglur_dst", CV_WINDOW_AUTOSIZE);
	imshow("bglur_dst", gblur);

	//通过掩模提升对比度
	Mat retImg;
	Mat kernal = (Mat_<int>(3, 3) << 0, -1, 0, -1, 5, -1, 0, -1, 0);
	filter2D(dst, retImg, dst.depth(), kernal, Point(-1, -1), 0);

	namedWindow("retImg", CV_WINDOW_AUTOSIZE);
	imshow("retImg", retImg);

	waitKey(0);
	return 0;
}
```
下面经过上述各种滤波器处理之后的效果：
![](https://img.zouchanglin.cn/20220101085008.png)

神奇的卷积核

## Mat对象与IplImage对象

- Mat对象OpenCV2.0之后引进的图像数据结构、自动分配内存、不存在内存泄漏的问题，是面向对象的数据结构。分了两个部分，头部与数据部分
- IplImage是从2001年OpenCV发布之后就一直存在，是C语言风格的数据结构，需要开发者自己分配与管理内存，对大的程序使用它容易导致内存泄漏问题，下面是IplImage结构体的定义：



```cpp
typedef struct _IplImage
{
        int nSize;         // IplImage大小
        int ID;            // 版本 (=0)
        int nChannels;     // 大多数OPENCV函数支持1,2,3 或 4 个通道 
        int alphaChannel; // 被OpenCV忽略 
        int depth;         // 像素的位深度，主要有以下支持格式： IPL_DEPTH_8U, IPL_DEPTH_8S, IPL_DEPTH_16U,IPL_DEPTH_16S, IPL_DEPTH_32S,IPL_DEPTH_32F 和IPL_DEPTH_64F 
        char colorModel[4]; // 被OpenCV忽略
        char channelSeq[4]; // 同上
        int dataOrder;     // 0 - 交叉存取颜色通道, 1 - 分开的颜色通道.只有cvCreateImage可以创建交叉存取图像
        int origin;        // 图像原点位置： 0表示顶-左结构,1表示底-左结构
        int align;         // 图像行排列方式 (4 or 8)，在 OpenCV 被忽略，使用 widthStep 代替
        int width;        // 图像宽像素数 
        int height;        // 图像高像素数
        struct _IplROI *roi; // 图像感兴趣区域，当该值非空时，只对该区域进行处理
        struct _IplImage *maskROI; // 在 OpenCV中必须为NULL
        void *imageId;     // 同上
        struct _IplTileInfo *tileInfo; //同上
        int imageSize;     // 图像数据大小(在交叉存取格式下ImageSize=image->height*image->widthStep），单位字节
        char *imageData;    // 指向排列的图像数据
        int widthStep;     // 排列的图像行大小，以字节为单位
        int BorderMode[4]; // 边际结束模式, 在 OpenCV 被忽略
        int BorderConst[4]; // 同上
        char *imageDataOrigin; // 指针指向一个不同的图像数据结构（不是必须排列的），是为了纠正图像内存分配准备的 

} IplImage;
```

## Mat对象使用

### 基本概念

#### 通道

把图像分解成一个或多个颜色成分！

- 单通道：一个像素点只需一个数值表示，只能表示灰度，0为黑色
- 三通道：RGB模式，把图像分为红绿蓝三个通道，可以表示彩色，全0表示黑色
- 四通道：在RGB基础上加上alpha通道，表示透明度，`alpha=0`表示全透明
- 双通道：双通道图像不常见，通常在程序处理中会用到，如傅里叶变换，可能会用到，一个通道为实数，一个通道为虚数，主要是编程方便

![mark](https://img.zouchanglin.cn///20200201/NEiPsmJ6FUAr.png)

 通过画图板的各种格式可以保存出不同的类型 

![mark](https://img.zouchanglin.cn///20200201/aiXHO94eX9Yy.png)

- #### 深度

深度即位数（比特数）

- 位深：一个像素点所占的总位数，也叫像素深度、图像深度等

- 位深 = 通道数 × 每个通道所占位数

- 256色图：n位的像素点可以表示2^n种颜色，称2^n色图，n=8时为256色图

- 8位RGB与8位图：前者的位数指每个通道所占的位数，后者指整个像素点共占的位数

- 8位RGB是一个24位图，也称为真彩

### Mat对象构造函数

- `Mat()`
无参数构造方法

- `Mat(int rows, int cols, int type)`
创建行数为 rows，列数为 col，类型为 type 的图像

- `Mat(Size size, int type)`
创建大小为 size，类型为 type 的图像

- `Mat(int rows, int cols, int type, const Scalar& s)`
创建行数为 rows，列数为 col，类型为 type 的图像，并将所有元素初始化为值s

- `Mat(Size size, int type, const Scalar& s)`
创建大小为 size，类型为 type 的图像，并将所有元素初始化为值 s

- `Mat(const Mat& m)`
将m赋值给新创建的对象，此处不会对图像数据进行复制，m和新对象共用图像数据，属于**浅拷贝**

- `Mat(int rows, int cols, int type, void* data, size_t step=AUTO_STEP)`
创建行数为rows，列数为col，类型为type的图像，此构造函数不创建图像数据所需内存，而是直接使用data所指内存，图像的行步长由 step指定

- `Mat(Size size, int type, void* data, size_t step=AUTO_STEP)`
创建大小为size，类型为type的图像，此构造函数不创建图像数据所需内存，而是直接使用data所指内存，图像的行步长由step指定

- `Mat(const Mat& m, const Range& rowRange, const Range& colRange)`
创建的新图像为m的一部分，具体的范围由rowRange和colRange指定，此构造函数也不进行图像数据的复制操作，新图像与m共用图像数据

- `Mat(const Mat& m, const Rect& roi)`
创建的新图像为m的一部分，具体的范围roi指定，此构造函数也不进行图像数据的复制操作，新图像与m共用图像数据

例如：`Mat M(2,2,CV_8UC3, Scalar(0,0,255))`
这些构造函数中，很多都涉及到类型type。type可以是`CV_8UC1`，`CV_16SC1`，`CV_64FC4` 等其中前两个参数分别表示行(row)跟列(column)、第三个`CV_8UC3`中的8表示每个通道占8位、U表示无符号、C表示Char类型、3表示通道数目是3，第四个参数是向量表示初始化每个像素值是多少，向量长度对应通道数目一致
如果你需要更多的通道数，需要用宏 `CV_8UC(n)` ，例如：
`Mat M(3,2, CV_8UC(5))` 创建行数为 3，列数为 2，通道数为 5 的图像。

### Mat对象常用方法

- 部分复制：一般情况下只会复制Mat对象的头和指针部分，不会复制数据部分

  ```cpp
  Mat A= imread("XXX");
  Mat B(A)  // 只复制头信息，浅拷贝
  ```

*  完全复制：如果想把Mat对象的头部和数据部分一起复制，可以通过如下两个API实现

  ```cpp
  Mat F = A.clone();  
  Mat G;
  A.copyTo(G);
  ```

Mat对象分为头部与数据部分，赋值操作和拷贝构造函数只会复制头部，要想用深拷贝只能使用`clone()` 、 `copyTo(Mat dst,int type)` ! 

```cpp
#include <iostream>
#include <opencv2\opencv.hpp>

using namespace cv;
using namespace std;

int main(int argc,char **argv)
{
	Mat src = imread("C:/Users/Tim/Desktop/Image/a.jpg");

	if (src.empty())
	{
		std::cout << "load image filed" << std::endl;
		return -1;
	}

	namedWindow("input window",CV_WINDOW_AUTOSIZE);
	imshow("input window", src);

	//通过ctreat函数创建
	Mat m_c;
	m_c.create(4, 4, CV_8UC2);
	cout << m_c << endl;

	//定义了一个dst对象的时候只是创建了Mat对象的头部
	Mat dst;
	dst = Mat(src.size(), src.type());
	dst = Scalar(127, 0, 255);

	namedWindow("output window", CV_WINDOW_AUTOSIZE);
	imshow("output window", dst);

	//都是深拷贝
	dst = src.clone();
	src.copyTo(dst);

	//获取通道数
	cvtColor(src, dst, CV_BGR2GRAY);
	cout << "src.channels():" << src.channels() << endl;
	cout << "dst.channels():" << dst.channels() << endl;

	//获取首行像素指针
	const uchar* firstRow = dst.ptr<uchar>(0);

	//获取行像素、列像素
	int row = dst.rows;
	int col = dst.cols;

	//创建行数为 rows，列数为 col，类型为 type 的图像，并将所有元素初始化
	Mat m(5, 5, CV_8UC3, Scalar(0, 0, 255));
	cout << m << endl;

	namedWindow("smail", CV_WINDOW_AUTOSIZE);
	imshow("smail", m);


	//定义小数组
	Mat C = (Mat_<double>(3, 3) << 0, -1, 0, -1, 5, -1, 0, -1, 0);
	cout << C << endl;
	
	waitKey(0);
	return 0;
}
```



![mark](https://img.zouchanglin.cn///20200201/GFEBLdf8z6x0.png)

这是创建的5*5的矩阵

![mark](https://img.zouchanglin.cn///20200201/yPvpg7KnhRe8.png)

#### 关于Scalar

查看源码opencv3源码， 发现Scalar做成了模板类，其中有如下构造函数：可以看到，Scalar是一个由长度为4的数组作为元素构成的结构体，Scalar最多可以存储四个值，没有提供的值默认是0。
Scalar常用的使用场景如下：

```
Mat M(7,7,CV_32FC2,Scalar(1,3));
```



上面的代码表示：创建一个2通道，且每个通道的值都为（1, 3），深度为32，7行7列的图像矩阵。CV_32F表示每个元素的值的类型为32位浮点数，C2表示通道数为2，Scalar（1,3）表示对矩阵每个元素都赋值为（1, 3），第一个通道中的值都是1，第二个通道中的值都是3.
`dst = Scalar(127, 0, 255)` 上述代码中颜色转换过来就是这样的：

![mark](https://img.zouchanglin.cn///20200201/BuPowS1f972o.png)

### Mat对象使用-四个要点

- 输出图像的内存是自动分配的

- 使用OpenCV的C++接口，不需要考虑内存分配问题

- 赋值操作和拷贝构造函数只会复制头部分

- 使用clone与copyTo两个函数实现数据完全复制

## 绘制形状与文字

### Point与Scalar

Point表示2D平面上一个点，其成员就是 x,y 坐标

Scalar表示四个元素的向量，表示 RGB 三个通道

### 代码

```cpp
#include <iostream>
#include <opencv2\opencv.hpp>

using namespace cv;
using namespace std;

Mat bgImage;
void MyLines();
void MyRectangle();
void MyEllipse();
void MyCircle();
void MyPolyon();
void Random();
int main(int argc, char **argv){

	bgImage = imread("C:\\Users\\Tim\\Desktop\\Image\\a.jpg");
	if (bgImage.empty()){
		cout << "load image filed..." << endl;
		return -1;
	}
	MyLines();

	MyRectangle();

	MyEllipse();

	MyCircle();

	MyPolyon();

	//绘制文字
	//背景图、文字、起始点、字体（前提是系统必须支持设定的字体）、字体放大倍数、颜色、线粗、线条类型
	putText(bgImage, "HelloWorld", Point(30, 50), CV_FONT_HERSHEY_COMPLEX, 2.0, Scalar(0, 0, 255), 2, 8);
	namedWindow("src_window", CV_WINDOW_AUTOSIZE);
	imshow("src_window", bgImage);

	//Random();

	waitKey(0);
	return 0;
}

//绘制线条
void MyLines(){
	Point p1 = Point(0, 0);
	Point p2 = Point(410, 624);
	Scalar color = Scalar(0, 0, 255);
	//背景图、直线两头坐标、颜色、线粗、
	//line(bgImage, p1, p2, color, 4, LINE_8);
	//line(bgImage, p1, p2, color, 4, LINE_4);
	line(bgImage, p1, p2, color, 4, LINE_AA);//LINE_AA是无锯齿
}

//绘制矩形
void MyRectangle(){
	//起始坐标点，宽和高
	Rect rect = Rect(120, 20, 200, 200);
	Scalar color = Scalar(0, 255, 0);
	rectangle(bgImage, rect, color, 2, LINE_AA);
}

//绘制椭圆
void MyEllipse(){
	Scalar color = Scalar(255, 0, 0);
	//背景图、中心点坐标、长轴和短轴、椭圆的倾斜度、（0-360就是绘制完整椭圆）、颜色、线粗、无锯齿
	ellipse(bgImage, Point(bgImage.cols / 2, bgImage.rows / 2), Size(bgImage.cols / 4, bgImage.rows / 8), 45, 0, 180, color, 2, LINE_AA);
}

//绘制圆
void MyCircle(){
	Scalar color = Scalar(255, 255, 0);
	//背景图、圆心、半径
	Point center = Point(bgImage.cols / 2, bgImage.rows / 2);
	circle(bgImage, center, 150, color, 2, LINE_8);
}

//绘制多边形
void MyPolyon(){
	//定义好多边形顶点的二维数组
	Point pts[1][5];
	pts[0][0] = Point(100, 100);
	pts[0][1] = Point(120, 180);
	pts[0][2] = Point(220, 200);
	pts[0][3] = Point(150, 80);
	pts[0][4] = Point(100, 100);

	const Point* ppts[] = { pts[0] };
	int npt[] = { 5 };
	Scalar color = Scalar(0, 255, 255);
	fillPoly(bgImage, ppts, npt, 1, color, 8);
}

//绘制随机线条
void Random(){
	RNG rng(12345);//设置随机种子
	Point pt1;
	Point pt2;
	Mat bg = Mat::zeros(bgImage.size(), bgImage.type());
	namedWindow("random", CV_WINDOW_AUTOSIZE);

	for (size_t i = 0; i <10000; i++)
	{
		//确保随机数的范围
		pt1.x = rng.uniform(0, bg.cols);
		pt2.x = rng.uniform(0, bg.cols);
		pt1.y = rng.uniform(0, bg.rows);
		pt2.y = rng.uniform(0, bg.rows);

		waitKey(100);
		Scalar color = Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255));
		line(bg, pt1, pt2, color, 1, 8);
		imshow("random", bg);
	}
}
```

![mark](https://img.zouchanglin.cn///20200201/1eYhHY4e4zDN.png)

随机线条

![]( https://img.zouchanglin.cn/EUP9MT98mkd.gif )

Mat与基本图形绘制

## 读写像素

### 读一个GRAY像素点的像素值（CV_8UC1）

```cpp
//方式一
Scalar intensity = img.at<uchar>(y, x); 
//方式二
Scalar intensity = img.at<uchar>(Point(x, y));
```

### 读一个BGR像素点的像素值

```cpp
//读取整形
Vec3b intensity = src.at<Vec3b>(x, y);
int b = intensity [0];
int g = intensity [1];
int r = intensity [2];
//读取浮点型
Vec3f intensity = img.at<Vec3f>(y, x); 
float blue = intensity.val[0]; 
float green = intensity.val[1]; 
float red = intensity.val[2];
```

## Vec3b与Vec3F

- Vec3b对应三通道的顺序是blue、green、red的uchar类型数据。
- Vec3f对应三通道的float类型数据
- 把CV_8UC1转换到CV32F1实现如下：`src.convertTo(dst, CV_32F);`



## 修改像素值

灰度图像
`img.at(y, x) = 128;`

RGB三通道图像
`img.at(y,x)[0]=128; // blue`
`img.at(y,x)[1]=128; // green`
`img.at(y,x)[2]=128; // red`

空白图像赋值
`img = Scalar(0);`

ROI选择
`Rect r(10, 10, 100, 100);`
`Mat smallImg = img(r);`

### 获取灰度图像素点

接下来用灰度图的反色作为示例：

```cpp
#include <iostream>
#include <opencv2\opencv.hpp>

using namespace cv;
using namespace std;

int main(int argc, char **argv)
{

	Mat src = imread("C:\\Users\\Tim\\Desktop\\Image\\a.jpg");
	if (src.empty())
	{
		cout << "load image filed..." << endl;
		return -1;
	}

	namedWindow("src_window", CV_WINDOW_AUTOSIZE);
	imshow("src_window", src);

	Mat src_gray;
	cvtColor(src, src_gray, CV_BGR2GRAY);

	namedWindow("src_gray_window", CV_WINDOW_AUTOSIZE);
	imshow("src_gray_window", src_gray);
	
	int height = src_gray.rows;
	int width = src_gray.cols;

	//单通道
	for (int row = 0; row < height;row++){
		for (int col = 0; col < width; col++) {
			//给每一个像素点取反
			int gray = src_gray.at<uchar>(row, col);
			src_gray.at<uchar>(row, col) = 255 - gray;
		}
	}
	//展示灰度图的反色图
	namedWindow("gray_window",CV_WINDOW_AUTOSIZE);
	imshow("gray_window", src_gray);
	waitKey(0);
	return 0;
}
```

![mark](https://img.zouchanglin.cn///20200201/XngCLYK82uRl.png)

### 获取三通道图像素点

对于三通道的像素点获取，以获取原图的反色图为例：

```cpp
#include <iostream>
#include <opencv2\opencv.hpp>

using namespace cv;
using namespace std;

int main(int argc, char **argv)
{

	Mat src = imread("C:\\Users\\Tim\\Desktop\\Image\\a.jpg");
	if (src.empty())
	{
		cout << "load image filed..." << endl;
		return -1;
	}

	namedWindow("src_window", CV_WINDOW_AUTOSIZE);
	imshow("src_window", src);

	Mat src_gray;
	cvtColor(src, src_gray, CV_BGR2GRAY);

	int height = src_gray.rows;
	int width = src_gray.cols;

	//三通道图像初始化
	Mat dst;
	dst.create(src.size(), src.type());
	height = src.rows;
	width = src.cols;

	//获取通道数
	int cn = src.channels();

	for (int row = 0; row < height; row++) {
		for (int col = 0; col < width; col++) {
			if (cn == 1) {
				//单通道图的处理，这块也就是上面的代码
				int gray = src_gray.at<uchar>(row, col);
				src_gray.at<uchar>(row, col) = 255 - gray;
			}
			else  if(cn == 3){
				//从原图中读取
				int b = src.at<Vec3b>(row, col)[0];
				int g = src.at<Vec3b>(row, col)[1];
				int r = src.at<Vec3b>(row, col)[2];
				//写入目标图像
				dst.at<Vec3b>(row, col)[0] = 255 - b;
				dst.at<Vec3b>(row, col)[1] = 255 - g;
				dst.at<Vec3b>(row, col)[2] = 255 - r;
			}		
		}
	}
	//使用API进行操作
	//bitwise_not(src, dst)
	namedWindow("gray_window",CV_WINDOW_AUTOSIZE);
	imshow("gray_window", dst);
	waitKey(0);
	return 0;
}
```

![mark](https://img.zouchanglin.cn///20200201/fMDuUScgqFs0.png)

 上面的反色，使用API也可以做到：`bitwise_not(src, dst)` 

### 三通道图转为灰度图的其他方式

![mark](https://img.zouchanglin.cn///20200201/yglW9vQaKVW0.png)

通过把原图中的像素点设定为像素点中的最大或者最小值也是可以达到转换为灰度图的效果！

## 图像混合

### 理论-线性混合操作

![mark](https://img.zouchanglin.cn///20200201/jrwaEUUWDp80.png)

### 相关API (addWeighted)

参数1：输入图像Mat – src1
参数2：输入图像src1的alpha值
参数3：输入图像Mat – src2
参数4：输入图像src2的alpha值
参数5：gamma值
参数6：输出混合图像
注意点：两张图像的大小和类型必须一致才可以

````cpp
#include <iostream>
#include <opencv2\opencv.hpp>

using namespace cv;
using namespace std;

int main(int argc, char **argv)
{

	Mat src1 = imread("C:\\Users\\Tim\\Desktop\\Image\\a.jpg");
	Mat src2 = imread("C:\\Users\\Tim\\Desktop\\Image\\b.jpg");
	Mat ret;//输出图像
	if (src1.empty() || src2.empty())
	{
		cout << "load image filed..." << endl;
		return -1;
	}

	namedWindow("src1", CV_WINDOW_AUTOSIZE);
	imshow("src1", src1);
	namedWindow("src2", CV_WINDOW_AUTOSIZE);
	imshow("src2", src2);

	double alpha = 0.5;
	//两张图片大小一致、类型一致
	if (src1.rows == src2.rows && src1.cols == src2.cols
	{
		addWeighted(src1, alpha, src2, (1.0 - alpha), 0, ret);
		//add(src1, src2, dst, Mat());
		//multiply(src1, src2, dst, 1.0);
		namedWindow("ret", CV_WINDOW_AUTOSIZE);
		imshow("ret", ret);
	}
	else
	{
		cout << "Images vary in size or type!" << endl;
		return -1;
	}

	waitKey(0);
	return 0;
}
````

这是两张图片各占50%的权重合成的图像：

![mark](https://img.zouchanglin.cn///20200201/crY8KYCfn0x7.png)

## 对比度和亮度调整

图像亮度本质上图像中每个像素的亮度，每个像素的亮度本质上RGB值的大小，RGB值为0，则像素点为黑色，RGB都为255时像素点最亮，为白色。对比度则是不同像素点之间的差值，差值越大，对比度越明显。
图像变换可以看作如下：

- 像素变换 – 点操作
- 邻域操作 – 区域



![mark](https://img.zouchanglin.cn///20200201/MLiTEYVK3c3A.png)

调整图像亮度和对比度属于像素变换-点操作，搞清楚原理下面开始撸代码:

### 代码

```cpp
#include <iostream>
#include <opencv2\opencv.hpp>

using namespace cv;
using namespace std;

int main(int argc, char **argv)
{

	Mat src = imread("C:\\Users\\Tim\\Desktop\\Image\\a.jpg");
	Mat dst;
	if (src.empty())
	{
		cout << "load image filed..." << endl;
		return -1;
	}
	char *input_win = "input_win";
	namedWindow(input_win, CV_WINDOW_AUTOSIZE);
	imshow("input_win", src);

	int height = src.rows;
	int wight = src.cols;

	//构建与src同等大小的空白图
	dst = Mat::zeros(src.size(), src.type());

	//差异倍数
	float alpha = 0.4f;
	//增益变量
	float beta = 0.0f;

	for (int row = 0; row < height; row++) {
		for (int col = 0; col < wight; col++) {
			//根据通道数目来判断处理方式
			if (src.channels() == 3){
				float b = src.at<Vec3b>(row, col)[0];
				float g = src.at<Vec3b>(row, col)[1];
				float r = src.at<Vec3b>(row, col)[2];

				dst.at<Vec3b>(row, col)[0] = saturate_cast<uchar>(b*alpha + beta);
				dst.at<Vec3b>(row, col)[1] = saturate_cast<uchar>(g*alpha + beta);
				dst.at<Vec3b>(row, col)[2] = saturate_cast<uchar>(r*alpha + beta);
			}
			else if (src.channels() == 1) {
				float v = src.at<uchar>(row, col);
				dst.at<uchar>(row, col) = saturate_cast<uchar>(v*alpha + beta);
			}
		}
	}

	//输出图像
	char *output_win = "output_win";
	namedWindow(output_win, CV_WINDOW_AUTOSIZE);
	imshow(output_win, dst);

	waitKey(0);
	return 0;
}
```

从代码中可以看出：如果将值乘上差异倍数，那么**像素点之间的差异倍数（alpha）越大，像素点之间的差异也就越大，这样导致的直接结果就是图像的对比度增强**，**增益变量越大，那么像素本身的值在增大，导致的结果就是亮度增强**

### 演示效果

![mark](https://img.zouchanglin.cn///20200201/QzpTxQCJc1uv.png)

### 重要的API

- `Mat new_image = Mat::zeros(image.size(), image.type());` 创建一张跟原图像大小和类型一致的空白图像、像素值初始化为0
- `saturate_cast(value)`确保值大小范围为0~255之间
- `Mat.at(y,x)[index]=value`给每个像素点每个通道赋值

图像亮度对比度调整

OpenCV是计算机视觉开源库，主要算法涉及图像处理和机器学习相关方法。是Intel公司贡献出来的，俄罗斯工程师贡献大部分C/C++代码。官网：https://opencv.org/ 从这里 https://opencv.org/releases.html 你可以下载到自己想要的版本！





## 环境搭建

本人使用的时VisualStudio2015+OpenCV3.4.1-vc14(vc14对应的VisualStudio版本就是VS2015)，配置环境变量，根据自己的路径来配置

![mark](https://img.zouchanglin.cn///20200201/LwXTMbNELUYs.png)

## 测试环境

新建VS空项目，注意是改为**`X64`**的解决方案，因为直接下载的exe实际上就是一个自解压文件，里面的库都是在X64的环境下编译好的，如何编译自己的VS对应的OpenCV参考：https://www.bilibili.com/video/av17968786，根据自己的路径配置即可！

> **包括头文件**
> D:\opencv3.4\build\include
> D:\opencv3.4\build\include\opencv
> D:\opencv3.4\build\include\opencv2
> **库文件**
> D:\opencv3.4\build\x64\vc14\lib
> **链接器-附加依赖项**
> opencv_world310d.lib

![mark](https://img.zouchanglin.cn///20200201/YmN4tW2jnrOw.png)

注意自己的图片路径，如果其他代码与图片所示一致，那么恭喜你的OpenCV开发环境搭建OK了！

## 图像有关的API

### 加载图像cv::imread

imread功能是加载图像文件成为一个Mat对象(什么是Mat对象接下来的文章中将会说到)
第一个参数表示图像文件名称(路径)
第二个参数，表示加载的图像是什么类型，支持常见的三个参数值

- IMREAD_UNCHANGED (<0) 表示加载原图，不做任何改变
- IMREAD_GRAYSCALE ( 0)表示把原图作为灰度图像加载进来
- IMREAD_COLOR (>0) 表示把原图作为RGB图像加载进来

注意：OpenCV支持JPG、PNG、TIFF等常见格式图像文件加载
例如加载灰度图：

![mark](https://img.zouchanglin.cn///20200201/491zkyJ3Atdm.png)

### 显示图像 cv::namedWindos 与cv::imshow

namedWindos功能是创建一个OpenCV窗口，它是由OpenCV自动创建与释放，无需手动销毁它。
常见用法namedWindow(“窗口标题”, WINDOW_AUTOSIZE)

- WINDOW_AUTOSIZE会自动根据图像大小，显示窗口大小，不能人为改变窗口大小
- WINDOW_NORMAL,跟QT集成的时候会使用，允许修改窗口大小。

imshow根据窗口名称显示图像到指定的窗口上去，第一个参数是窗口名称，第二参数是Mat对象

### 修改图像 (cv::cvtColor)

cvtColor的功能是把图像从一个彩色空间转换到另外一个色彩空间，有三个参数，第一个参数表示源图像、第二参数表示色彩空间转换之后的图像、第三个参数表示源和目标色彩空间如：COLOR_BGR2HLS 、COLOR_BGR2GRAY 等
这是原图转换为COLOR_BGR2HLS色彩空间：

![mark](https://img.zouchanglin.cn///20200201/VrrRYac1cz9p.png)

这是原图转换为COLOR_BGR2GRAY 色彩空间：

有时容易出现这样的错误

![mark](https://img.zouchanglin.cn///20200201/KNiFk2dlmpcT.png)

这个问题一般是由于将已经是灰度图的图片继续转为灰度图时引起的，所以在读取图片转为灰度色彩空间的时候要保证读取到的原图是彩色图像，如果使用灰度图的参数读取那么再次灰度化的时候就会抱这种错误！

### 保存图像(cv::imwrite)

保存图像文件到指定目录路径，只有8位、16位的PNG、JPG、Tiff文件格式而且是单通道或者三通道的BGR的图像才可以通过这种方式保存，保存PNG格式的时候可以保存透明通道的图片可以指定压缩参数！

```cpp
#include <iostream>
#include <opencv2\opencv.hpp>
#include <math.h>
using namespace std;
using namespace cv;

int main(int argc, char* argv[])
{
	//加载图像，默认IMREAD_UNCHANGED
	//Mat src = imread("C:/Users/Tim/Desktop/Image/a.jpg");
	Mat src = imread("C:/Users/Tim/Desktop/Image/a.jpg", IMREAD_GRAYSCALE); 
    //以灰度图读取

	//判断是否加载成功
	if (src.empty())
	{
		cout << "load image filed..." << endl;
		return -1;
	}

	//新建一个OpenCV窗口，大小根据图片自动调节
	namedWindow("Test Opencv", CV_WINDOW_AUTOSIZE);
	//显示图像
	imshow("Test Opencv", src);

	namedWindow("Output Window", CV_WINDOW_AUTOSIZE);
	Mat outImg;
	//色彩空间装换
	//cvtColor(src, outImg, CV_BGR2HLS);
	cvtColor(src, outImg, COLOR_BGR2GRAY);
	imshow("Output Window", outImg);

	//将Mat对象写入文件
	imwrite("C:/Users/Tim/Desktop/Image/a2.png",outImg);
	waitKey(0);
	return 0;
}
```

## 矩阵的掩膜操作

### 掩膜操作解释

所谓掩膜其实就是一个矩阵，然后根据这个矩阵重新计算图片中像素的值，掩模也叫作`kernal`
下图就是通过掩模提高图片对比度的计算公式，根据掩模把图片的对比度提高：

![mark](https://img.zouchanglin.cn///20200201/lNg287Hanf1B.png)

```cpp
#include <opencv2\opencv.hpp>
#include <iostream>
#include <math.h>

using namespace cv;

int main(int argc,char* argv[])
{
	Mat src;
	Mat dst;

	src = imread("C:/Users/Tim/Desktop/Image/e.jpg");
	if (!src.data)
	{
		std::cout << "load iamge filed..." << std::endl;
		return -1;
	} 

	namedWindow("input image", CV_WINDOW_AUTOSIZE);
	imshow("input image", src);

	//获取图像的列数,一定不要忘记图像的通道数
	int cols = (src.cols-1) * src.channels();
	int rows = src.rows;

	//获取通道数目
	int offsetx = src.channels();

	//生成一个和源图像大小相等类型相同的全0矩阵
	dst = Mat::zeros(src.size(),src.type());

	//获取起始时间
	double start = getTickCount();
	
	for (int row = 1; row < (rows - 1); row++)
	{
		//获取每一个通道的像素指针
		const uchar* prev = src.ptr<uchar>(row - 1);
		const uchar* cur = src.ptr<uchar>(row);
		const uchar* next = src.ptr<uchar>(row + 1);

		uchar* output = dst.ptr<uchar>(row);

		for (int col = offsetx; col < cols; col++){
			//output[col] = (5 * cur[col] - (cur[col - offsetx] + cur[col + offsetx] + prev[col] + next[col]));//注意像素值范围在0~255之间！
			output[col] = saturate_cast<uchar>(5 * cur[col] - (cur[col - offsetx] + cur[col + offsetx] + prev[col] + next[col]));
		}
	}

	//获取处理时间
	double run_time = (cvGetTickCount() - start)/getTickFrequency();
	std::cout << run_time<< std::endl;

	namedWindow("output image", CV_WINDOW_AUTOSIZE);
	imshow("output image", dst);
	waitKey(0);
	return 0;
}
```

### 获取图像像素指针

`Mat.ptr (int i = 0)`获取像素矩阵的指针，索引i表示第几行，从0开始计行数。
获得当前行指针`const uchar* current= myImage.ptr(row )`;
获取当前像素点`P(row, col)`的像素值 `p(row, col) =current[col]`

### saturate_cast < uchar >

```
saturate_cast<uchar>（-100），返回0
saturate_cast<uchar>（288），返回255
saturate_cast<uchar>（100），返回100
```

这个函数的功能是确保RGB值得范围在0~255之间!如果不使用这个函数进行转换，将会得到如下所示的效果，这是由于部分像素点在经过公式转化之后范围已经不再0~255之间，所以需要用到此函数：

![mark](https://img.zouchanglin.cn///20200201/E3Yb2DV9cW4K.png)

经过校正之后的处理效果：

![mark](https://img.zouchanglin.cn///20200201/GVa8Od7qQ7rl.png)

### filter2D实现掩膜

参数一：源图像
参数二：最终输出的图像,需要再定义一个Mat类变量
参数三：为像素深度，两个像素深度一定要相同，否则出错`src.depth()` 或者 `-1`
参数四：掩膜

```cpp
#include <opencv2\opencv.hpp>
#include <iostream>
#include <math.h>

using namespace cv;

int main(int argc,char* argv[])
{
	Mat src;
	Mat dst;

	src = imread("C:/Users/Tim/Desktop/Image/e.jpg");
	if (!src.data)
	{
		std::cout << "load iamge filed..." << std::endl;
		return -1;
	} 

	namedWindow("input image", CV_WINDOW_AUTOSIZE);
	imshow("input image", src);

	//获取图像的列数,一定不要忘记图像的通道数
	int cols = (src.cols-1) * src.channels();
	int rows = src.rows;

	//获取通道数目
	int offsetx = src.channels();

	//生成一个和源图像大小相等类型相同的全0矩阵
	dst = Mat::zeros(src.size(),src.type());

	//获取起始时间
	double start = getTickCount();

	//定义一个掩模
	//Mat kernal = (Mat_<char>(3, 3) << 0, 1, 0, -1, 5, -1, 0, -1, 0);//对比度增强
	Mat kernal = (Mat_<char>(3, 3) << 0, -1, 0, -1, 6, -1, 0, -1, 0);//提高锐度
	filter2D(src, dst, src.depth(), kernal);

	//获取处理时间
	double run_time = (cvGetTickCount() - start)/getTickFrequency();
	std::cout << run_time<< std::endl;

	namedWindow("output image", CV_WINDOW_AUTOSIZE);
	imshow("output image", dst);
	waitKey(0);
	return 0;
}
```

### 掩模的主要应用

- 实现图像对比度调整

- 提取感兴趣区,用预先制作的感兴趣区掩模与待处理图像相乘,得到感兴趣区图像,感兴趣区内图像值保持不变,而区外图像值都为0
掩膜是一种图像滤镜的模板，实用掩膜经常处理的是遥感图像。当提取道路或者河流，或者房屋时，通过一个n*n的矩阵来对图像进行像素过滤，然后将我们需要的地物或者标志突出显示出来。这个矩阵就是一种掩膜

- 屏蔽作用,用掩模对图像上某些区域作屏蔽,使其不参加处理或不参加处理参数的计算,或仅对屏蔽区作处理或统计

- 结构特征提取,用相似性变量或图像匹配方法检测和提取图像中与掩模相似的结构特征

- 特殊形状图像的制作

### 各种掩膜的作用

3x3

邻域平均 全是1

3x3高斯均值滤波器
filters(0) = 1: filters(1) = 2:filters(2) = 1
filters(3) = 2: filters(4) = 4: filters(5) = 2
filters(6) = 1: filters(7) = 2: filters(8) = 1

拉普拉斯1型滤波器 高通边缘检测器掩膜
filters(0) = -1: filters(1) = 0: filters(2) = -1
filters(3) = 0: filters(4) = 4: filters(5) = 0
filters(6) = -1: filters(7) = 0: filters(8) = -1

锐化 (中锐化：filters(4) = 5 ， 高锐化：filters(4) = 6)
filters(0) = 0: filters(1) = -1: filters(2) = 0
filters(3) = -1: filters(4) = 6: filters(5) = -1
filters(6) = 0: filters(7) = -1: filters(8) = 0

垂直掩膜
filters(0) = 3: filters(1) = -6: filters(2) = 3
filters(3) = 3: filters(4) = -6: filters(5) = 3
filters(6) = 3: filters(7) = -6: filters(8) = 3

水平掩膜
filters(0) = 3: filters(1) = 3: filters(2) = 3
filters(3) = -6: filters(4) = -6: filters(5) = -6
filters(6) = 3: filters(7) = 3: filters(8) = 3

对角线掩膜
filters(0) = 3: filters(1) = 3: filters(2) = -6
filters(3) = 3: filters(4) = -6: filters(5) = 3
filters(6) = -6: filters(7) = 3: filters(8) = 3

高斯滤镜5x5
f(0) = 1: f(1) = 4: f(2) = 6: f(3) = 4: f(4) = 1
f(5) = 4: f(6) = 16: f(7) = 24: f(8) = 16: f(9) = 4
f(10) = 6: f(11) = 24: f(12) = 36: f(13) = 24: f(14) = 6
f(15) = 4: f(16) = 16: f(17) = 24: f(18) = 16: f(19) = 4
f(20) = 1: f(21) = 4: f(22) = 6: f(23) = 4: f(24) = 1

根据掩模的设定不同效果也就不同，比如上述代码中一个掩模是增强对比度，一个掩模是增强锐度：

![mark](https://img.zouchanglin.cn///20200201/QFCnEfib2uGO.png)

**注意代码中的如何计算图片的处理时间，以及如何生成全0矩阵！**