OpenCV之阈值化

2020-12-20

图像的与阈值化操作就是利用图像像素点分布规律，设定阈值进行像素点分割，进而得到图像的二值化图像。

在阈值化处理中，最常用的算法就是OTSU，OTSU是一种寻找图像阈值的最大类间方差算法。算法步骤如下：

（1）统计灰度级每个像素在整个图像中的数量

（2）计算每个像素在整个图像中得概率分布

（3）对灰度级进行遍历搜索，计算当前灰度值下前景背景类间概率

（4）通过目标函数计算类内与类间下对应的阈值

从255个灰度级遍历t，使得t为某个值的时候，前景和背景的方差最大，则这个 t 值便是我们要求得的阈值。

示例代码如下：

#include <iostream>
#include <string>
#include <cmath>
#include <opencv2/opencv.hpp>
using std::sin;
using std::cos;
//使用CommandLineParser对输入的参数进行分析，获取输入的图片路径
std::string GetFileName(int argc,char* argv[])
{
    /*
    argc : the size of argv[]
    argv : the parameters of comdline
    */
    const char* key = {
    "{help h usage? || usage information}"
    "{@picture || input picture}"
    };
     cv::CommandLineParser parser(argc,argv,key);
    if (parser.has("help"))
    {
        parser.printMessage();
        exit(0);
    }
    //如果没有输入图片路径
    if (!parser.check())
    {
        parser.printErrors();
        exit(-1);
    }
    std::string fileName = parser.get<std::string>(0);
    return fileName;
}
int OTSU(const cv::Mat& inputImage)
{
    int rows = inputImage.rows;
    int cols = inputImage.cols;
    int threshold = 0;
    //统计每个像素
    int nPixels[256] = {0};
    float nProdis[256];
    for(int i=0;i < 256;i++)
    {
        nPixels[i] = 0;
        nProdis[i] = 0;
    }
    for(int i=0;i < rows;i++)
    {
        for(int j=0;j < cols;j++)
        {
            nPixels[(int)inputImage.at<uchar>(j,i)] ++;
        }
    }
    //计算概率分布
    for(int i = 0;i < 256;i++)
    {
        nProdis[i] = (float) nPixels[i] / (rows * cols);
    }
    //遍历灰度级，找出类内类间最大方差
    float delta_temp = 0;
    double delta_max = 0;
    float w0,w1,u0,u1,u0_temp,u1_temp;
    for(int i=0;i < 256;i++)
    {
        w0 = 0; w1 =0;u0=0;u1=0;u0_temp = 0;u1_temp=0;delta_temp=0;
        for(int  j=0;j < 256;j++)
        {
            if (j <= i)
            {
                w0 += nProdis[j];
                u0_temp += j*nProdis[j];
            }
            else
            {
                w1 += nProdis[j];
                u1_temp += j* nProdis[j];
            }
        }
        //计算平均灰度
        u0 = u0_temp / w0;
        u1 = u1_temp / w1;
        delta_temp = (float)(w0 * w1*pow((u0-u1),2));
        if (delta_temp > delta_max)
        {
            delta_max = delta_temp;
            threshold = i;
        }
    }



    return threshold;
}
int main(int argc,char *argv[])
{
    std::string ImageFilePath = GetFileName(argc,argv);
    cv::Mat srcImage = cv::imread(ImageFilePath);
    if (srcImage.empty())
    {
        std::cerr << "fail to load image" <<std::endl;
        exit(-1);
    }
    cv::Mat grayImage;
    cv::cvtColor(srcImage,grayImage,cv::COLOR_BGR2GRAY);
    int threshold = OTSU(grayImage);
    cv::Mat otsuImage = cv::Mat::zeros(grayImage.size(),CV_8UC1);

    for(int i=0; i < grayImage.rows;i++)
    {
        for(int j = 0;j < grayImage.cols;++j)
        {
            if (grayImage.at<uchar>(j,i) > threshold)
                otsuImage.at<uchar>(j,i) = 255;
        }
    }


    cv::imshow("gray",grayImage);
    cv::imshow("otsu",otsuImage);
    cv::waitKey(0);
    cv::destroyAllWindows();
    return 0;
}