otsu算法详细推导、实现及Multi Level OTSU算法实现

微信公众号：幼儿园的学霸

目录

简介

OTSU算法也称最大类间差法，有时也称之为大津算法，由大津于1979年提出，被认为是图像分割中阈值选取的最佳算法，计算简单，不受图像亮度和对比度的影响，因此在数字图像处理上得到了广泛的应用。它是按图像的灰度分布特性,将图像分成背景(background)和目标(object)两部分。考虑到方差是灰度分布均匀性的一种度量,理想情况下，对于同一类，其类内方差应该是很小的，同时背景和目标之间的类间方差越大,说明构成图像的两部分的差别越大,当部分目标错分为背景或部分背景错分为目标都会导致两部分差别变小。因此,使类间方差最大的分割意味着错分概率最小。

该方法的基本思想是根据选取的阈值将图像分为目标和背景两个部分，计算该灰度值下的类间方差值，将类间方差最大时对应的阈值/灰度值作为最佳阈值。

推导及实现

常规推导

设图像尺寸为MxN,其二值化的最佳阈值为T,该阈值将图像分为背景和目标2类别。其中属于背景的像素点数量为N0，属于目标的像素点数量为N1;背景像素点数占整幅图像的比例为${\omega }_0$,其灰度均值为${\mu }_0$;目标像素点数占整幅图像的比例为${\omega }_1$,其灰度均值为${\mu }_1$;整幅图像的灰度均值为$\mu$,则:
$${\omega }_0=\frac{N_0}{M\ast N}\text{\hspace{1em}(1)}$$

$${\omega }_1=\frac{N_1}{M\ast N}\text{\hspace{1em}(2)}$$

$$N_0+N_1=M\ast N\text{\hspace{1em}(3)}$$
由上面公式(1)(2)(3)得:
$${\omega }_0+{\omega }_1=1\text{\hspace{1em}(4)}$$

$$\begin{array}{rl}\mu & =\frac{{\mu }_0\ast N_0+{\mu }_1\ast N_1}{M\ast N}\\ & ={\mu }_0{\omega }_0+{\mu }_1{\omega }_1\end{array}\text{\hspace{1em}(5)}$$
在论文中，类内方差(Within-class variance)公式如下:

$${\sigma }_W^2={\omega }_0{\sigma }_0^2+{\omega }_1{\sigma }_1^2\text{\hspace{1em}(6)}$$

从上式可以看出,类内方差指的是两类像素的方差的加权和，这里权指的是该类像素点数量占整个图像像素点数量的比值

类间方差(Between-class variance)的公式如下:

$${\sigma }_B^2={\omega }_0({\mu }_0-{\mu }_T{)}^2+{\omega }_1({\mu }_1-{\mu }_T{)}^2\text{\hspace{1em}(7)}$$
可等价为:

$${\sigma }_B^2={\omega }_0{\omega }_1({\mu }_0-{\mu }_1{)}^2\text{\hspace{1em}(8)}$$
其推导过程如下:

$$\begin{array}{rl}{\sigma }_B^2& ={\omega }_0({\mu }_0-\mu {)}^2+{\omega }_1({\mu }_1-\mu {)}^2\\ & ={\omega }_0({\mu }_0-({\omega }_0{\mu }_0+{\omega }_1{\mu }_1){)}^2+{\omega }_1({\mu }_1-({\omega }_0{\mu }_0+{\omega }_1{\mu }_1){)}^2\\ & ={\omega }_0({\mu }_0-{\omega }_0{\mu }_0-{\omega }_1{\mu }_1{)}^2+{\omega }_1({\mu }_1-{\omega }_0{\mu }_0-{\omega }_1{\mu }_1{)}^2\\ & ={\omega }_0((1-{\omega }_0){\mu }_0-{\omega }_1{\mu }_1{)}^2+{\omega }_1((1-{\omega }_1){\mu }_1-{\omega }_0{\mu }_0{)}^2\\ & ={\omega }_0({\omega }_1{\mu }_0-{\omega }_1{\mu }_1{)}^2+{\omega }_1({\omega }_0{\mu }_1-{\omega }_0{\mu }_0{)}^2\\ & ={\omega }_0({\omega }_1({\mu }_0-{\mu }_1){)}^2+{\omega }_1({\omega }_0({\mu }_1-{\mu }_0){)}^2\\ & ={\omega }_0{\omega }_1^2({\mu }_0-{\mu }_1{)}^2+{\omega }_1{\omega }_0^2({\mu }_1-{\mu }_0{)}^2\\ & =({\omega }_0+{\omega }_1){\omega }_0{\omega }_1({\mu }_0-{\mu }_1{)}^2\\ & ={\omega }_0{\omega }_1({\mu }_0-{\mu }_1{)}^2\end{array}\text{\hspace{1em}(9)}$$
理想情况下，对于同一类，其类内方差应该是很小的，同时背景和目标之间的类间方差越大,说明构成图像的两部分的差别越大。因此采用遍历的方法得到使类间方差最大的阈值T即为所求。

