OpenCv中Threshold函数详解
参数简析：
对数组元素进行固定阈值操作
void cvThreshold( const CvArr* src, CvArr* dst, double threshold,
double max_value, int threshold_type );
src
原始数组 (单通道 , 8-bit of 32-bit 浮点数).
dst
输出数组，必须与 src 的类型一致，或者为 8-bit.
threshold
阈值
max_value
使用 CV_THRESH_BINARY 和 CV_THRESH_BINARY_INV 的最大值.
threshold_type
阈值类型
函数 cvThreshold 对单通道数组应用固定阈值操作。该函数的典型应用是对灰度图像进行阈值操作得到二值图像。(cvCmpS 也可以达到此目的) 或者是去掉噪声，例如过滤很小或很大象素值的图像点。本函数支持的对图像取阈值的方法由 threshold_type 确定:
threshold_type=CV_THRESH_BINARY:
dst(x,y) = max_value, if src(x,y)>threshold
0, otherwise
threshold_type=CV_THRESH_BINARY_INV:
dst(x,y) = 0, if src(x,y)>threshold
max_value, otherwise
threshold_type=CV_THRESH_TRUNC:
dst(x,y) = threshold, if src(x,y)>threshold
src(x,y), otherwise
threshold_type=CV_THRESH_TOZERO:
dst(x,y) = src(x,y), if (x,y)>threshold
0, otherwise
threshold_type=CV_THRESH_TOZERO_INV:
dst(x,y) = 0, if src(x,y)>threshold
src(x,y), otherwise
详解：
定义：图像的二值化，就是将图像上的像素点的灰度值设置为0或255，也就是将整个图像呈现出明显的只有黑和白的视觉效果。
灰度值0：黑，灰度值255：白
一幅图像包括目标物体、背景还有噪声，要想从多值的数字图像中直接提取出目标物体，常用的方法就是设定一个阈值T，用T将图像的数据分成两部分：大于T的像素群和小于T的像素群。这是研究灰度变换的最特殊的方法，称为图像的二值化（Binarization）。
threshold
cv2.threshold(img, threshold, maxval,type)
其中：
- threshold是设定的阈值
- maxval是当灰度值大于（或小于）阈值时将该灰度值赋成的值
- type规定的是当前二值化的方式
破折线为将被阈值化的值，中间线为阈值
cv2.THRESH_BINARY 大于阈值的部分被置为255，小于部分被置为0
cv2.THRESH_BINARY_INV 大于阈值部分被置为0，小于部分被置为255
cv2.THRESH_TRUNC 大于阈值部分被置为threshold，小于部分保持原样
cv2.THRESH_TOZERO 小于阈值部分被置为0，大于部分保持不变
cv2.THRESH_TOZERO_INV 大于阈值部分被置为0，小于部分保持不变
下面着重说明一下THRESH_OTSU与THRESH_TRIANGLE。
THRESH_OTSU与THRESH_TRIANGLE适用场合：
参考如下连接：
https://zhuanlan.zhihu.com/p/81680297
OTSU算法对直方图有两个峰，中间有明显波谷的直方图对应图像二值化效果比较好，而对于只有一个单峰的直方图对应的图像分割效果没有双峰的好。
所以OTSU更适用于有明显区分的前景色和后景色的图像。
THRESH_TRIANGLE：
并不是所有的照片都是由明显的前景色和后景色的对比的，比如这个。
那么，有没有一种更好的办法来处理这种单峰图像呢？答案是肯定的。THRESH_TRIANGLE应运而生。
THRESH_OTSU：
大津法（OTSU）是一种确定图像二值化分割阈值的算法，由日本学者大津于1979年提出。从大津法的原理上来讲，该方法又称作最大类间方差法，因为按照大津法求得的阈值进行图像二值化分割后，前景与背景图像的类间方差最大。
它被认为是图像分割中阈值选取的最佳算法，计算简单，不受图像亮度和对比度的影响，因此在数字图像处理上得到了广泛的应用。它是按图像的灰度特性，将图像分成背景和前景两部分。因方差是灰度分布均匀性的一种度量,背景和前景之间的类间方差越大,说明构成图像的两部分的差别越大,当部分前景错分为背景或部分背景错分为前景都会导致两部分差别变小。因此,使类间方差最大的分割意味着错分概率最小。
应用：是求图像全局阈值的最佳方法，应用不言而喻，适用于大部分需要求图像全局阈值的场合。
优点：计算简单快速，不受图像亮度和对比度的影响。
求类间方差：
OTSU算法的假设是存在阈值TH将图像所有像素分为两类C1(小于TH)和C2(大于TH)，则这两类像素各自的均值就为m1、m2，图像全局均值为mG。同时像素被分为C1和C2类的概率分别为p1、p2。因此就有：
OTSU代码
#include
#include
#include
#include
int Otsu(cv::Mat& src, cv::Mat& dst, int thresh){
const int Grayscale = 256;
int graynum[Grayscale] = { 0 };
int r = src.rows;
int c = src.cols;
for (int i = 0; i < r; ++i){
const uchar* ptr = src.ptr(i);
for (int j = 0; j < c; ++j){ //直方图统计
graynum[ptr[j]]++;
}
}
double P[Grayscale] = { 0 };
double PK[Grayscale] = { 0 };
double MK[Grayscale] = { 0 };
double srcpixnum = r*c, sumtmpPK = 0, sumtmpMK = 0;
for (int i = 0; i < Grayscale; ++i){
P[i] = graynum[i] / srcpixnum; //每个灰度级出现的概率
PK[i] = sumtmpPK + P[i]; //概率累计和
sumtmpPK = PK[i];
MK[i] = sumtmpMK + i*P[i]; //灰度级的累加均值
sumtmpMK = MK[i];
}
//计算类间方差
double Var=0;
for (int k = 0; k < Grayscale; ++k){
if ((MK[Grayscale-1] * PK[k] - MK[k])*(MK[Grayscale-1] * PK[k] - MK[k]) / (PK[k] * (1 - PK[k])) > Var){
Var = (MK[Grayscale-1] * PK[k] - MK[k])*(MK[Grayscale-1] * PK[k] - MK[k]) / (PK[k] * (1 - PK[k]));
thresh = k;
}
}
//阈值处理
src.copyTo(dst);
for (int i = 0; i < r; ++i){
uchar* ptr = dst.ptr(i);
for (int j = 0; j < c; ++j){
if (ptr[j]> thresh)
ptr[j] = 255;
else
ptr[j] = 0;
}
}
return thresh;
}
int main(){
cv::Mat src = cv::imread("I:\\Learning-and-Practice\\2019Change\\Image process algorithm\\Img\\Fig1039(a)(polymersomes).tif");
if (src.empty()){
return -1;
}
if (src.channels() > 1)
cv::cvtColor(src, src, CV_RGB2GRAY);
cv::Mat dst,dst2;
int thresh=0;
double t2 = (double)cv::getTickCount();
thresh=Otsu(src , dst, thresh); //Otsu
std::cout << "Mythresh=" << thresh << std::endl;
t2 = (double)cv::getTickCount() - t2;
double time2 = (t2 *1000.) / ((double)cv::getTickFrequency());
std::cout << "my_process=" << time2 << " ms. " << std::endl << std::endl;
double Otsu = 0;
Otsu=cv::threshold(src, dst2, Otsu, 255, CV_THRESH_OTSU + CV_THRESH_BINARY);
std::cout << "OpenCVthresh=" << Otsu << std::endl;
cv::namedWindow("src", CV_WINDOW_NORMAL);
cv::imshow("src", src);
cv::namedWindow("dst", CV_WINDOW_NORMAL);
cv::imshow("dst", dst);
cv::namedWindow("dst2", CV_WINDOW_NORMAL);
cv::imshow("dst2", dst2);
//cv::imwrite("I:\\Learning-and-Practice\\2019Change\\Image process algorithm\\Image Filtering\\MeanFilter\\TXT.jpg",dst);
cv::waitKey(0);
}
THRESH_TRIANGLE：
三角法求阈值最早见于Zack的论文《Automatic measurement of sister chromatid exchange frequency》主要是用于染色体的研究，该方法是使用直方图数据，基于纯几何方法来寻找最佳阈值，它的成立条件是假设直方图最大波峰在靠近最亮的一侧，然后通过三角形求得最大直线距离，根据最大直线距离对应的直方图灰度等级即为分割阈值，图示如下：
对上图的详细解释：
在直方图上从最高峰处bmx到最暗对应直方图bmin(p=0)%构造一条直线，从bmin处开始计算每个对应的直方图b到直线的垂直距离，知道bmax为止，其中最大距离对应的直方图位置即为图像二值化对应的阈值T。
扩展情况：
有时候最大波峰对应位置不在直方图最亮一侧，而在暗的一侧，这样就需要翻转直方图，翻转之后求得值，用255减去即得到为阈值T。扩展情况的直方图表示如下：
THRESH_TRIANGLE算法步骤
- 图像转灰度
- 计算图像灰度直方图
- 寻找直方图中两侧边界
- 寻找直方图最大值
- 检测是否最大波峰在亮的一侧，否则翻转
- 计算阈值得到阈值T，如果翻转则255-T
- 代码实现：
package com.gloomyfish.filter.study;
import java.awt.image.BufferedImage;
public class TriangleBinaryFilter extends AbstractBufferedImageOp{
public TriangleBinaryFilter() {
System.out.println("triangle binary filter");
}
@Override
public BufferedImage filter(BufferedImage src, BufferedImage dest) {
int width = src.getWidth();
int height = src.getHeight();
if ( dest == null )
dest = createCompatibleDestImage( src, null );
// 图像灰度化
int[] inPixels = new int[width*height];
int[] outPixels = new int[width*height];
getRGB( src, 0, 0, width, height, inPixels );
int index = 0;
for(int row=0; row> 24) & 0xff;
tr = (inPixels[index] >> 16) & 0xff;
tg = (inPixels[index] >> 8) & 0xff;
tb = inPixels[index] & 0xff;
int gray= (int)(0.299 *tr + 0.587*tg + 0.114*tb);
inPixels[index] = (ta << 24) | (gray << 16) | (gray << 8) | gray;
}
}
// 获取直方图
int[] histogram = new int[256];
for(int row=0; row> 16) & 0xff;
histogram[tr]++;
}
}
int left_bound = 0, right_bound = 0, max_ind = 0, max = 0;
int temp;
boolean isflipped = false;
int i=0, j=0;
int N = 256;
// 找到最左边零的位置
for( i = 0; i < N; i++ )
{
if( histogram[i] > 0 )
{
left_bound = i;
break;
}
}
// 位置再移动一个步长，即为最左侧零位置
if( left_bound > 0 )
left_bound--;
// 找到最右边零点位置
for( i = N-1; i > 0; i-- )
{
if( histogram[i] > 0 )
{
right_bound = i;
break;
}
}
// 位置再移动一个步长，即为最右侧零位置
if( right_bound < N-1 )
right_bound++;
// 在直方图上寻找最亮的点Hmax
for( i = 0; i < N; i++ )
{
if( histogram[i] > max)
{
max = histogram[i];
max_ind = i;
}
}
// 如果最大值落在靠左侧这样就无法满足三角法求阈值，所以要检测是否最大值是否靠近左侧
// 如果靠近左侧则通过翻转到右侧位置。
if( max_ind-left_bound < right_bound-max_ind)
{
isflipped = true;
i = 0;
j = N-1;
while( i < j )
{
// 左右交换
temp = histogram[i]; histogram[i] = histogram[j]; histogram[j] = temp;
i++; j--;
}
left_bound = N-1-right_bound;
max_ind = N-1-max_ind;
}
// 计算求得阈值
double thresh = left_bound;
double a, b, dist = 0, tempdist;
a = max; b = left_bound-max_ind;
for( i = left_bound+1; i <= max_ind; i++ )
{
// 计算距离 - 不需要真正计算
tempdist = a*i + b*histogram[i];
if( tempdist > dist)
{
dist = tempdist;
thresh = i;
}
}
thresh--;
// 对已经得到的阈值T,如果前面已经翻转了，则阈值要用255-T
if( isflipped )
thresh = N-1-thresh;
// 二值化
System.out.println("final threshold value : " + thresh);
for(int row=0; row> 8) & 0xff;
if(gray > thresh)
{
gray = 255;
outPixels[index] = (0xff << 24) | (gray << 16) | (gray << 8) | gray;
}
else
{
gray = 0;
outPixels[index] = (0xff << 24) | (gray << 16) | (gray << 8) | gray;
}
}
}
// 返回二值图像
setRGB(dest, 0, 0, width, height, outPixels );
return dest;
}
}
自适应阈值
在图像阈值化操作中，更关注的是从二值化图像中，分离目标区域和背景区域，但是仅仅通过设定固定阈值很难达到理想的分割效果。而自适应阈值，则是根据像素的邻域块的像素值分布来确定该像素位置上的二值化阈值。这样做的好处：
每个像素位置处的二值化阈值不是固定不变的，而是由其周围邻域像素的分布来决定的。
亮度较高的图像区域的二值化阈值通常会较高，而亮度低的图像区域的二值化阈值则会相适应的变小。
不同亮度、对比度、纹理的局部图像区域将会拥有相对应的局部二值化阈值。
1. void adaptiveThreshold(InputArray src, OutputArray dst,
2. double maxValue, int adaptiveMethod,
3. int thresholdType, int bolckSize, double C)
4. 参数说明
参数1：InputArray类型的src，输入图像，填单通道，单8位浮点类型Mat即可。
参数2：函数运算后的结果存放在这。即为输出图像（与输入图像同样的尺寸和类型）。
参数3：预设满足条件的最大值。
参数4：指定自适应阈值算法。可选择ADAPTIVE_THRESH_MEAN_C 或 ADAPTIVE_THRESH_GAUSSIAN_C两种。（具体见下面的解释）。
参数5：指定阈值类型。可选择THRESH_BINARY或者THRESH_BINARY_INV两种。（即二进制阈值或反二进制阈值）。
参数6：表示邻域块大小，用来计算区域阈值，一般选择为3、5、7......等。
参数7：参数C表示与算法有关的参数，它是一个从均值或加权均值提取的常数，可以是负数。（具体见下面的解释）。对参数4与参数7内容的解释：
自适应阈值化计算大概过程是为每一个象素点单独计算的阈值，即每个像素点的阈值都是不同的，就是将该像素点周围B*B区域内的像素加权平均，然后减去一个常数C，从而得到该点的阈值。B由参数6指定，常数C由参数7指定。
ADAPTIVE_THRESH_MEAN_C，为局部邻域块的平均值，该算法是先求出块中的均值，再减去常数C。
ADAPTIVE_THRESH_GAUSSIAN_C，为局部邻域块的高斯加权和。该算法是在区域中(x, y)周围的像素根据高斯函数按照他们离中心点的距离进行加权计算，再减去常数C。
举个例子：如果使用平均值方法，平均值mean为190，差值delta（即常数C）为30。那么灰度小于160的像素为0，大于等于160的像素为255。如下图：
如果是反向二值化，如下图：
delta（常数C）选择负值也是可以的。
/*
自适应阈值：adaptiveThreshold()函数
*/
#include
#include
#include
#include
using namespace std;
using namespace cv;
int main()
{
//------------【1】读取源图像并检查图像是否读取成功------------
Mat srcImage = imread("D:\\OutPutResult\\ImageTest\\build.jpg");
if (!srcImage.data)
{
cout << "读取图片错误，请重新输入正确路径！\n";
system("pause");
return -1;
}
imshow("【源图像】", srcImage);
//------------【2】灰度转换------------
Mat srcGray;
cvtColor(srcImage, srcGray, CV_RGB2GRAY);
imshow("【灰度图】", srcGray);
//------------【3】初始化相关变量---------------
Mat dstImage; //初始化自适应阈值参数
const int maxVal = 255;
int blockSize = 3; //取值3、5、7....等
int constValue = 10;
int adaptiveMethod = 0;
int thresholdType = 1;
/*
自适应阈值算法
0:ADAPTIVE_THRESH_MEAN_C
1:ADAPTIVE_THRESH_GAUSSIAN_C
--------------------------------------
阈值类型
0:THRESH_BINARY
1:THRESH_BINARY_INV
*/
//---------------【4】图像自适应阈值操作-------------------------
adaptiveThreshold(srcGray, dstImage, maxVal, adaptiveMethod, thresholdType, blockSize, constValue);
imshow("【自适应阈值】", dstImage);
waitKey(0);
return 0;
}
滤波处理
另外，做不做滤波处理等对图像分割影响也比较大。
- adaptiveThreshold分割
Mat img=imread("D:/ImageTest/sudoku.png",CV_LOAD_IMAGE_COLOR); Mat dst1; Mat dst2; Mat dst3; cv::cvtColor(img,img,COLOR_RGB2GRAY);//进行，灰度处理 medianBlur(img,img,5);//中值滤波 threshold(img,dst1, 127, 255, THRESH_BINARY);//阈值分割 adaptiveThreshold(img,dst2,255,ADAPTIVE_THRESH_MEAN_C,THRESH_BINARY,11,2);//自动阈值分割,邻域均值 adaptiveThreshold(img,dst3,255,ADAPTIVE_THRESH_GAUSSIAN_C,THRESH_BINARY,11,2);//自动阈值分割，高斯邻域 //ADAPTIVE_THRESH_MEAN_C : threshold value is the mean of neighbourhood area //ADAPTIVE_THRESH_GAUSSIAN_C : threshold value is the weighted sum of neighbourhood values where weights are a gaussian window. imshow("dst1", dst1); imshow("dst2", dst2); imshow("dst3", dst3); imshow("img", img); waitKey(0);2. 加入滤波处理的最大类间方差分割
Mat img=imread("D:/ImageTest/pic2.png",CV_LOAD_IMAGE_COLOR);
Mat dst1;
Mat dst2;
Mat dst3;
cv::cvtColor(img,img,COLOR_RGB2GRAY);//进行，灰度处理
// medianBlur(img,img,5);
threshold(img,dst1, 127, 255, THRESH_BINARY);
threshold(img,dst2,0, 255, THRESH_OTSU);//最大类间方差法分割 Otsu algorithm to choose the optimal threshold value
Mat img2=img.clone();
GaussianBlur(img2,img2,Size(5,5),0);//高斯滤波去除小噪点
threshold(img2,dst3, 0, 255, THRESH_OTSU);
imshow("BINARY dst1", dst1);
imshow("OTSU dst2", dst2);
imshow("GaussianBlur OTSU dst3", dst3);
imshow("original img", img);
waitKey(0);