C++手敲Roberts-创新互联

使用OPENCV,编写代码，学习图像二值化算法，以及边缘检测算法，进行图像的分割。

站在用户的角度思考问题，与客户深入沟通，找到城中网站设计与城中网站推广的解决方案，凭借多年的经验，让设计与互联网技术结合，创造个性化、用户体验好的作品，建站类型包括：成都网站设计、成都网站制作、企业官网、英文网站、手机端网站、网站推广、申请域名、网站空间、企业邮箱。业务覆盖城中地区。

下面主要介绍Robert算子的实现过程：

①任务分析

调入并显示图像；使用Roberts 算子对图像进行边缘检测处理； Roberts 算子为一对模板：

相应的矩阵为：rh = [0 1；-1 0]； rv = [1 0；0 -1]；这里的rh 为水平Roberts 算子，rv为垂直Roberts 算子。分别显示处理后的水平边界和垂直边界检测结果；用“欧几里德距离”和“街区距离”方式计算梯度的模，并显示检测结果；对于检测结果进行二值化处理，并显示处理结果。

②代码实现

先加载需要的库

#include#includeusing namespace cv;

接着定义一个基于Roberts算子实现阈值分割的函数,其功能包括显示用街区距离和欧几里得距离得出的梯度图、选择一个合适的阈值实现图像分割。
其中街区距离就是水平梯度和垂直梯度的和：

Robert_City.at(row, col) = saturate_cast(fabs(img.at(row, col) - img.at(row + 1, col + 1))+ fabs(img.at(row, col + 1) - img.at(row + 1, col)));

saturate_cast()函数的作用是限制像素值的范围，把大于255和小于0的情况分别赋值255和0，避免了像素值溢出的问题。

而欧几里得距离就是水平梯度和垂直梯度的平方和再开方：

Robert_Ojld.at(row, col) = saturate_cast(sqrt(pow(img.at(row, col) - img.at(row + 1, col + 1),2) + pow(img.at(row, col + 1) - img.at(row + 1, col),2)));

具体代码实现：

Mat Robert_City = Mat::zeros(Size(img.cols, img.rows), img.type());  //用于计算城市距离的空白图像
	Mat Robert_Ojld = Mat::zeros(Size(img.rows, img.cols), img.type());  //用于计算欧几里得距离的空白图像
	for (int row = 0; row< img.rows-1; row++) {
		for (int col = 0; col< img.cols-1; col++) {                 // 由于像素之间的加减可能会小于零，因此记得加上绝对值函数fabs()
			Robert_City.at(row, col) = saturate_cast(fabs(img.at(row, col) - img.at(row + 1, col + 1)) + fabs(img.at(row, col + 1) - img.at(row + 1, col)));
		}
	}
	for (int row = 0; row< img.rows - 1; row++) {
		for (int col = 0; col< img.cols - 1; col++) {
			Robert_Ojld.at(row, col) = saturate_cast(sqrt(pow(img.at(row, col) - img.at(row + 1, col + 1),2) + pow(img.at(row, col + 1) - img.at(row + 1, col),2)));
		}
	}
	imshow("Robert图像(街区距离)", Robert_City);
	imshow("Robert图像(欧几里得距离)", Robert_Ojld);

结果如下：

（原图）

接下来要选择一个合适的阈值用于图像的二值化。选择阈值的方式有很多暴力遍历（不推荐）、调用函数法（直接输出直方图看每一个像素值的数量，方便主观判断）和数组法。这里介绍一下数组法：创建一个256大小的一维数组arr[256]，每一个元素依据索引代表对应的像素值的个数。就比如说假设一共有10000个点像素值为0，那么arr[0] = 10000。先对欧几里得距离实现二值化，实现如下：