大津法的形象理解：对于直方图有两个峰值的图像，大津法求得的Ｔ近似等于两个峰值之间的低谷

算法步骤及实现

步骤

按照上面的公式,可以初步确定一个容易实现的算法过程:
1.根据图像的尺寸确定图像总的像素点数量MxN
2.遍历图像灰度级0-255中的每一个灰度值L,
假设L将图像分为背景(Background)和目标(Object)两部分
2.1 求解背景的像素点数量及像素的灰度值和$N_0,Su{m}_0$;目标的像素点数量及像素的灰度值和$N_1,Su{m}_1$;
2.2 根据上面公式(1)(2)求解两类像素点各自占图像的比例${\omega }_0,{\omega }_1$;
根据下面的公式计算两类的灰度均值${\mu }_0,{\mu }_1$:

$$\begin{gathered} {\mu }_0=\frac{Su{m}_0}{N_0} \\ {\mu }_1=\frac{Su{m}_1}{N_1} \end{gathered}$$

2.3 根据公式(8)计算类间方差
3.在上面遍历过程中找到使类间方差最大的灰度值L即为所求

上面步骤存在很大的优化空间，仅为说明算法过程

实现

实现代码如下:

//
// Created by liheng on 11/22/20.
//

#include <iostream>
#include <chrono>
#include <opencv2/opencv.hpp>

/*!
 * 大津法求解二值化分割阈值
 * @param image 输入图像.CV_8UC1
 * @return >0 大津法求解的分割阈值
 * @author liheng
 */
int ThresholdOTSU(const cv::Mat &image)
{
    CV_Assert( image.type() == CV_8UC1 );

    int thresh = -1;

    int pixNumber = image.cols * image.rows;//图像总像素点
    int pixCount[256] = { 0 }; //每个灰度值所占像素个数.灰度级为0-255.


    //1°统计每个灰度级中像素的个数.本质:灰度直方图
    {
        //for (int i=0; i<image.rows; ++i)
        //{
        //    for (int j=0; j<image.cols; ++j)
        //        pixCount[image.at<unsigned char>(i,j)]++;
        //}

        cv::Size size(image.size());
        if( image.isContinuous() )
        {
            size.width *= size.height;
            size.height = 1;
        }
        for(int i=0; i<size.height; ++i )
        {
            const uchar* sdata = image.ptr(i);
            for( int j = 0; j < size.width; ++j )
                pixCount[sdata[j]] += 1;
        }
    }

    //2°穷举0-255各灰度,求解使得类间方差最大的灰度值k
    const auto PpixNum = 1.0f/image.rows*image.cols;//像素总数
    float gmax = -FLT_MAX;
    for(int k=0;k<256;++k)
    {
        //背景及前景的像素点数量及和(用于求均值)
        int backNum = 0;
        float backSum = 0;

        int objectNum = 0;
        float objectSum = 0;

        //遍历区分背景和前景
        //for(int i=0;i<256;++i)
        //{
        //    if( i<=k )//背景,此处为i<=k,如果为i<k呢?
        //    {
        //        backNum +=pixCount[i];
        //        backSum += i*pixCount[i];
        //    }
        //    else//前景
        //    {
        //        objectNum += pixCount[i];
        //        objectSum += i*pixCount[i];
        //    }
        //}

        //上面修改为该形式,能够减少for循环中的判断
        //阈值k将像素分为背景和前景2部分
        for(int i=0;i<=k;++i)//背景,此处为i<=k,如果为i<k呢?
        {
            backNum +=pixCount[i];
            backSum += i*pixCount[i];
        }
        for(int i=k+1;i<256;++i)//前景
        {
            objectNum += pixCount[i];
            objectSum += i*pixCount[i];
        }

        //求解类间方差
        const auto w0 = backNum*PpixNum;
        const auto w1 = objectNum*PpixNum;
        //考虑到PpixNum为定值,上面2行可修改为下面形式,但结果可能与opencv结果存在稍许不同!!!
        //const auto w0 = backNum;
        //const auto w1 = objectNum;

        const float u0 = backSum*1.0f/(backNum+FLT_EPSILON);
        const float u1 = objectSum*1.0f/(objectNum+FLT_EPSILON);

        const float sigma = w0*w1*std::pow((u0-u1),2);//w0*w1*(u0-u1)^2
        if( sigma>=gmax )
        {
            thresh = k;
            gmax = sigma;
        }
    }

    //利用概率学相关内容,考虑将上面的双重循环,修改为单层循环


    return thresh;
}

