OpenCV阈值化处理

图像的阈值化就是利用图像像素点分布规律，设定阈值进行像素点分割，进而得到图像的二值图像。图像阈值化操作有多种方法，常用方法有经典的OTSU、固定阈值、自适应阈值、双阈值及半阈值化操作。这里对各种阈值化操作进行一个总结。

OTSU阈值化

在阈值化处理中，常用的算法就是OTSU。发明人是Nobuyuki Ostu。这种二值化操作阈值的选取非常重要，阈值选取的不合适，可能得到的结果就毫无用处。简单的说，这种算法假设衣服图像由前景色和背景色组成。通过统计学的方法来选取一个阈值，使这个阈值可以将前景色和背景色尽可能分开。

我们知道一幅灰度图像，可以计算它的颜色平均值，或者更进一步，可以计算出灰度直方图。我们可以把这幅图的灰度平均值为M，任意选取一个灰度值t，则可以将这个直方图分成前后两部分。我们称这两部分分别为A和B，对应的就是前景色和背景色。这两部分各自的平均值为$ M_0 \(和\) M_1 \(。A部分里的像素站总像素数的比例为\) p_0 \(，B部分里的像素数站总像素数的比例为\) p_1 $。Nobuyuki Ostu给出的类间方差定义为：

\[
ICV = p_0*(M_0 - M)^2 + p_1*(M_1 - M)^2\tag 1)
\]

展开后如下：

\[
p_0 M_0^2 - 2p_0M_0M+p_0M^2+ p_1M_1^2-2p_1M_1M+P_1M^2
\]

又：

\[ p_0 + p_1 = 1,p_0M_0 + p_1M_1 = M \]

带入(1)得如下：

\[
p_0p_1(M_0-M_1)^2
\]

其实现代码如下：

#include "opencv2/core/core.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp"
#include <iostream>
#include <string>
#include <cmath>

using namespace cv;
int Otsu(Mat matSrc)
{
    if (CV_8UC1 != matSrc.type())
        return -1;
    int nCols = matSrc.cols;
    int nRows = matSrc.rows;
    int nPixelNum = nCols * nRows;
    // 初始化
    int pixelNum[256];
    double probability[256];
    for (int i = 0; i < 256; i++)
    {
        pixelNum[i] = 0;
        probability[i] = 0.0;
    }
    // 统计像素数和频率
    for (int j = 0; j < nRows; j++)
    {
        for (int i = 0; i < nCols; i++)
        {
            pixelNum[matSrc.at<uchar>(j, i)]++;
        }
    }
    for (int i = 0; i < 256; i++)
    {
        probability[i] = (double)0.1*pixelNum[i] / nPixelNum;
    }
    // 计算
    int nThreshold = 0;          // 最佳阈值
    double dMaxDelta = 0.0;      // 最大类间方差
    double dMean_0 = 0.0;        // 左边平均值
    double dMean_1 = 0.0;        // 右边平均值
    double dDelta = 0.0;         // 类间方差
    double dMean_0_temp = 0.0;   // 左边平均值中间值
    double dMean_1_temp = 0.0;   // 右边平均值中间值
    double dProbability_0 = 0.0;       // 左边频率值
    double dProbability_1 = 0.0;       // 右边频率值
    for (int j = 0; j < 256; j++)
    {
        for (int i = 0; i < 256; i++)
        {
            if (i < j)// 前半部分
            {
                dProbability_0 += probability[i];
                dMean_0_temp += i * probability[i];
            }
            else      // 后半部分
            {
                dProbability_1 += probability[i];
                dMean_1_temp += i * probability[i];
            }
        }
        // 计算平均值
        // fMean_0_teamp计算的是前半部分的灰度值的总和除以总像素数，
        // 所以要除以前半部分的频率才是前半部分的平均值，后半部分同样
        dMean_0 = dMean_0_temp / dProbability_0;
        dMean_1 = dMean_1_temp / dProbability_1;
        dDelta = (double)(dProbability_0 * dProbability_1 * pow((dMean_0 - dMean_1), 2));
        if (dDelta > dMaxDelta)
        {
            dMaxDelta = dDelta;
            nThreshold = j;
        }
        // 相关参数归零
        dProbability_0 = 0.0;
        dProbability_1 = 0.0;
        dMean_0_temp = 0.0;
        dMean_1_temp = 0.0;
        dMean_0 = 0.0;
        dMean_1 = 0.0;
        dDelta = 0.0;
    }
    return nThreshold;
}

