OpenCV学习基础图像操作（九）：阈值操作

最新推荐文章于 2024-01-17 17:20:03 发布

飓风神龙

最新推荐文章于 2024-01-17 17:20:03 发布

阅读量355

点赞数

分类专栏： Opecv 图像基础

本文链接：https://blog.csdn.net/fan1102958151/article/details/107300395

版权

Opecv 同时被 2 个专栏收录

16 篇文章 2 订阅

订阅专栏

图像基础

14 篇文章 1 订阅

订阅专栏

阈值类型

二值化(THRESH_BINARY)

$dst(x,y) = \begin{Bmatrix} max(val) \ \ \ \ \ \textit{if} \ src(x,y) > thresh \\ 0 \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ otherwise \end{matrix}$

反二值化(THRESH_BINARY_INV)

$dst(x,y) = \begin{Bmatrix} 0 \ \ \ \ \ \ \ \ \ \textit{if} \ src(x,y) > thresh \\ max(val) \ \ \ \ \ \ \ \ \ \ \ otherwise \end{matrix}$

截断(THRESH_TRUNC)

$dst(x,y) = \begin{Bmatrix} thresh \ \ \ \ \ \textit{if} \ src(x,y) > thresh \\ src(x,y) \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ otherwise \end{matrix}$

阈值取零(THRESH_TOZERO)

$dst(x,y) = \begin{Bmatrix} src(x,y) \ \ \ \ \ \textit{if} \ src(x,y) > thresh \\ 0 \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ otherwise \end{matrix}$

阈值反取零

$dst(x,y) = \begin{Bmatrix} 0 \ \ \ \ \ \textit{if} \ src(x,y) > thresh \\ src(x,y) \ \ \ \ \ \ \ \ \ \ \ \ otherwise \end{matrix}$

阈值算法

大津法（THRESH_OTSU）

核心思想

让前景与背景的类间方差最大，然后以此为分割界限。

算法流程

1.计算灰度直方图

2.假定阈值，划分为前景与背景

3.计算前景方差与后景方差

4.重复迭代2到4，找到前后景方差的最大分割值

代码实践

int otsuThreshold(IplImage* img)
{
	int T = 0;//阈值
	int height = img->height;
	int width = img->width;
	int step = img->widthStep;
	int channels = img->nChannels;
	uchar* data = (uchar*)img->imageData;
	double gSum0;//第一类灰度总值
	double gSum1;//第二类灰度总值
	double N0 = 0;//前景像素数
	double N1 = 0;//背景像素数
	double u0 = 0;//前景像素平均灰度
	double u1 = 0;//背景像素平均灰度
	double w0 = 0;//前景像素点数占整幅图像的比例为ω0
	double w1 = 0;//背景像素点数占整幅图像的比例为ω1
	double u = 0;//总平均灰度
	double tempg = -1;//临时类间方差
	double g = -1;//类间方差
	double Histogram[256]={0};// = new double[256];//灰度直方图
	double N = width*height;//总像素数

	for(int i=0;i<height;i++)
	{//计算直方图
		for(int j=0;j<width;j++)
		{
			double temp =data[i*step + j * 3] * 0.114 + data[i*step + j * 3+1] * 0.587 + data[i*step + j * 3+2] * 0.299;
			temp = temp<0? 0:temp;
			temp = temp>255? 255:temp;
			Histogram[(int)temp]++;
		} 
	}

	//计算阈值
	for (int i = 0;i<256;i++)
	{

		gSum0 = 0;
		gSum1 = 0;
		N0 += Histogram[i];			
		N1 = N-N0;
		if(0==N1)break;//当出现前景无像素点时，跳出循环
		w0 = N0/N;
		w1 = 1-w0;
		for (int j = 0;j<=i;j++)
		{
			gSum0 += j*Histogram[j];
		}
		u0 = gSum0/N0;
		for(int k = i+1;k<256;k++)
		{
			gSum1 += k*Histogram[k];
		}

		u1 = gSum1/N1;
		//u = w0*u0 + w1*u1;
		g = w0*w1*(u0-u1)*(u0-u1);

                //让类间最大方差最大
		if (tempg<g)
		{
			tempg = g;
			T = i;
		}
	}
	return T; 
}

三角法(THRESH_TRIANGLE)

核心思想

利用纯几何方法来寻找最佳阈值，它的成立条件是假设直方图最大波峰在靠近最亮的一侧，然后通过三角形求得最大直线距离，根据最大直线距离对应的直方图灰度等级即为分割阈值：

这里写图片描述