void ShowHist(const cv::Mat& image,cv::Mat& hist_img,int scale=2)
{
    int bins = 256;
    int hist_size[] = {bins};
    float range[] = { 0, 256 };
    const float* ranges[] = { range};
    cv::MatND hist;
    int channels[] = {0};

    cv::calcHist( &image, 1, channels, cv::Mat(), // do not use mask
              hist, 1, hist_size, ranges,
              true, // the histogram is uniform
              false );

    double max_val;
    cv::minMaxLoc(hist, nullptr, &max_val, nullptr, nullptr);
    const int hist_height=image.rows;
    hist_img = cv::Mat::zeros(hist_height,bins*scale, CV_8UC3);
    for(int i=0;i<bins;i++)
    {
        float bin_val = hist.at<float>(i);
        int intensity = cvRound(bin_val*hist_height/max_val);  //要绘制的高度
        cv::rectangle(hist_img,cv::Point(i*scale,hist_height-1),
                  cv::Point((i+1)*scale - 1, hist_height - intensity),
                  CV_RGB(255,255,255));
    }
    
    //cv::copyMakeBorder(hist_img,hist_img,10,10,10,10,cv::BORDER_CONSTANT,cv::Scalar(0,0,0));
}

int main()
{
    cv::Mat image = cv::imread("./input.bmp",cv::IMREAD_GRAYSCALE);
    cv::imshow("src",image);

    //求解直方图
    cv::Mat hist_img;
    int scale = 2;
    ShowHist(image,hist_img);

    cv::Mat ourdst,cvdst;

    auto th = ThresholdOTSU(image);
    cv::threshold(image,ourdst,th,255,cv::THRESH_BINARY);
    
    //在直方图上绘制阈值位置
    cv::line(hist_img,cv::Point(th*scale,0),cv::Point(th*scale,hist_img.rows-1),cv::Scalar(0,0,255),2);

    auto cvTh = cv::threshold(image,cvdst,0,255,cv::THRESH_OTSU);
    
    cv::imshow("hist",hist_img);
    cv::imshow("ourdst",ourdst);
    cv::imshow("cvdst",cvdst);



    cv::waitKey(0);

    return 0;
}

输入图像如下所示:

OTSU阈值分割结果如下(和OpenCV分割结果一致,OpenCV源码分割结果不在展示):

输入图像的灰度直方图和OTSU阈值如下图所示:图像中的红线位置为OTSU算法求解的阈值:

可以看到OTSU算法求解的阈值和灰度直方图中的2个双峰均值比较接近。

如果选择两个波峰之间的波谷作为阈值，就能轻松地把这两类像素分开。但是图像的直方图往往是不连续的，有非常多尖峰和抖动，要找到准确的极值点十分困难

从概率的角度解释

在上面的介绍中对OTSU算法的实现思想已经有了一定的认知。接着从概率学的角度继续探讨该算法。

推导

