C++手敲基于梯度图和像素数量数组的OTSU阈值分割

一件迷途小书童

已于 2022-12-12 23:20:18 修改

阅读量1.8k

点赞数 2

分类专栏：图像处理文章标签：算法开发语言 c++

于 2022-12-02 14:22:54 首次发布

本文链接：https://blog.csdn.net/m0_64007201/article/details/128144957

版权

图像处理专栏收录该内容

4 篇文章 2 订阅

订阅专栏

一、OTSU算法原理

➢OTSU法（最大类间方差法，有时也称之为大津算法）

➢ 使用聚类的思想，把图像的灰度数按灰度级分成2个部分，使得两个部分之间的灰度值差异最大，每个部分之间的灰度差异最小

➢ 通过方差的计算来寻找一个合适的灰度级别来划分。

➢ 可以在二值化的时候采用OTSU算法来自动选取阈值进行二值化。

➢ OTSU算法被认为是图像分割中阈值选取的最佳算法，计算简单，不受图像亮度和对比度的影响。

➢ 因此,使类间方差最大的分割意味着错分概率最小。

二、OTSU算法步骤：

全局阈值T可以按如下计算：

➢选择一个初时估计值T （一般为图像的平均灰度值）

➢使用T分割图像，产生两组像素：G1包括灰度级大于 T的像素，G2包括灰度级小于等于T的像素

➢计算G1 中像素的平均值并赋值给μ1，计算G2 中像素的平均值并赋值给μ2

➢计算一个新的阈值：

➢重复步骤 2 ～ 4，一直到两次连续的T之间的差小于预先给定的上界T∞

三、代码实现

当我们用边缘梯度算子（如Roberts、Soberl、Prewitt等）处理原始图像拿到梯度图之后，可以创建一个1*256维的数组来存放梯度图中每个像素的个数，其具体的实现方式如下：

int pixel_num[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<uchar>(row, col)] += 1;   //遍历到的像素值作为索引，次数+1
		}
	}

以下是OTSU的实现方法：
①由传入的梯度图拿到图像的维度，创建一个空白图像用于保留运算得到的结果，并且拿到梯度图像的总像素个数。

Mat OTSU = Mat::zeros(Size(img.cols, img.rows), img.type());
int N = img.rows * img.cols;

②由像素数量数组，得到每一个像素对应的概率：

double pro[256] = { 0 };            // 定义概率数组
	for (int i = 0; i < 256; i++) {
		pro[i] = arr[i] / N;            // 得到每个像素值的概率
	}

注意创建的概率数组是浮点型，定义为整形的话会出现全部像素的概率都为零的情况。

③依次创建OTSU计算的过程量，包括两类的概率、均值，还有阈值T以及方差v等等；先计算得到两类的均值以及概率，根据公式v = w0 * w1 * pow(u1 - u0, 2);就可以得到此次遍历的像素作为阈值得到的方差。

double delta = 0, w0 = 0, w1 = 0, u0 = 0, u1 = 0, v = 0;           // 变量初始化为0
int T = 0, thresh = 0;
while (T <= 255) {
		for (int i = 0; i <= T; i++) {
			w0 += pro[i];                       // C0的概率
		}
		w1 = 1 - w0;                            // C1的概率
		for (int i = 0; i <= 255; i++) {
			if (i <= T) {
				u0 += pro[i] * i;                     // C0的平均值
			}
			else {
				u1 += pro[i] * i;                     // C1的平均值
			}
			v = w0 * w1 * pow(u1 - u0, 2);
			if (v > delta) {
				delta = v;
				thresh = T;
			}
			T += 1;
		}
	}

遍历循环的过程中要对方差进行判断，如果此次计算的方差要比之前的最大方差delta要大，那么对delta进行更新，同时也用thresh记录下历史最大方差对应的像素值，作为分割的阈值T。这样一来，遍历的结果就可以得到我们想要的，能使两类差异最大的阈值T。

④通过对与梯度图同维大小的空白图片遍历，给每一个像素进行二值化。若遍历到的像素值大于等于T，则赋值为255，否则为0。