测试代码如下：

int main()
{
    std::string strPath = "D:\\MyDocuments\\My Pictures\\OpenCV\\";
    Mat matSrc = imread(strPath + "shrimp.jpg");
    if (matSrc.empty())
        return -1;
    int nCols = matSrc.cols;
    int nRows = matSrc.rows;
    Mat matGray;
    cvtColor(matSrc, matGray, CV_BGR2GRAY);
    imshow("gray", matGray);
    int nOstuThreshold = Otsu(matGray);
    std::cout << nOstuThreshold << std::endl;
    Mat matOstu = Mat::zeros(matGray.rows, matGray.cols, CV_8UC1);
    // 用得到的值进行二值化处理
    for (int j = 0; j < nRows; j++)
    {
        for (int i = 0; i < nCols; i++)
        {
            if (matGray.at<uchar>(j, i) < nOstuThreshold)
            {
                // matOstu.at<uchar>(j, i) = matGray.at<uchar>(j, i);
                matOstu.at<uchar>(j, i) = matGray.at<uchar>(j, i);
            }
            else
            {
                // matOstu.at<uchar>(j, i) = matGray.at<uchar>(j, i);
                matOstu.at<uchar>(j, i) = 0;
            }
        }
    }
    imshow("ostu", matOstu);
    imwrite(strPath + "ostu.jpg", matOstu);
    waitKey();
    return 0;
}

原图：

阈值处理后：

固定阈值化

OpenCV中提供了阈值化函数threshold，该函数有5中阈值化类型参数。简单说就是用一个固定阈值来分割图像。至于分割方式有多种。分别对应不同的阈值化方式。其函数原型如下：

double threshold(InputArray src, OutputArray dst, double thresh, double maxval, int type)

参数src表示原图像数组（单通道，8位或32位浮点数据）;dst表示输出图像组；thresh表示阈值大小;maxval表示预设最大值（THRESH_BINARY或THRESH_BINARY_INV时有用）;type表示阈值化处理的类型设置。type的各种类型如下：

THRESH_BINARY二进制阈值化

将灰度值大于thresh的设置为maxval，不大于thresh设置为0。灰度计算式如下：

\[dst(x, y) = \begin{cases}
maxval&src(x, y)>thresh\0&otherwise
\end{cases}\]

THRESH_BINARY_INV反二进制阈值化

将灰度值大于thresh的设置为0，不大于thresh设置为maxval。灰度计算式如下：

\[dst(x, y) = \begin{cases}
maxval&src(x, y)\leq thresh\0&otherwise
\end{cases}\]

THRESH_TRUNC截断阈值化

将灰度值大于thresh的设置为threshold，不大于thresh的灰度值不变。灰度计算式如下：

\[dst(x, y) = \begin{cases}
threshold &src(x, y)> thresh\src(x, y)&otherwise
\end{cases}\]

THRESH_TOZERO阈值化为0

将灰度值大于thresh的不变，不大于thresh的灰度值设置为0。灰度计算式如下：

\[dst(x, y) = \begin{cases}
src(x, y) &src(x, y)> thresh\0&otherwise
\end{cases}\]

THRESH_TOZERO_INV反阈值化为0

将灰度值大于thresh的不变，不大于thresh的灰度值设置为0。灰度计算式如下：

\[dst(x, y) = \begin{cases}
src(x, y) &src(x, y)\leq thresh\0&otherwise
\end{cases}\]

试例代码如下：