设待分割图像有L个灰度级,灰度值范围为[0,1,2,...,L-2,L-1],其中灰度值为i的像素个数为$n_i$,那么可以得到图像总的像素个数为:
$$\begin{array}{rl}N& =n_1+n_2+\cdots +n_{L-2}+n_{L-1}\\ & =\sum _{i=0}^{L-1}{n}_i\end{array}\text{\hspace{1em}(11)}$$
则灰度值为i的像素在图像中出现的概率为:
$$p_i=\frac{n_i}{N_i},p_i\ge 0,\sum _{i=0}^{L-1}{p}_i=1\text{\hspace{1em}(12)}$$
假设灰度值(阈值)k将图像中的像素划分为2类:$C_0,C_1$,其中类$C_0$中像素的灰度级为$[0,1,\cdots ,k-1,k]$,类$C_1$中像素的灰度级为$[k+1,k+2,\cdots ,L-2,L-1]$
在图像中，某一类别出现的概率为:
$$\begin{array}{rl}{\omega }_0& =P_r(C_0)=\sum _{i=0}^k{p}_i=\omega (k)\\ {\omega }_1& =P_r(C_1)=\sum _{i=k+1}^{L-1}{p}_i=1-\omega (k)\end{array}\text{\hspace{1em}(13)}$$
上面公式中，记为$\omega (k)$是为了将出现概率和分割阈值k之间以函数的形式联系起来。后述公式是同样的道理。
根据期望公式,图像整体灰度值为:
$$\mu =\mu (L)=\sum _{i=0}^{L-1}i\ast p_i\text{\hspace{1em}(14)}$$
根据条件概率公式,某一类别的平均灰度值为:
$$\begin{array}{rl}{\mu }_0& =\sum _{i=0}^{k}i\ast P_r(i\mid C_0)=\sum _{i=0}^{k}i\ast \frac{p_i}{{\omega }_0}\\ & =\sum _{i=0}^k\frac{i{p}_i}{\omega (k)}=\frac{1}{\omega (k)}\sum _{i=0}^{k}i{p}_i\\ & =\frac{\mu (k)}{\omega (k)}\end{array}\text{\hspace{1em}(15)}$$
同理,
$$\begin{array}{rl}{\mu }_1& =\sum _{i=k+1}^{L-1}i\ast P_r(i\mid C_1)=\sum _{i=k+1}^{L-1}i\ast \frac{p_i}{{\omega }_1}\\ & =\frac{\mu -\mu (k)}{1-\omega (k)}\end{array}\text{\hspace{1em}(16)}$$
根据上述公式(13)~(16),对于任一分割阈值k,有下面公式成立:
$${\omega }_0{\mu }_0+{\omega }_1{\mu }_1=\mu ,{\omega }_0+{\omega }_1=1\text{\hspace{1em}(17)}$$

除了期望,还可以计算图像的方差和各类别的方差，如下:
$$\begin{array}{c}{\sigma }^2=\sum _{i=0}^{L-1}(i-\mu {)}^2{p}_i\\ {\sigma }_0^2=\sum _{i=0}^k(i-{\mu }_0{)}^2{P}_r(i\mid C_0)=\sum _{i=0}^k\frac{(i-{\mu }_0{)}^2{p}_i}{{\omega }_0}\\ {\sigma }_1^2=\sum _{i=k+1}^{L-1}(i-{\mu }_1{)}^2{P}_r(i\mid C_1)=\sum _{i=k+1}^{L-1}\frac{(i-{\mu }_1{)}^2{p}_i}{{\omega }_1}\end{array}\text{\hspace{1em}(18)}$$

再对公式(8)进行进一步整理:
$$\begin{array}{rl}{\sigma }_B^2& ={\omega }_0{\omega }_1({\mu }_0-{\mu }_1{)}^2\\ & ={\omega }_0{\omega }_1{\left(\frac{\mu (k)}{\omega (k)}-\frac{\mu -\mu (k)}{1-\omega (k)}\right)}^2\\ & =\omega (k)(1-\omega (k)){\left(\frac{\mu (k)\ast (1-\omega (k))-\omega (k)\ast (\mu -\mu (k))}{\omega (k)\ast (1-\omega (k))}\right)}^2\\ & =\omega (k)(1-\omega (k)){\left(\frac{\mu (k)-\mu \ast \omega (k)}{\omega (k)\ast (1-\omega (k))}\right)}^2\\ & =\frac{{\left(\mu (k)-\mu \ast \omega (k)\right)}^2}{\omega (k)(1-\omega (k))}\end{array}\text{\hspace{1em}(19)}$$
因此求解最大类间方差可写作:
$${\sigma }_B^2\left(k^{\ast }\right)=\underset{0\le k<L}{\max }{\sigma }_B^2(k)\text{\hspace{1em}(20)}$$