int pixel_num[256] = {0};            //数组记得初始化为0，即未统计数量之前各个像素的个数都是0
	for (int row = 0; row< img.rows ; row++) {
		for (int col = 0; col< img.cols ; col++) {         
			pixel_num[Robert_Ojld.at(row, col)] += 1;   //遍历到的像素值作为索引，次数+1
		}
	}
	int times = 0;         //定义遍历数组的变量，从0开始，依次输出0到255每个像素值的数目
	while (times<= 255) {
		cout<<"像素值"<

输出结果：

可以看出，像素值9和像素值10差异变化较大。因此可以选择像素值10作为分割图像的阈值，比像素值10小的像素全部赋值为0，比像素值大的全部赋值255：

for (int row = 0; row< img.rows; row++) {
		for (int col = 0; col< img.cols; col++) {       //遍历所有像素点进行判断
			if (Robert_Ojld.at(row, col)< 10) {
				Robert_Ojld.at(row, col) = 0;     // 小于阈值赋值为0，否则赋值255
			}
			else {
				Robert_Ojld.at(row, col) = 255;
			}
		}
	}
	imshow("欧几里得阈值分割", Robert_Ojld);

可以看到阈值分割效果不错，但是不足之处也很明显：图像因此留下了很多离散点，这是阈值选择得不够大的原因。于是我又偷偷的把阈值调整为15：在保证图片不失真的情况下，15作为阈值要明显好于10。

同理，街区距离的做法和欧几里得距离类似，也是通过数组得到较为可信的阈值之后再细微调整。街区距离的实现过程以及结果如下所示：

int pixel_num02[256] = { 0 };            //数组记得初始化为0，即未统计数量之前各个像素的个数都是0
	for (int row = 0; row< img.rows; row++) {
		for (int col = 0; col< img.cols; col++) {
			pixel_num01[Robert_City.at(row, col)] += 1;   //遍历到的像素值作为索引，次数+1
		}
	}
	int time = 0;         //定义遍历数组的变量，从0开始，依次输出0到255每个像素值的数目
	while (times<= 255) {
		cout<< "像素值"<< time<< "的数目为：  "<< pixel_num02[time]<< endl;    // 遍历输出
		time++;                             // 不要忘了自增
	}
	//得到10作为分割阈值
	for (int row = 0; row< img.rows; row++) {
		for (int col = 0; col< img.cols; col++) {       //遍历所有像素点进行判断
			if (Robert_City.at(row, col)< 20) {
				Robert_City.at(row, col) = 0;     // 小于阈值赋值为0，否则赋值255
			}
			else {
				Robert_City.at(row, col) = 255;
			}
		}
	}
	imshow("街区距离阈值分割", Robert_City);

注意：阈值的选择是很关键的，如果阈值选择过大的话可能会导致边缘断开的情况，也就是失真。这就需要我们在去噪和失真两个方面做权衡。以下给出了基于Roberts算子的阈值分割函数的完整代码：

void Roberts(Mat& img) {                   // 基于Roberts算子的阈值分割
	Mat Robert_City = Mat::zeros(Size(img.cols, img.rows), img.type());  //用于计算城市距离的空白图像
	Mat Robert_Ojld = Mat::zeros(Size(img.cols, img.rows), img.type());  //用于计算欧几里得距离的空白图像
	for (int row = 0; row< img.rows-1; row++) {
		for (int col = 0; col< img.cols-1; col++) {                 // 由于像素之间的加减可能会小于零，因此记得加上绝对值函数fabs()
			Robert_City.at(row, col) = saturate_cast(fabs(img.at(row, col) - img.at(row + 1, col + 1)) + fabs(img.at(row, col + 1) - img.at(row + 1, col)));
		}
	}
	for (int row = 0; row< img.rows - 1; row++) {
		for (int col = 0; col< img.cols - 1; col++) {
			Robert_Ojld.at(row, col) = saturate_cast(sqrt(pow(img.at(row, col) - img.at(row + 1, col + 1),2) + pow(img.at(row, col + 1) - img.at(row + 1, col),2)));
		}
	}
	imshow("Robert图像(街区距离)", Robert_City);
	imshow("Robert图像(欧几里得距离)", Robert_Ojld);
	int pixel_num01[256] = {0};            //数组记得初始化为0，即未统计数量之前各个像素的个数都是0
	for (int row = 0; row< img.rows ; row++) {
		for (int col = 0; col< img.cols ; col++) {         
			pixel_num01[Robert_Ojld.at(row, col)] += 1;   //遍历到的像素值作为索引，次数+1
		}
	}
	int times = 0;         //定义遍历数组的变量，从0开始，依次输出0到255每个像素值的数目
	while (times<= 255) {
		cout<<"像素值"<(row, col)< 15) {
				Robert_Ojld.at(row, col) = 0;     // 小于阈值赋值为0，否则赋值255
			}
			else {
				Robert_Ojld.at(row, col) = 255;
			}
		}
	}
	imshow("欧几里得阈值分割", Robert_Ojld);
	int pixel_num02[256] = { 0 };            //数组记得初始化为0，即未统计数量之前各个像素的个数都是0
	for (int row = 0; row< img.rows; row++) {
		for (int col = 0; col< img.cols; col++) {
			pixel_num01[Robert_City.at(row, col)] += 1;   //遍历到的像素值作为索引，次数+1
		}
	}
	int time = 0;         //定义遍历数组的变量，从0开始，依次输出0到255每个像素值的数目
	while (times<= 255) {
		cout<< "像素值"<< time<< "的数目为：  "<< pixel_num02[time]<< endl;    // 遍历输出
		time++;                             // 不要忘了自增
	}
	//得到10作为分割阈值
	for (int row = 0; row< img.rows; row++) {
		for (int col = 0; col< img.cols; col++) {       //遍历所有像素点进行判断
			if (Robert_City.at(row, col)< 20) {
				Robert_City.at(row, col) = 0;     // 小于阈值赋值为0，否则赋值255
			}
			else {
				Robert_City.at(row, col) = 255;
			}
		}
	}
	imshow("街区距离阈值分割", Robert_City);

	waitKey(0);
	destroyAllWindows();
}

