Halcon--二值化算子dual_threshold和var_threshold的理解

zsffuture

已于 2024-05-28 12:47:25 修改

阅读量424

点赞数

文章标签：计算机视觉人工智能

于 2024-05-28 12:38:14 首次发布

原文链接：https://www.cnblogs.com/xh6300/p/6384542.html

版权

Halcon中阈值二值化的算子众多，通常用得最多的有threshold、binary_threshold、dyn_threshold等。

threshold是最简单的阈值分割算子，理解最为简单；binary_threshold是自动阈值算子，它可以自动选出暗（dark）的区域，或者自动选出亮（light）的区域，理解起来也没有难度。

动态阈值算子dyn_threshold理解起来稍微复杂一点，使用dyn_threshold算子的步骤基本是这样的：

① 将原图进行滤波平滑处理。

② 用原图和平滑后的图逐个像素做比较，它可以根据参数分割出原图比平滑后的图灰度高（或者低）若干个灰度值的区域。

举例如下：

处理程序是这样的：

1 read_image (Image, 'C:/Users/happy xia/Desktop/dynPic.png')
2 mean_image (Image, ImageMean, 9, 9)
3 dyn_threshold (Image, ImageMean, RegionDynThresh, 10, 'dark')

程序分析：本例中，将图片模糊后，点阵字的黑色扩散了，随之就是字的黑色不如原图那么黑了，那么通过给定的限值“10”和“dark”，就可以将原图比模糊后的图暗10个灰阶以上的区域（即黑色文字部分）选出来了。

以上所说的三个算子并不是本文的重点，但却是理解下面的两个阈值分割算子的准备知识。

1、dual_threshold

先看程序和效果图再分析。

1 read_image (Image, 'C:/Users/happy xia/Desktop/2.png')
2 dual_threshold (Image, RegionCrossings, 174, 200, 180)

dual_threshold(Image : RegionCrossings : MinSize, MinGray, Threshold : )

该算子签名中：Threshold 表示用于分割的阈值数值，MinSize表示分割出来的区域的最小面积（即数像素的数目个数），MinGray表示分割出来的区域对应的原图中图像像素的最高灰度不能低于MinGray设定值。

注意图中蓝色矩形小色块的面积是175个像素，因此当MinSize = 174时，它可以被分割出来。

OK，我知道这么说比较拗口。下面我边改变参数边观察效果图，并做简要分析：

1 read_image (Image, 'C:/Users/happy xia/Desktop/2.png')
2 dual_threshold (Image, RegionCrossings, 176, 200, 180)

效果图如下：

由于最小面积设置为176，那么面积为175像素的矩形小色块就没有被分割出来。

再来改变MinGray参数：

1 read_image (Image, 'C:/Users/happy xia/Desktop/2.png')
2 dual_threshold (Image, RegionCrossings, 176, 216, 180)

此时观察到，最右边那个齿轮本来分割出来的区域没有了！

通过取色器观察可知，这块区域最亮的灰度大概比211高一点点。

我们把这个值略微调低再看看：

1 read_image (Image, 'C:/Users/happy xia/Desktop/2.png')
2 dual_threshold (Image, RegionCrossings, 176, 210, 180)

最右边那个齿轮右下角那一块又被分割出来了！

相信通过这样参数的反复调节，大家已经彻底明白了dual_threshold算子的意义和用法。

我们看这个算子的名称——dual是“双”的意思，也就是双阈值。如果我们让参数列表中的MinGray = Threshold，那就是单阈值了。

1 read_image (Image, 'C:/Users/happy xia/Desktop/2.png')
2 dual_threshold (Image, RegionCrossings, 176, 180, 180)

这个算子是很高效的。如果要完成上面这个程序这样的功能，用threshold算子的话，代码要这样写：

1 read_image (Image, 'C:/Users/happy xia/Desktop/2.png')
2 threshold (Image, Region, 180, 255)
3 connection (Region, ConnectedRegions)
4 select_shape (ConnectedRegions, SelectedRegions, 'area', 'and', 176, 9999999)

也就是说dual_threshold一条算子顶这三条算子。

dual_threshold算子的缺陷：它只能分割出灰度值高的亮区域，不能分割出灰度值低的暗区域。