公式(19)以函数的表达形式展示类间方差和分割阈值k之间的关系. 图像整体的灰度均值和分割阈值是无关的，这样能够进一步优化代码实现，优化后的代码附后。

在论文中还有下列公式成立：
$${\sigma }_W^2+{\sigma }_B^2={\sigma }^2\text{\hspace{1em}(21)}$$
即类间方差和类内方差的和为定值,也即最大化类间差异就是最小化类内差异
下面对公式(20)进行推导
$$\begin{array}{rl}{\sigma }_W^2+{\sigma }_B^2& =\left({\omega }_0{\sigma }_0^2+{\omega }_1{\sigma }_1^2\right)+\left({\omega }_0({\mu }_0-\mu {)}^2+{\omega }_1({\mu }_1-\mu {)}^2\right)\\ & =\left({\omega }_0{\sigma }_0^2+{\omega }_0({\mu }_0-\mu {)}^2\right)+\left({\omega }_1{\sigma }_1^2+{\omega }_1({\mu }_1-\mu {)}^2\right)\end{array}\text{\hspace{1em}(22)}$$

其中:

$$\begin{array}{rl}{\omega }_0{\sigma }_0^2& ={\omega }_0\left[\frac{1}{{\omega }_0}\ast \sum _{i=0}^k{\left(i-{\mu }_0\right)}^2{p}_i\right]={\omega }_0\left[\frac{1}{{\omega }_0}\ast \sum _{i=0}^k{\left(\left(i-\mu \right)+\left(\mu -{\mu }_0\right)\right)}^2{p}_i\right]\\ & ={\omega }_0\left[\frac{1}{{\omega }_0}\ast \sum _{i=0}^k\left({\left(i-\mu \right)}^2+2\left(i-\mu \right)\left(\mu -{\mu }_0\right)+{\left(\mu -{\mu }_0\right)}^2\right)p_i\right]\\ & =\left(\sum _{i=0}^k{\left(i-\mu \right)}^2\ast p_i\right)+\left(\sum _{i=0}^{k}2(i-\mu )(\mu -{\mu }_0)\ast p_i\right)+\left((\mu -{\mu }_0{)}^2\ast \sum _{i=0}^k{p}_i\right)\\ & =\left(\sum _{i=0}^k{\left(i-\mu \right)}^2\ast p_i\right)+\left(2(\mu -{\mu }_0)\sum _{i=0}^k(i-\mu )p_i\right)+\left({\omega }_0(\mu -{\mu }_0{)}^2\right)\\ & =\left(\sum _{i=0}^k{\left(i-\mu \right)}^2\ast p_i\right)+2(\mu -{\mu }_0)\left[\sum _{i=0}^{k}i{p}_i-\mu \sum _{i=0}^k{p}_i\right]+\left({\omega }_0(\mu -{\mu }_0{)}^2\right)\\ & =\left(\sum _{i=0}^k{\left(i-\mu \right)}^2\ast p_i\right)+\left(2(\mu -{\mu }_0)\sum _{i=0}^k(i-\mu )p_i\right)+\left({\omega }_0(\mu -{\mu }_0{)}^2\right)\\ & =\left(\sum _{i=0}^k{\left(i-\mu \right)}^2\ast p_i\right)+2(\mu -{\mu }_0)\left[\sum _{i=0}^{k}i{p}_i-\mu \sum _{i=0}^k{p}_i\right]+\left({\omega }_0(\mu -{\mu }_0{)}^2\right)\\ & =\left(\sum _{i=0}^k{\left(i-\mu \right)}^2\ast p_i\right)+2(\mu -{\mu }_0)\left({\omega }_0{\mu }_0-\mu {\omega }_0\right)+\left({\omega }_0(\mu -{\mu }_0{)}^2\right)\text{根据公式(15),(13)进行替换而来}\\ & =\left(\sum _{i=0}^k{\left(i-\mu \right)}^2\ast p_i\right)-2{\omega }_0({\mu }_0-\mu {)}^2+\left({\omega }_0(\mu -{\mu }_0{)}^2\right)\\ & =\left(\sum _{i=0}^k{\left(i-\mu \right)}^2\ast p_i\right)-{\omega }_0({\mu }_0-\mu {)}^2\end{array}\text{\hspace{1em}(23)}$$