类似的如Prewitt算子、Sobel算子与上述的Roberts算子类似，其阈值分割的过程都是先用街区距离、欧几里得距离分别算出原始图像的梯度，然后再创建一个一维数组来记录下每个像素值的数目以备接下来的阈值选择操作。最后的阈值选择既需要能有效地对图像进行分割，也要保证图像不会出现失真的现象。

以下分别是基于Prewitt算子的阈值分割函数、基于Sobel算子的阈值分割函数。

void Prewitt(Mat& img) {                   // 基于Prewitt算子的阈值分割
	Mat Prewitt_City = Mat::zeros(Size(img.cols, img.rows), img.type());  //用于计算城市距离的空白图像
	Mat Prewitt_Ojld = Mat::zeros(Size(img.cols, img.rows), img.type());  //用于计算欧几里得距离的空白图像
	for (int row = 1; row< img.rows - 1; row++) {
		for (int col = 1; col< img.cols - 1; col++) {                 // 由于像素之间的加减可能会小于零，因此记得加上绝对值函数fabs()
			Prewitt_City.at(row, col) = saturate_cast(fabs(img.at(row-1, col+1) - img.at(row - 1, col - 1)+ img.at(row , col + 1)- img.at(row, col - 1)+ img.at(row + 1, col + 1)- img.at(row + 1, col - 1)) + fabs(img.at(row+1, col - 1) - img.at(row -1 , col-1)+ img.at(row + 1, col)- img.at(row - 1, col)+ img.at(row + 1, col + 1)- img.at(row - 1, col + 1)));
		}
	}
	for (int row = 1; row< img.rows - 1; row++) {
		for (int col = 1; col< img.cols - 1; col++) {
			Prewitt_Ojld.at(row, col) = saturate_cast(sqrt(pow(img.at(row - 1, col + 1) - img.at(row - 1, col - 1) + img.at(row, col + 1) - img.at(row, col - 1)+ img.at(row + 1, col + 1) - img.at(row + 1, col - 1), 2) + pow(img.at(row + 1, col - 1) - img.at(row - 1, col - 1) + img.at(row + 1, col) - img.at(row - 1, col) + img.at(row + 1, col + 1) - img.at(row - 1, col + 1), 2)));
		}
	}
	imshow("Prewitt图像(街区距离)", Prewitt_City);
	imshow("Prewitt图像(欧几里得距离)", Prewitt_Ojld);
	int pixel_num01[256] = { 0 };            //数组记得初始化为0，即未统计数量之前各个像素的个数都是0
	for (int row = 0; row< img.rows; row++) {
		for (int col = 0; col< img.cols; col++) {
			pixel_num01[Prewitt_Ojld.at(row, col)] += 1;   //遍历到的像素值作为索引，次数+1
		}
	}
	int times = 0;         //定义遍历数组的变量，从0开始，依次输出0到255每个像素值的数目
	while (times<= 255) {
		cout<< "像素值"<< times<< "的数目为：  "<< pixel_num01[times]<< endl;    // 遍历输出
		times++;                             // 不要忘了自增
	}
	//得到10作为分割阈值
	for (int row = 0; row< img.rows; row++) {
		for (int col = 0; col< img.cols; col++) {       //遍历所有像素点进行判断
			if (Prewitt_Ojld.at(row, col)< 70) {
				Prewitt_Ojld.at(row, col) = 0;     // 小于阈值赋值为0，否则赋值255
			}
			else {
				Prewitt_Ojld.at(row, col) = 255;
			}
		}
	}
	imshow("欧几里得阈值分割", Prewitt_Ojld);
	int pixel_num02[256] = { 0 };            //数组记得初始化为0，即未统计数量之前各个像素的个数都是0
	for (int row = 0; row< img.rows; row++) {
		for (int col = 0; col< img.cols; col++) {
			pixel_num01[Prewitt_City.at(row, col)] += 1;   //遍历到的像素值作为索引，次数+1
		}
	}
	int time = 0;         //定义遍历数组的变量，从0开始，依次输出0到255每个像素值的数目
	while (times<= 255) {
		cout<< "像素值"<< time<< "的数目为：  "<< pixel_num02[time]<< endl;    // 遍历输出
		time++;                             // 不要忘了自增
	}
	//得到10作为分割阈值
	for (int row = 0; row< img.rows; row++) {
		for (int col = 0; col< img.cols; col++) {       //遍历所有像素点进行判断
			if (Prewitt_City.at(row, col)< 70) {
				Prewitt_City.at(row, col) = 0;     // 小于阈值赋值为0，否则赋值255
			}
			else {
				Prewitt_City.at(row, col) = 255;
			}
		}
	}
	imshow("街区距离阈值分割", Prewitt_City);

	waitKey(0);
	destroyAllWindows();
}