for (int row = 0; row < img.rows; row++) {
		for (int col = 0; col < img.cols; col++) {
			if (img.at<uchar>(row, col) > thresh) {    //遍历判断
				OTSU.at<uchar>(row, col) = 255;
			}
		}
	}

⑤显示OTSU图像，得到阈值分割结果：

imshow("OTSU阈值分割", OTSU);
waitKey(0);
destroyAllWindows();

四、代码汇总

#include<opencv2/opencv.hpp>
#include<iostream>
#include<math.h>

using namespace cv;
using namespace std;

void Sobel(Mat img);
void OTSU(Mat& img, int arr[]);

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

void OTSU(Mat& img, int arr[]) {   // 需要输入待处理的图像 和 直方图像素个数数组
	int N = img.rows * img.cols;    // 统计输入图像的像素个数N
	double pro[256] = { 0 };            // 定义概率数组
	for (int i = 0; i < 256; i++) {
		pro[i] = arr[i] / N;            // 得到每个像素值的概率
	}
	double delta = 0, w0 = 0, w1 = 0, u0 = 0, u1 = 0, v = 0;           // 变量初始化为0
	int T = 0, thresh = 0;
while (T <= 255) {
		for (int i = 0; i <= T; i++) {
			w0 += pro[i];                       // C0的概率
		}
		w1 = 1 - w0;                            // C1的概率
		for (int i = 0; i <= 255; i++) {
			if (i <= T) {
				u0 += pro[i] * i;                     // C0的平均值
			}
			else {
				u1 += pro[i] * i;                     // C1的平均值
			}
			v = w0 * w1 * pow(u1 - u0, 2);
			if (v > delta) {
				delta = v;
				thresh = T;
			}
			T += 1;
		}
	}
	Mat OTSU = Mat::zeros(Size(img.cols, img.rows), img.type());
	for (int row = 0; row < img.rows; row++) {
		for (int col = 0; col < img.cols; col++) {
			if (img.at<uchar>(row, col) > int(thresh)) {
				OTSU.at<uchar>(row, col) = 255;
			}
		}
	}
	imshow("OTSU阈值分割", OTSU);
	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<uchar>(row, col) = saturate_cast<uchar>(fabs(img.at<uchar>(row - 1, col + 1) - img.at<uchar>(row - 1, col - 1) + 2*img.at<uchar>(row, col + 1) - 2*img.at<uchar>(row, col - 1) + img.at<uchar>(row + 1, col + 1) - img.at<uchar>(row + 1, col - 1)) + fabs(img.at<uchar>(row + 1, col - 1) - img.at<uchar>(row - 1, col - 1) + 2*img.at<uchar>(row + 1, col) - 2*img.at<uchar>(row - 1, col) + img.at<uchar>(row + 1, col + 1) - img.at<uchar>(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<uchar>(row, col) = saturate_cast<uchar>(sqrt(pow(img.at<uchar>(row - 1, col + 1) - img.at<uchar>(row - 1, col - 1) + 2*img.at<uchar>(row, col + 1) - 2*img.at<uchar>(row, col - 1) + img.at<uchar>(row + 1, col + 1) - img.at<uchar>(row + 1, col - 1), 2) + pow(img.at<uchar>(row + 1, col - 1) - img.at<uchar>(row - 1, col - 1) + 2*img.at<uchar>(row + 1, col) - 2*img.at<uchar>(row - 1, col) + img.at<uchar>(row + 1, col + 1) - img.at<uchar>(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<uchar>(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<uchar>(row, col) < 70) {
				Sobel_Ojld.at<uchar>(row, col) = 0;     // 小于阈值赋值为0，否则赋值255
			}
			else {
				Sobel_Ojld.at<uchar>(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<uchar>(row, col)] += 1;   //遍历到的像素值作为索引，次数+1
		}
	}
	int time = 0;         //定义遍历数组的变量，从0开始，依次输出0到255每个像素值的数目
	while (times <= 255) {
		cout << "像素值" << time << "的数目为：  " << pixel_num02[time] << endl;    // 遍历输出
		time++;                             // 不要忘了自增
	}


	OTSU(Sobel_Ojld, pixel_num01);     // OTSU阈值分割
	OTSU(Sobel_City, pixel_num02);

}