同样可推导:

$$\begin{array}{r}{\omega }_1{\sigma }_1^2=\left(\sum _{i=k+1}^{L-1}{\left(i-\mu \right)}^2\ast p_i\right)-{\omega }_1({\mu }_1-\mu {)}^2\end{array}\text{\hspace{1em}(24)}$$

因此,式(21)可继续展开:
$$\begin{array}{rl}{\sigma }_W^2+{\sigma }_B^2& =\left({\omega }_0{\sigma }_0^2+{\omega }_0({\mu }_0-\mu {)}^2\right)+\left({\omega }_1{\sigma }_1^2+{\omega }_1({\mu }_1-\mu {)}^2\right)\\ & =\sum _{i=0}^k{\left(i-\mu \right)}^2\ast p_i+\sum _{i=k+1}^{L-1}{\left(i-\mu \right)}^2\ast p_i\\ & =\sum _{i=0}^{L-1}{\left(i-\mu \right)}^2\ast p_i\\ & ={\sigma }^2\end{array}\text{\hspace{1em}(25)}$$

公式得证。

实现

按照公式(19)进行实现的代码如下:

int ThresholdOTSU2(const cv::Mat &image)
{
    CV_Assert( image.type() == CV_8UC1 );

    int thresh = -1;

    int pixNumber = image.cols * image.rows;//图像总像素点
    float Ppix[256] = { 0 }; //每一个灰度值出现的概率
    float u = 0;//图像整体均值
    //公式12,每一灰度值出现的概率
    {
        //求各灰度值出现的次数
        cv::Size size(image.size());
        if( image.isContinuous() )
        {
            size.width *= size.height;
            size.height = 1;
        }

        for(int i=0; i<size.height; ++i )
        {
            const uchar* sdata = image.ptr(i);
            for( int j = 0; j < size.width; ++j )
                Ppix[sdata[j]] += 1;
        }

        //求灰度值出现的概率及整体均值
        const auto p = 1.0/pixNumber;
        for(int i=0;i<256;++i)
        {
            Ppix[i] *= p;
            u += i*Ppix[i];
        }

    }
    
    //遍历
    float wk=0;
    float uk=0;
    float gmax = -FLT_MAX;
    for(int k=0;k<256;++k)
    {
        //注意此处.没有在每个循环中遍历求0-k的和,
        // 而是在上一次求解的基础上累加,防止重复计算
        wk += Ppix[k];//0-k灰度值的像素 出现的概率.Note:包含k
        uk += k*Ppix[k];

        const auto temp = uk-u*wk;
        const auto sigma = temp*temp/(wk*(1-wk)+FLT_EPSILON);
        if( sigma>=gmax )//考虑对相同的最大方差下的阈值进行存储,然后求这些阈值的均值
        {
            thresh = k;
            gmax = sigma;
        }

    }

    return thresh;
}

扩展-MultiLevel OTSU

在上面的算法中,讨论的是2个类别的分割，针对图像来说就是二值化处理。如果对该问题进行扩展，我们想把图像像素划分为M类,则对应的目标函数可以扩展为:
$${\sigma }_B^2=\sum _{k=0}^{M-1}{\omega }_k{\left({\mu }_k-\mu \right)}^2$$

对大津算法的多级推广成为多大津算法（multi Otsu method）
论文: A Fast Algorithm for Multilevel Thresholding. 来自台湾的一篇论文,说明还是比较详细.

我们需要找到$(t_0,t_1,\cdots ,t_{M-1},\mid t_0<t_1<\cdots <t_{M-1})$使得目标函数(类间方差)取最大值
根据上一节的结论:类间方差和类内方差的和为定值,因此最小化类内方差和最大化类间方差是相同的,因此目标函数可以进行修改如下:
$${\sigma }_W^2=\sum _{k=0}^{M-1}{w}_k{\mu }_k^2$$

找出使上公式最小的一系列阈值即可。

此处为我的理解，正好和原论文中结论相反

关于多阈值OTSU算法在上面提到的论文中有比较详细的说明,里面讨论了其算法实现、简化过程，以实现fast的目的.该部分暂时不赘述,看后面的情况,有时间在补上一篇.
此处将按照论文实现的算法贴出,有需要的可以浏览一番.