void Sobel(Mat& img) {                   // 基于Prewitt算子的阈值分割
	Mat Sobel_City = Mat::zeros(Size(img.cols, img.rows), img.type());  //用于计算城市距离的空白图像
	Mat Sobel_Ojld = Mat::zeros(Size(img.cols, img.rows), img.type());  //用于计算欧几里得距离的空白图像
	for (int row = 1; row< img.rows - 1; row++) {
		for (int col = 1; col< img.cols - 1; col++) {                 // 由于像素之间的加减可能会小于零，因此记得加上绝对值函数fabs()
			Sobel_City.at(row, col) = saturate_cast(fabs(img.at(row - 1, col + 1) - img.at(row - 1, col - 1) + 2*img.at(row, col + 1) - 2*img.at(row, col - 1) + img.at(row + 1, col + 1) - img.at(row + 1, col - 1)) + fabs(img.at(row + 1, col - 1) - img.at(row - 1, col - 1) + 2*img.at(row + 1, col) - 2*img.at(row - 1, col) + img.at(row + 1, col + 1) - img.at(row - 1, col + 1)));
		}
	}
	for (int row = 1; row< img.rows - 1; row++) {
		for (int col = 1; col< img.cols - 1; col++) {
			Sobel_Ojld.at(row, col) = saturate_cast(sqrt(pow(img.at(row - 1, col + 1) - img.at(row - 1, col - 1) + 2*img.at(row, col + 1) - 2*img.at(row, col - 1) + img.at(row + 1, col + 1) - img.at(row + 1, col - 1), 2) + pow(img.at(row + 1, col - 1) - img.at(row - 1, col - 1) + 2*img.at(row + 1, col) - 2*img.at(row - 1, col) + img.at(row + 1, col + 1) - img.at(row - 1, col + 1), 2)));
		}
	}
	imshow("Sobel图像(街区距离)", Sobel_City);
	imshow("Sobel图像(欧几里得距离)", Sobel_Ojld);
	int pixel_num01[256] = { 0 };            //数组记得初始化为0，即未统计数量之前各个像素的个数都是0
	for (int row = 0; row< img.rows; row++) {
		for (int col = 0; col< img.cols; col++) {
			pixel_num01[Sobel_Ojld.at(row, col)] += 1;   //遍历到的像素值作为索引，次数+1
		}
	}
	int times = 0;         //定义遍历数组的变量，从0开始，依次输出0到255每个像素值的数目
	while (times<= 255) {
		cout<< "像素值"<< times<< "的数目为：  "<< pixel_num01[times]<< endl;    // 遍历输出
		times++;                             // 不要忘了自增
	}
	//得到10作为分割阈值
	for (int row = 0; row< img.rows; row++) {
		for (int col = 0; col< img.cols; col++) {       //遍历所有像素点进行判断
			if (Sobel_Ojld.at(row, col)< 70) {
				Sobel_Ojld.at(row, col) = 0;     // 小于阈值赋值为0，否则赋值255
			}
			else {
				Sobel_Ojld.at(row, col) = 255;
			}
		}
	}
	imshow("欧几里得阈值分割", Sobel_Ojld);
	int pixel_num02[256] = { 0 };            //数组记得初始化为0，即未统计数量之前各个像素的个数都是0
	for (int row = 0; row< img.rows; row++) {
		for (int col = 0; col< img.cols; col++) {
			pixel_num01[Sobel_City.at(row, col)] += 1;   //遍历到的像素值作为索引，次数+1
		}
	}
	int time = 0;         //定义遍历数组的变量，从0开始，依次输出0到255每个像素值的数目
	while (times<= 255) {
		cout<< "像素值"<< time<< "的数目为：  "<< pixel_num02[time]<< endl;    // 遍历输出
		time++;                             // 不要忘了自增
	}
	//得到10作为分割阈值
	for (int row = 0; row< img.rows; row++) {
		for (int col = 0; col< img.cols; col++) {       //遍历所有像素点进行判断
			if (Sobel_City.at(row, col)< 70) {
				Sobel_City.at(row, col) = 0;     // 小于阈值赋值为0，否则赋值255
			}
			else {
				Sobel_City.at(row, col) = 255;
			}
		}
	}
	imshow("街区距离阈值分割", Sobel_City);

	waitKey(0);
	destroyAllWindows();
}