下面介绍var_threshold算子。

2、var_threshold

先看var_threshold算子的签名：

var_threshold(Image : Region : MaskWidth, MaskHeight, StdDevScale, AbsThreshold, LightDark : )

MaskWidth、 MaskHeight是用于滤波平滑的掩膜单元；StdDevScale是标准差乘数因子（简称标准差因子）；AbsThreshold是设定的绝对阈值；LightDark有4个值可选，'light'、'dark'、'equal'、'not_equal'。

需要强调的是var_threshold算子和dyn_threshold算子极为类似。不同的是var_threshold集成度更高，并且加入了“标准差×标准差因子”这一变量。

举例：

1 read_image (Image, 'C:/1.png')
2 var_threshold (Image, Region, 4, 4, 0.2, 12, 'dark')

在该程序中，先用4×4的掩膜在图像上逐像素游走，用原图中的当前像素和对应掩膜中16个像素的灰度均值对比，找出暗（dark）的区域。当原图像素灰度比对应的掩膜灰度均值低（0.2,12）个灰阶时，该区域被分割出来。本程序中StdDevScale = 0.2, AbsThreshold = 12,问题的关键就是理解如何通过StdDevScale和AbsThreshold来确定用于分割的阈值。

var_threshold的帮助文档中是这么写的：

说明：

1、d(x,y)指的是遍历每个像素时，掩膜覆盖的那些像素块（本例中是4×4 = 16个像素）灰度的标准差；StdDevScale 是标准差因子。

2、当标准差因子StdDevScale ≥ 0 时，v(x,y) 取（StdDevScale ×标准差）和AbsThreshold 中较大的那个。

3、当标准差因子StdDevScale ＜ 0 时，v(x,y) 取（StdDevScale ×标准差）和AbsThreshold 中较小的那个。实测发现，这里的比较大小是带符号比较，由于标准差是非负数，当StdDevScale ＜ 0 时，（StdDevScale ×标准差）≤ 0恒成立。所以此时的取值就是（StdDevScale ×标准差）。

文档是这么说的：

If StdDevScale*dev(x,y) is below AbsThreshold for positive values of StdDevScale or above for negative values StdDevScale, AbsThreshold is taken instead.

大致意思是：

当StdDevScale为正时，如果StdDevScale*dev(x,y) 低于 AbsThreshold，则采用AbsThreshold。

当StdDevScale为负时，如果StdDevScale*dev(x,y) 高于 AbsThreshold，则采用AbsThreshold。

我找了一块黑白过渡处4×4的像素块，求得它的灰度标准差为51.16（或49.53）：

帮助文档中StdDevScale 的推荐值范围是-1~1，一般通过上面的例子可知，一般的明显的黑白过度处的标准差在50左右，乘以StdDevScale即-50 ~ 50 ,50的灰度差异，对于分割来说一般是够了的。

文档还说：推荐的值是0.2，如果参数StdDevScale太大，可能分割不出任何东西；如果参数StdDevScale太小（例如-2），可能会把整个图像区域全部输出，也就说达不到有效分割的目的。（……with 0.2 as a suggested value. If the parameter is too high or too low, an empty or full region may be returned.）

最后再看看是怎么分割像素的：

其中g(x,y)指的是原始图像当前像素的灰度值；m(x,y)指的是遍历像素时，掩膜覆盖的像素的平均灰度值（mean）。

以LightDark = ‘dark’为例，当满足m(x,y) - g(x,y) ≥ v(x,y)时（即原始图像对应像素灰度比掩膜像素灰度均值低v(x,y)个灰度值以上），相应的灰度值低的暗像素被分割出来。

最后看几个例子体会一下：（对比之前的例子var_threshold (Image, Region, 4, 4, 0.2, 12, 'dark')的效果）

① 将AbsThreshold 由12改成30，此时分割出的区域变小。

1 read_image (Image, 'C:/1.png')
2 var_threshold (Image, Region, 4, 4, 0.2, 30, 'dark')

② AbsThreshold 保持12不变，将StdDevScale由0.2改成0.7，此时分割出的区域变小。