#include <iostream>
#include <chrono>
#include <opencv2/opencv.hpp>
#include <numeric>
cv::Mat SegImage(const cv::Mat &src,const std::vector<int> &thresholds,const std::vector<cv::Vec3b> &colors);


/*!
 * 多级大津算法
 * @param image 输入图像.CV_8UC1
 * @param classes 分类的类别
 * @param thresholds 分割阈值
 * @author liheng
 * @Reference http://github.com/hipersayanX/MultiOtsuThreshold
 */
void MultiOtsuThreshold(const cv::Mat &image, unsigned int classes, std::vector<int> &thresholds)
{
    CV_Assert( image.type() == CV_8UC1 );

    float maxSum = 0;
    std::vector<int>(classes-1,0).swap(thresholds);

    //cal histogram. 求解直方图
    std::vector<int> histogram(256, 0);
    {
        cv::Size size(image.size());
        if( image.isContinuous() )
        {
            size.width *= size.height;
            size.height = 1;
        }
        for(int i=0; i<size.height; ++i )
        {
            const uchar* sdata = image.ptr(i);
            for( int j = 0; j < size.width; ++j )
                histogram[sdata[j]] += 1;
        }

        // Since we use sum tables add one more to avoid unexistent colors.
        //for (int i = 0; i < histogram.size(); i++)
        //    histogram[i]++;
    }

    //buildTables
    std::vector<float> H(histogram.size() * histogram.size(), 0.f);
    {
        // Create cumulative sum tables.
        std::vector<int> P(histogram.size() + 1);
        std::vector<int> S(histogram.size() + 1);
        P[0] = 0;
        S[0] = 0;

        int sumP = 0;
        int sumS = 0;

        for (int i = 0; i < histogram.size(); i++) {
            sumP += int(histogram[i]);
            sumS += int(i * histogram[i]);
            P[i + 1] = sumP;
            S[i + 1] = sumS;
        }

        // Calculate the between-class variance for the interval u-v
        //std::vector<float> H(histogram.size() * histogram.size(), 0.f);

        for (int u = 0; u < histogram.size(); u++)
        {
            float *hLine = H.data() + u * histogram.size();

            for (int v = u + 1; v < histogram.size(); v++)
                hLine[v] = std::pow(S[v]-S[u], 2)*1.0f/(P[v] - P[u]+FLT_EPSILON);
        }
    }

    std::vector<int> index(classes + 1);
    index[0] = 0;
    index[index.size() - 1] = histogram.size() - 1;


    std::function<void(float *maxSum,
                       std::vector<int> *lhthres,
                       const std::vector<float> &H,
                       int u,int vmax,int level,
                       int levels,std::vector<int> *index)> lhOTSU_for_loop =
            [&](float *maxSum, std::vector<int> *lhthres,const std::vector<float> &H,
                int u,
                int vmax,
                int level,
                int levels,
                std::vector<int> *index)
            {
                int classes = index->size() - 1;

                for (int i = u; i < vmax; i++)
                {
                    (*index)[level] = i;

                    if (level + 1 >= classes)
                    {
                        // Reached the end of the for loop.

                        // Calculate the quadratic sum of al intervals.
                        float sum = 0.;
                        for (int c = 0; c < classes; c++)
                        {
                            int u = index->at(c);
                            int v = index->at(c + 1);
                            sum += H[v + u * levels];
                        }

                        if (*maxSum < sum)
                        {
                            // Return calculated threshold.
                            *lhthres = std::vector<int>(index->begin()+1,index->begin()+lhthres->size()+1);
                            *maxSum = sum;
                        }
                    }
                    else
                    {
                        // Start a new for loop level, one position after current one.
                        lhOTSU_for_loop(maxSum,
                                        lhthres,
                                        H,
                                        i + 1,
                                        vmax + 1,
                                        level + 1,
                                        levels,
                                        index);
                    }
                }
            };

    lhOTSU_for_loop(&maxSum,
                    &thresholds,
                    H,
                    1,
                    histogram.size() - classes + 1,
                    1,
                    histogram.size(), &index);

}