Prewitt算子和Sobel算子大同小异，Sobel是在Prewitt的基础上增加了权重，也就是越靠近当前像素值，那么它所发挥的作用就越大。总体而言的话Prewitt算子和Sobel算子的结果会比Roberts算子的结果要好一些，下面是基于两者的阈值分割结果：

总代码如下：

#include#include#includeusing namespace cv;
using namespace std;

void Roberts(Mat& img);
void Prewitt(Mat& img);
void Sobel(Mat& img);

int main() {
	Mat Gray = imread("C:\\Users\\Czhannb\\Desktop\\gray.png", IMREAD_GRAYSCALE);
	if (Gray.empty()) {
		cout<< "读取图片错误！"<< endl;
	}
	else {
		imshow("未动工之前：", Gray);
	}
	//Roberts(Gray);
	//Prewitt(Gray);
	Sobel(Gray);
	return 0;
}


void Roberts(Mat& img) {                   // 基于Roberts算子的阈值分割
	Mat Robert_City = Mat::zeros(Size(img.cols, img.rows), img.type());  //用于计算城市距离的空白图像
	Mat Robert_Ojld = Mat::zeros(Size(img.cols, img.rows), img.type());  //用于计算欧几里得距离的空白图像
	for (int row = 0; row< img.rows-1; row++) {
		for (int col = 0; col< img.cols-1; col++) {                 // 由于像素之间的加减可能会小于零，因此记得加上绝对值函数fabs()
			Robert_City.at(row, col) = saturate_cast(fabs(img.at(row, col) - img.at(row + 1, col + 1)) + fabs(img.at(row, col + 1) - img.at(row + 1, col)));
		}
	}
	for (int row = 0; row< img.rows - 1; row++) {
		for (int col = 0; col< img.cols - 1; col++) {
			Robert_Ojld.at(row, col) = saturate_cast(sqrt(pow(img.at(row, col) - img.at(row + 1, col + 1),2) + pow(img.at(row, col + 1) - img.at(row + 1, col),2)));
		}
	}
	imshow("Robert图像(街区距离)", Robert_City);
	imshow("Robert图像(欧几里得距离)", Robert_Ojld);
	int pixel_num01[256] = {0};            //数组记得初始化为0，即未统计数量之前各个像素的个数都是0
	for (int row = 0; row< img.rows ; row++) {
		for (int col = 0; col< img.cols ; col++) {         
			pixel_num01[Robert_Ojld.at(row, col)] += 1;   //遍历到的像素值作为索引，次数+1
		}
	}
	int times = 0;         //定义遍历数组的变量，从0开始，依次输出0到255每个像素值的数目
	while (times<= 255) {
		cout<<"像素值"<(row, col)< 15) {
				Robert_Ojld.at(row, col) = 0;     // 小于阈值赋值为0，否则赋值255
			}
			else {
				Robert_Ojld.at(row, col) = 255;
			}
		}
	}
	imshow("欧几里得阈值分割", Robert_Ojld);
	int pixel_num02[256] = { 0 };            //数组记得初始化为0，即未统计数量之前各个像素的个数都是0
	for (int row = 0; row< img.rows; row++) {
		for (int col = 0; col< img.cols; col++) {
			pixel_num01[Robert_City.at(row, col)] += 1;   //遍历到的像素值作为索引，次数+1
		}
	}
	int time = 0;         //定义遍历数组的变量，从0开始，依次输出0到255每个像素值的数目
	while (times<= 255) {
		cout<< "像素值"<< time<< "的数目为：  "<< pixel_num02[time]<< endl;    // 遍历输出
		time++;                             // 不要忘了自增
	}
	//得到10作为分割阈值
	for (int row = 0; row< img.rows; row++) {
		for (int col = 0; col< img.cols; col++) {       //遍历所有像素点进行判断
			if (Robert_City.at(row, col)< 20) {
				Robert_City.at(row, col) = 0;     // 小于阈值赋值为0，否则赋值255
			}
			else {
				Robert_City.at(row, col) = 255;
			}
		}
	}
	imshow("街区距离阈值分割", Robert_City);

	waitKey(0);
	destroyAllWindows();
}