③ 将参数改为var_threshold (Image, Region, 4, 4, -0.01, 12, 'dark')，此时分割出的区域大大增加，由前面的分析可知，此时参数AbsThreshold = 12无效，事实上，此时将AbsThreshold 改为1、50甚至200都对最终结果没有任何影响。

通过本人的分析，我认为StdDevScale取负值意义不大，因为它会分割出大量的不需要的区域，故一般推荐使用该算子时，StdDevScale取正值。

需要强调的是：在黑白过渡处，一般掩膜覆盖的像素的标准差较大，而在其他平缓的地方，标准差较小；因此最终采用的分割阈值随着掩膜在不断遍历像素的过程中，在(StdDevScale×标准差)和AbsThreshold 之间不断切换。

var_threshold和dyn_threshold的区别和联系：

dyn_threshold是将原图和滤波平滑后的图对比，var_threshold是将原图和对应像素掩膜覆盖的像素的平均灰度值对比。

在算子var_threshold中，如果参数StdDevScale = 0，那么就可以用动态阈值的方式非常近似地模拟。以下两种算法的效果极为类似：

1 read_image (Image, 'C:/1.png')
2 var_threshold (Image, Region, 4, 4, 0, 12, 'dark')

1 read_image (Image, 'C:/1.png')
2 mean_image (Image, ImageMean, 4, 4)
3 dyn_threshold (Image, ImageMean, RegionDynThresh, 12, 'dark')

两种方法的效果图：

那么当StdDevScale ＞ 0 时，var_threshold对比dyn_threshold还存在什么优点呢？我认为是在黑白过渡处能减少分割出不需要的区域的概率。（因为黑白过渡处标准差大，当然前提是StdDevScale 不能设置得太小）

使用c++和opencv 实现 var_threshold

enum ThresholdType
{
    THRESHOLD_LIGHT,		//明
    THRESHOLD_DARK,			//暗
    THRESHOLD_EQUAL,		//等于
    THRESHOLD_NOT_EQUAL		//不等于
};

//功能：通过局部均值和标准差分析对图像进行阈值处理
//参数：
//  src：输入图像
//  mask：掩膜
//  dst：输出图像
//  maskW：掩膜宽度，用于均值和偏差计算（maskW >= 1）
//  maskH：掩膜高度，用于均值和偏差计算（maskH >= 1）
//  StdDevScale：灰度值标准差的因数
//  AbsThreshold：与平均值的最小灰度值差异
//  type：
//      g（x，y）：是输入Image中位置（x，y）处的灰度值
//      m（x，y）：对应的平均灰度值
//      d（x，y）：围绕该像素的遮罩中的相应标准偏差
//      THRESHOLD_LIGHT（明）： g（x，y） ≥ m（x，y） + d（x，y）
//      THRESHOLD_DARK（暗）： g（x，y） ≤ m（x，y） - d（x，y）
//      THRESHOLD_EQUAL（等于）： m（x，y） - d（x，y） ≤ g（x，y） ≤ m（x，y） + d（x，y）
//      THRESHOLD_NOT_EQUAL（不等于）： m（x，y） - d（x，y） > g（x，y） || g（x，y） > m（x，y） + d（x，y）
//返回值：无
void var_threshold(Mat src, Mat mask, Mat &dst,
                   int maskW, int maskH, float StdDevScale,
                   float AbsThreshold, ThresholdType type)
{
    dst = Mat(src.size(), CV_8UC1, Scalar(0));
    int width = maskW;
    int height = maskH;
    if (maskW % 2 == 0)
        width++;
    if (maskH % 2 == 0)
        height++;
    int rows = src.rows;
    int cols = src.cols;
    int minW = width / 2;
    int minH = height / 2;
    for (int row = 0; row < rows; row++)
    {
        for (int col = 0; col < cols; col++)
        {
            if (mask.at<uchar>(row, col) > 0)
            {
                vector<float> grays;
                float sum = 0;
                int i, j;
                if (row - minH < 0)
                    i = 0;
                else
                    i = row - minH;
                for (; i <= row + minH && i < rows; i++)
                {
                    if (col - minW < 0)
                        j = 0;
                    else
                        j = col - minW;
                    for (; j <= col + minW && j < cols; j++)
                    {
                        if (mask.at<uchar>(i, j) > 0)
                        {
                            int gray = src.at<uchar>(i, j);
                            grays.push_back(gray);
                            sum += gray;
                        }
                    }
                }
                float average = sum / grays.size();
                float stdValue = StdDeviation(grays, average);
                float limit = 0;
                if (StdDevScale >= 0)
                {
                    limit = std::max(StdDevScale * stdValue, AbsThreshold);
                }
                else if (StdDevScale < 0)
                {
                    limit = std::min(StdDevScale * stdValue, AbsThreshold);
                }

                int g_src = src.at<uchar>(row, col);
                if (type == THRESHOLD_LIGHT)
                {
                    if (g_src >= average + limit)
                        dst.at<uchar>(row, col) = 255;
                }
                else if (type == THRESHOLD_DARK)
                {
                    if (g_src <= average - limit)
                        dst.at<uchar>(row, col) = 255;
                }
                else if (type == THRESHOLD_EQUAL)
                {
                    if (g_src >= average - limit && g_src <= average + limit)
                        dst.at<uchar>(row, col) = 255;
                }
                else if (type == THRESHOLD_NOT_EQUAL)
                {
                    if (g_src < average - limit || g_src > average + limit)
                        dst.at<uchar>(row, col) = 255;
                }
            }
        }
    }
}