#include "opencv2/core/core.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp"
#include <iostream>
#include <string>
#include <cmath>

using namespace cv;
int main()
{
    std::string strPath = "D:\\MyDocuments\\My Pictures\\OpenCV\\";
    Mat matSrc = imread(strPath + "shrimp.jpg");
    Mat matGray, matThresh;
    cvtColor(matSrc, matGray, CV_BGR2GRAY);
    threshold(matGray, matThresh, 156, 255, CV_THRESH_TOZERO_INV);
    imshow("gray", matGray);
    imshow("thresh", matThresh);
    imwrite(strPath + "thresh.jpg", matThresh);
    waitKey();
    return 0;
}

原图：

阈值处理后的图：

自适应阈值化

在图像阈值化操作中，我们更关心的是从二值化图像中分离目标区域和背景区域，仅仅通过固定阈值很难达到理想的分割效果。在图片中的灰度是不均匀的，所以通常情况下图片中不同区域的阈值时不一样的。在不同局部选取阈值的方法有多种。在OpenCV中实现了两种方法：1）局部邻域块的均值；2）局部邻域块的高斯加权和。其函数原型如下：

void adaptiveThreshold(InoutArray src, OutputArray dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C)

src表示源图像数组；

dst表示输出图像组；

maxValue表示预设满足条件最大值；

adaptiveMethod表示自适应阈值算法选择ADAPTIVE_THRESH_MEAN_C或ADAPTIVE_THRESH_GAUSSIAN_C;

ADAPTIVE_THRESH_MEAN_C的计算方法是计算出邻域的平均值再减去第七个参数double C的值

ADAPTIVE_THRESH_GAUSSIAN_C的计算方法是计算出邻域的高斯均匀值再减去第七个参数double C的值

thresholdType表示阈值类型THRESH_BINARY或THRESH_BINARY_INV;

blockSize表示邻域块大小，用来计算区域阈值，一般选择3、5、7......;

参数C表示常数，它是一个从均匀或加权均值提取的常数，可以是负数。

试例代码如下：

#include "opencv2/core/core.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp"
#include <iostream>
#include <string>
#include <cmath>

using namespace cv;
int main_adaptive()
{
    std::string strPath = "D:\\MyDocuments\\My Pictures\\OpenCV\\";
    Mat matSrc = imread(strPath + "panda.jpg");
    Mat matGray, matAdaptive;
    cvtColor(matSrc, matGray, CV_BGR2GRAY);

    // adaptiveThreshold(matGray, matAdaptive, 255, ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY_INV, 5, 5);
    adaptiveThreshold(matGray, matAdaptive, 255, ADAPTIVE_THRESH_GAUSSIAN_C, THRESH_BINARY_INV, 5, 5);
    imshow("gray", matGray);
    imshow("adaptive", matAdaptive);
    imwrite(strPath + "adaptive.jpg", matAdaptive);

    waitKey();
    return 0;
}

原图： 阈值处理后的图：

原文地址：https://www.cnblogs.com/konglongdanfo/p/9135263.html

时间： 2024-10-12 09:06:34

OpenCV阈值化处理的相关文章

OpenCV的阈值化函数threshold

在OpenCV中,threshold用来进行对图像(二维数组)的二值化阈值处理 通过查找OpenCV在线文档,发现存在很多函数: 其函数原型如下: 1. C版本的:函数原型: void cvThreshold( const CvArr* src, CvArr* dst, double threshold,double max_value, int threshold_type ); src,dst: 不必多说,其要求类型一致性: threshold:需要设置的阈值,当像素值大于某个数字时,设定一

opencv学习之路（13）、图像阈值化

一.图像阈值化简介 二.固定阈值 三.自适应阈值 1 #include<opencv2/opencv.hpp> 2 using namespace cv; 3 4 void main(){ 5 Mat src=imread("E://1.jpg",0);//以灰度模式读入 6 Mat dst; 7 //threshold(src,dst,100,255,CV_THRESH_BINARY); 8 //adaptiveThreshold(src,dst,255,CV_ADAPT