void Prewitt(Mat& img) {                   // 基于Prewitt算子的阈值分割
	Mat Prewitt_City = Mat::zeros(Size(img.cols, img.rows), img.type());  //用于计算城市距离的空白图像
	Mat Prewitt_Ojld = Mat::zeros(Size(img.cols, img.rows), img.type());  //用于计算欧几里得距离的空白图像
	for (int row = 1; row< img.rows - 1; row++) {
		for (int col = 1; col< img.cols - 1; col++) {                 // 由于像素之间的加减可能会小于零，因此记得加上绝对值函数fabs()
			Prewitt_City.at(row, col) = saturate_cast(fabs(img.at(row-1, col+1) - img.at(row - 1, col - 1)+ img.at(row , col + 1)- img.at(row, col - 1)+ img.at(row + 1, col + 1)- img.at(row + 1, col - 1)) + fabs(img.at(row+1, col - 1) - img.at(row -1 , col-1)+ img.at(row + 1, col)- img.at(row - 1, col)+ img.at(row + 1, col + 1)- img.at(row - 1, col + 1)));
		}
	}
	for (int row = 1; row< img.rows - 1; row++) {
		for (int col = 1; col< img.cols - 1; col++) {
			Prewitt_Ojld.at(row, col) = saturate_cast(sqrt(pow(img.at(row - 1, col + 1) - img.at(row - 1, col - 1) + img.at(row, col + 1) - img.at(row, col - 1)+ img.at(row + 1, col + 1) - img.at(row + 1, col - 1), 2) + pow(img.at(row + 1, col - 1) - img.at(row - 1, col - 1) + img.at(row + 1, col) - img.at(row - 1, col) + img.at(row + 1, col + 1) - img.at(row - 1, col + 1), 2)));
		}
	}
	imshow("Prewitt图像(街区距离)", Prewitt_City);
	imshow("Prewitt图像(欧几里得距离)", Prewitt_Ojld);
	int pixel_num01[256] = { 0 };            //数组记得初始化为0，即未统计数量之前各个像素的个数都是0
	for (int row = 0; row< img.rows; row++) {
		for (int col = 0; col< img.cols; col++) {
			pixel_num01[Prewitt_Ojld.at(row, col)] += 1;   //遍历到的像素值作为索引，次数+1
		}
	}
	int times = 0;         //定义遍历数组的变量，从0开始，依次输出0到255每个像素值的数目
	while (times<= 255) {
		cout<< "像素值"<< times<< "的数目为：  "<< pixel_num01[times]<< endl;    // 遍历输出
		times++;                             // 不要忘了自增
	}
	//得到10作为分割阈值
	for (int row = 0; row< img.rows; row++) {
		for (int col = 0; col< img.cols; col++) {       //遍历所有像素点进行判断
			if (Prewitt_Ojld.at(row, col)< 70) {
				Prewitt_Ojld.at(row, col) = 0;     // 小于阈值赋值为0，否则赋值255
			}
			else {
				Prewitt_Ojld.at(row, col) = 255;
			}
		}
	}
	imshow("欧几里得阈值分割", Prewitt_Ojld);
	int pixel_num02[256] = { 0 };            //数组记得初始化为0，即未统计数量之前各个像素的个数都是0
	for (int row = 0; row< img.rows; row++) {
		for (int col = 0; col< img.cols; col++) {
			pixel_num01[Prewitt_City.at(row, col)] += 1;   //遍历到的像素值作为索引，次数+1
		}
	}
	int time = 0;         //定义遍历数组的变量，从0开始，依次输出0到255每个像素值的数目
	while (times<= 255) {
		cout<< "像素值"<< time<< "的数目为：  "<< pixel_num02[time]<< endl;    // 遍历输出
		time++;                             // 不要忘了自增
	}
	//得到10作为分割阈值
	for (int row = 0; row< img.rows; row++) {
		for (int col = 0; col< img.cols; col++) {       //遍历所有像素点进行判断
			if (Prewitt_City.at(row, col)< 70) {
				Prewitt_City.at(row, col) = 0;     // 小于阈值赋值为0，否则赋值255
			}
			else {
				Prewitt_City.at(row, col) = 255;
			}
		}
	}
	imshow("街区距离阈值分割", Prewitt_City);

	waitKey(0);
	destroyAllWindows();
}