//功能：求标准差
//参数：
//  numbers：求标准差的数组
//  average：该数组的平均值
//返回值：求得的标准差
float StdDeviation(vector<float> numbers, float average)
{
    int count = numbers.size();
    float sum = 0;
    for (int i = 0; i < count; i++)
        sum += (numbers[i] - average) * (numbers[i] - average);
    if (0 == count)
    {
        return 0;
    }
    return sqrt(sum / count);
}

使用c++和opencv 实现 dyn_threshold算子

void CImagePreprocessing::dynamic_threshold_referHalcon(cv::Mat &frame_gray, int ksize, int offset) //仿Halcon
{
    cv::Mat srcMean;
    cv::Mat binary1;
    cv::Mat binary2;
 
    //均值滤波
    blur(frame_gray, srcMean, cv::Size(9, 9));
 
    //动态阈值
    binary1 = cv::Mat::zeros(frame_gray.size(), CV_8UC1);
    _HalconDynThreshold(frame_gray, srcMean, binary1, offset, Equal);
}
 
void CImagePreprocessing::_HalconDynThreshold(cv::Mat &src, cv::Mat &srcMean, cv::Mat &result, int offset, int LightDark)
{
    //使用Opencv实现Halcon中的动态阈值
    //src是原图,灰度图
    //srcMean是平滑滤波之后的图
    //最好不要把Offset这个变量设置为0，因为这样会导致最后找到太多很小的regions，而这基本上都是噪声。
    //所以这个值最好是在5-40之间，值选择的越大，提取出来的regions就会越小。
    int r = src.rows; //高
    int c = src.cols; //宽
    int Value = 0;
    for (int i = 0; i < r; i++)
    {
        uchar *datasrc = src.ptr<uchar>(i); //指针访问图像像素
        uchar *datasrcMean = srcMean.ptr<uchar>(i);
        uchar *dataresult = result.ptr<uchar>(i);
 
        for (int j = 0; j < c; j++)
        {
            switch (LightDark)
            {
            case Light:
                Value = datasrc[j] - datasrcMean[j];
                if (Value >= offset)
                {
                    dataresult[j] = 255;
                }
                break;
 
            case Dark:
                Value = datasrcMean[j] - datasrc[j];
                if (Value >= offset)
                {
                    dataresult[j] = 255;
                }
                break;
 
            case Equal:
                Value = datasrc[j] - datasrcMean[j];
                if (Value >= -offset && Value <= offset)
                {
                    dataresult[j] = 255;
                }
                break;
 
            case Not_equal:
                Value = datasrc[j] - datasrcMean[j];
                if (Value < -offset || Value > offset)
                {
                    dataresult[j] = 255;
                }
                break;
 
            default:
                break;
            }
        }
    }
}

此文为转载，文章在这里