OpenCV实现图像阈值化

纯粹阅读,请移步OpenCV实现图像阈值化 效果图 源码 KqwOpenCVBlurDemo 阈值化是一种将我们想要在图像中分析的区域分割出来的方法. 我们把每个像素值都与一个预设的阈值做比较,再根据比较的结果调整像素值. 类似这样 Imgproc.threshold(src,src,100,255,Imgproc.THRESH_BINARY); 其中100是阈值,255是最大值(纯白色的值). 常量 名称 常量 二值阈值化 Imgproc.THRESH_BINARY 阈值化到零 Imgproc

《OpenCV:灰度图像阈值化分割常见方法总结及VC代码》

支持原创,拿来收藏!转载地址:http://blog.csdn.net/likezhaobin/article/details/6915755?userName=u014395105&userInfo=aWOfy4XjkeuESVqMgVdrnPewKx6gaD2TZ6xUFF%2FXs%2FeZjmZKRHLyhzVPli3izF4JpSQuVNfcdFRe6pvuXl6VvRJ%2FSmjVpClq8XgXbwl56GUA19Luch91NWA57umNAidF94p6X1kqBpQ9l4%

openCV—Python(10)—— 图像阈值化处理

一.函数简介 1.threshold-图像简单阈值化处理 函数原型:threshold(src, thresh, maxval, type, dst=None) src:图像矩阵 thresh:阈值 maxVal:像素最大值 type:阈值化类型 2.adaptiveThreshold-图像自适应阈值化处理 函数原型:adaptiveThreshold(src, maxValue, adaptiveMethod, thresholdType, blockSize, C, dst=None) sr

【练习6.1】阈值化、腐蚀、cvFilter2D及自定义滤波器

提纲 题目要求 程序代码 结果图片 要言妙道 题目要求: 用cvFilter2D创建一个滤波器,只检测一副图像里的60度角的直线.将结果显示.做一下分部步操作: a.自定义卷积核,使用cvFilter2D,处理图像 b.对a的结果图片阈值化,是60度上的直线更清晰 c.对b的结果腐蚀 备注: 对于这道题,我的理解是,只保留一副图片60度角上的直线,是为了增加对自定义滤波器的熟悉度 在Opencv卷积滤波cvFilter2D一文中有更多常用的滤波器模板可以借鉴 程序代码: 1 // OpenCVE

Opencv3编程入门笔记（4）腐蚀、膨胀、开闭运算、漫水填充、金字塔、阈值化、霍夫变换

19      腐蚀erode.膨胀dilate 腐蚀和膨胀是针对图像中的白色部分(高亮部分)而言的,不是黑色的.除了输入输出图像外,还需传入模板算子element,opencv中有三种可以选择:矩形MORPH_RECT,交叉形MORPH_CROSS,椭圆形MORPH_ELLIPSE.Matlab中会有更多一点的模板. 例如: Mat element = getStructuringElement(MORPH_RECT,Size(15,15)); erode(srcImage,dstImage,

灰度图像阈值化分割常见方法总结及VC实现

转载地址:http://blog.csdn.net/likezhaobin/article/details/6915755 在图像处理领域,二值图像运算量小,并且能够体现图像的关键特征,因此被广泛使用.将灰度图像变为二值图像的常用方法是选定阈值,然后将待处理图像的每个像素点进行单点处理,即将其灰度值与所设置的门限进行比对,从而得到二值化的黑白图.这样一种方式因为其直观性以及易于实现,已经在图像分割领域处于中心地位.本文主要对最近一段时间作者所学习的阈值化图像分割算法进行总结,全文描述了作者对每种

阈值化

一.固定阈值化Threshold()函数 double threshold( InputArray src, OutputArray dst, double thresh, double maxval, int type ); 二.自适应阈值操作:adaptiveThreshold()函数 void adaptiveThreshold( InputArray src, OutputArray dst, double maxValue, int adaptiveMethod, int thresh