void Sobel(Mat& img) {                   // 基于Prewitt算子的阈值分割
	Mat Sobel_City = Mat::zeros(Size(img.cols, img.rows), img.type());  //用于计算城市距离的空白图像
	Mat Sobel_Ojld = Mat::zeros(Size(img.cols, img.rows), img.type());  //用于计算欧几里得距离的空白图像
	for (int row = 1; row< img.rows - 1; row++) {
		for (int col = 1; col< img.cols - 1; col++) {                 // 由于像素之间的加减可能会小于零，因此记得加上绝对值函数fabs()
			Sobel_City.at(row, col) = saturate_cast(fabs(img.at(row - 1, col + 1) - img.at(row - 1, col - 1) + 2*img.at(row, col + 1) - 2*img.at(row, col - 1) + img.at(row + 1, col + 1) - img.at(row + 1, col - 1)) + fabs(img.at(row + 1, col - 1) - img.at(row - 1, col - 1) + 2*img.at(row + 1, col) - 2*img.at(row - 1, col) + img.at(row + 1, col + 1) - img.at(row - 1, col + 1)));
		}
	}
	for (int row = 1; row< img.rows - 1; row++) {
		for (int col = 1; col< img.cols - 1; col++) {
			Sobel_Ojld.at(row, col) = saturate_cast(sqrt(pow(img.at(row - 1, col + 1) - img.at(row - 1, col - 1) + 2*img.at(row, col + 1) - 2*img.at(row, col - 1) + img.at(row + 1, col + 1) - img.at(row + 1, col - 1), 2) + pow(img.at(row + 1, col - 1) - img.at(row - 1, col - 1) + 2*img.at(row + 1, col) - 2*img.at(row - 1, col) + img.at(row + 1, col + 1) - img.at(row - 1, col + 1), 2)));
		}
	}
	imshow("Sobel图像(街区距离)", Sobel_City);
	imshow("Sobel图像(欧几里得距离)", Sobel_Ojld);
	int pixel_num01[256] = { 0 };            //数组记得初始化为0，即未统计数量之前各个像素的个数都是0
	for (int row = 0; row< img.rows; row++) {
		for (int col = 0; col< img.cols; col++) {
			pixel_num01[Sobel_Ojld.at(row, col)] += 1;   //遍历到的像素值作为索引，次数+1
		}
	}
	int times = 0;         //定义遍历数组的变量，从0开始，依次输出0到255每个像素值的数目
	while (times<= 255) {
		cout<< "像素值"<< times<< "的数目为：  "<< pixel_num01[times]<< endl;    // 遍历输出
		times++;                             // 不要忘了自增
	}
	//得到10作为分割阈值
	for (int row = 0; row< img.rows; row++) {
		for (int col = 0; col< img.cols; col++) {       //遍历所有像素点进行判断
			if (Sobel_Ojld.at(row, col)< 70) {
				Sobel_Ojld.at(row, col) = 0;     // 小于阈值赋值为0，否则赋值255
			}
			else {
				Sobel_Ojld.at(row, col) = 255;
			}
		}
	}
	imshow("欧几里得阈值分割", Sobel_Ojld);
	int pixel_num02[256] = { 0 };            //数组记得初始化为0，即未统计数量之前各个像素的个数都是0
	for (int row = 0; row< img.rows; row++) {
		for (int col = 0; col< img.cols; col++) {
			pixel_num01[Sobel_City.at(row, col)] += 1;   //遍历到的像素值作为索引，次数+1
		}
	}
	int time = 0;         //定义遍历数组的变量，从0开始，依次输出0到255每个像素值的数目
	while (times<= 255) {
		cout<< "像素值"<< time<< "的数目为：  "<< pixel_num02[time]<< endl;    // 遍历输出
		time++;                             // 不要忘了自增
	}
	//得到10作为分割阈值
	for (int row = 0; row< img.rows; row++) {
		for (int col = 0; col< img.cols; col++) {       //遍历所有像素点进行判断
			if (Sobel_City.at(row, col)< 70) {
				Sobel_City.at(row, col) = 0;     // 小于阈值赋值为0，否则赋值255
			}
			else {
				Sobel_City.at(row, col) = 255;
			}
		}
	}
	imshow("街区距离阈值分割", Sobel_City);

	waitKey(0);
	destroyAllWindows();
}

补充：由于处理空白图像的像素值时没有考虑到最外面的一层，因此会出现有像素保持为初始值0的情况。一种改进的方法是给这些像素赋值为离它最近的像素值，这样的话一定程度上解决了边界全黑的问题。

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧

                

                新闻名称：C++手敲Roberts-创新互联                

                链接URL：http://azwzsj.com/article/dpgpeh.html


        
            其他资讯
            
                
                        两栈共享存储空间-创新互联
                    

                        Linux基础操作总结【二】-创新互联
                    

                        JSON如何使用-创新互联
                    

                        Nginx实现404页面的几种方法(三种)-创新互联
                    

                        go-carbon1.2.4新增系列时间比较方法是什么-创新互联