在直方图上从最高峰处bmx到最暗对应直方图bmin(p=0)%构造一条直线，从bmin处开始计算每个对应的直方图b到直线的垂直距离，知道bmax为止，其中最大距离对应的直方图位置即为图像二值化对应的阈值T。

扩展情况：
有时候最大波峰对应位置不在直方图最亮一侧，而在暗的一侧，这样就需要翻转直方图，翻转之后求得值，用255减去即得到为阈值T。扩展情况的直方图表示如下：
这里写图片描述

算法流程

1. 图像转灰度
2. 计算图像灰度直方图
3. 寻找直方图中两侧边界
4. 寻找直方图最大值
5. 检测是否最大波峰在亮的一侧，否则翻转
6. 计算阈值得到阈值T，如果翻转则255-T

代码实践

int otsuThreshold(IplImage* img)
{
	int T = 0;//阈值
	int height = img->height;
	int width = img->width;
	int step = img->widthStep;
	int channels = img->nChannels;
	uchar* data = (uchar*)img->imageData;


        int temp = 0;
        bool isflipped = false;

        QVector<int> histogram(256);


        //直方图
        for(int row = 0; row < height; row++)
        {
            for(int col = 0; col<width; col++)
            {
                gray = qGray(image.pixel(col,row));
                histogram[gray] ++;
            }
        }

            //3. 寻找直方图中两侧边界
    int left_bound = 0;
    int right_bound = 0;
    int max = 0;
    int max_index = 0;

    //左侧为零的位置
    for(i = 0; i<256; i++)
    {
        if(histogram[i]>0)
        {
            left_bound = i;
            break;
        }
    }
    //直方图为零的位置
    if(left_bound > 0)
    {
        left_bound --;
    }


    //直方图右侧为零的位置
    for(i = 255; i>0; i--)
    {
        if(histogram[i]>0)
        {
            right_bound = i;
            break;
        }
    }
    //直方图为零的地方
    if(right_bound >0)
    {
        right_bound++;
    }

    //4. 寻找直方图最大值
    for(i = 0; i<256;i++)
    {
        if(histogram[i] > max)
        {
            max = histogram[i];
            max_index = i;
        }
    }

    //判断最大值是否在最左侧，如果是则不用翻转
    //因为三角法二值化只能适用于最大值在最右侧
    if(max_index - left_bound  < right_bound - max_index)
    {
        isflipped = true;
        i = 0;
        j = 255;
        while( i < j )
        {
            // 左右交换
            temp = histogram[i]; histogram[i] = histogram[j]; histogram[j] = temp;
            i++; j--;
        }
        left_bound = 255-right_bound;
        max_index = 255-max_index;
    }


    // 计算求得阈值
    double thresh = left_bound;
    double a, b, dist = 0, tempdist;
    a = max; b = left_bound-max_index;
    for( i = left_bound+1; i <= max_index; i++ )
    {
       // 计算距离 - 不需要真正计算
       tempdist = a*i + b*histogram[i];
       if( tempdist > dist)
       {
           dist = tempdist;
           thresh = i;
       }
    }
    thresh--;

    // 对已经得到的阈值T,如果前面已经翻转了，则阈值要用255-T
    if( isflipped )
    {
         thresh = 255-thresh;
    }

    return thresh;
}

API简介

threshold(gray_src, dst, threshold_value, threshold_max, THRESH_BINARY);

#gray_src 输入的灰度图 输入图片必须是单通道的
#threshold_value  分割阈值
#threshold_max    分割后的上限
#THRESH_BINARY   分割方式

代码实践

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

using namespace cv;
using namespace std;
char OUTPUT[] = "OUTPUT_WINDOS";
int threshold_value = 127;
int threshold_max = 255;
void Threshold_Demo(int, void*);
Mat src, gray_src,dst;
int type_value = 2;
int type_max = 4;
int main(int argc, char* argv[])
{
	//src = imread("src.jpg");
	src = imread("cat.png");
	if (!src.data)
	{
		cout << "cannot open image" << endl;
		return -1;
	}
	namedWindow("input image", WINDOW_AUTOSIZE);
	namedWindow(OUTPUT, WINDOW_AUTOSIZE);
	imshow("input image", src);
	createTrackbar("Type Value:", OUTPUT, &type_value, type_max, Threshold_Demo);
	createTrackbar("Threshold Value:", OUTPUT,&threshold_value,threshold_max,Threshold_Demo);
	
	Threshold_Demo(0, 0);


	waitKey(0);
	return 0;
}

void Threshold_Demo(int , void*)
{
	cvtColor(src, gray_src, COLOR_BGR2GRAY);
	threshold(gray_src, dst, threshold_value, threshold_max, type_value);
	imshow(OUTPUT, dst);
}