int main(int argc, char *argv[])
{
    cv::Mat image = cv::imread("./1.bmp",cv::IMREAD_GRAYSCALE);
    cv::imshow("src",image);

    //灰度直方图
    cv::Mat hist_img;
    int scale = 2;
    ShowHist(image,hist_img);


    //MultiLevel OTSU
    unsigned int classes = 4;
    std::vector<cv::Vec3b> colors(classes);
    colors[0] = cv::Vec3b(0,0,0);
    colors[1] = cv::Vec3b(255,0,0);
    colors[2] = cv::Vec3b(0,255,0);
    colors[3] = cv::Vec3b(0,0,255);


    std::vector<int> thresholds;
    MultiOtsuThreshold(image,classes,thresholds);
    //在直方图上绘制阈值位置
    for( const auto th:thresholds)
        cv::line(hist_img,cv::Point(th*scale,0),cv::Point(th*scale,hist_img.rows-1),cv::Scalar(0,0,255),2);

    for(int i=0;i<thresholds.size();++i)
        std::cout<<thresholds[i] <<" ";
    std::cout<<std::endl;

    cv::Mat thresholded = SegImage(image, thresholds, colors);
    cv::imshow("4otsu-dst",thresholded);
    //cv::imwrite("./res.bmp",thresholded);

    //cv::Mat otsudst;
    //auto th = ThresholdOTSU(image);
    //cv::threshold(image,otsudst,th,255,cv::THRESH_BINARY);
    //cv::imshow("2otsu-dst",otsudst);

    cv::imshow("hist",hist_img);
    cv::waitKey(0);


    return 0;
}


cv::Mat SegImage(const cv::Mat &src,
                 const std::vector<int> &thresholds,
                 const std::vector<cv::Vec3b> &colors)
{
    cv::Mat dst = cv::Mat::zeros(src.size(),CV_8UC3);

    std::vector<cv::Vec3b> colorTable(256);
    int j = 0;

    for (int i = 0; i < colorTable.size(); i++)
    {
        if (j < thresholds.size() && i >= thresholds[j])
            j++;

        colorTable[i] = colors[j];
    }

//    for (int y = 0; y < src.rows; y++)
//    {
//        const uchar *srcLine = src.ptr(y);
//        auto *dstLine = dst.ptr<cv::Vec3b>(y);
//
//        for (int x = 0; x < src.cols; x++)
//            dstLine[x] = colorTable[srcLine[x]];
//    }

    cv::cvtColor(src,dst,cv::COLOR_GRAY2BGR);
    cv::LUT(dst,colorTable,dst);
    return dst;
}

输入图像如下:

分割结果如下:

延伸思考

从OTSU算法的思想、实现过程来看，其虽然是对图像进行分割，但是算法的核心输入为灰度直方图/概率直方图，算法过程也是对概率直方图进行处理。因此我们该算法不仅仅适用于图像分割领域，也可以适用于其他能够求解概率直方图的场合，求解最大类间方差，如点云分类等。

算法评价

• 应用:是求图像全局阈值的最佳方法，应用不言而喻，适用于大部分需要求图像全局阈值的场合
• 优点:计算简单快速，不受图像亮度和对比度的影响
• 缺点:对图像噪声敏感，只能针对单一目标分割，当目标和背景大小比例（面积）悬殊、类间方差函数可能呈现双峰或者多峰，这个时候效果不好
• 解释：当图像中的目标与背景的面积相差很大时，表现为直方图没有明显的双峰，或者两个峰的大小相差很大，分割效果不佳，或者目标与背景的灰度有较大的重叠时也不能准确的将目标与背景分开。导致这种现象出现的原因是该方法忽略了图像的空间信息，同时该方法将图像的灰度分布作为分割图像的依据，因而对噪声也相当敏感。所以，在实际应用中，总是将其与其他方法结合起来使用。

参考资料

1.原论文链接
2.otsu阈值分割算法原理_大津法—OTSU算法
3.最大类间方差法（大津法OTSU）
4.大津法(OTSU 最大类间方差法)公式推导

5.大津法（OTSU 最大类间方差法）详细数学推导（公式繁杂，欢迎讨论）

该文最后的推导中公式有处笔误,整体没有问题

6.A Fast Algorithm for Multilevel Thresholding
7.多类别的最大类间方差法（Otsu’s method）

---

下面的是我的公众号二维码图片，按需关注。