opencv学习笔记10-opencv中的图像二值化

最新推荐文章于 2024-08-31 19:13:52 发布

The_xz

最新推荐文章于 2024-08-31 19:13:52 发布

阅读量631

点赞数 6

文章标签： opencv 学习笔记

本文链接：https://blog.csdn.net/The_xz/article/details/141501440

版权

一、图像二值化概括：

图像二值化是数字图像处理中的一种技术，它将图像的像素值简化为两个类别：前景和背景。具体来说，二值化处理涉及以下关键点：

（1）目的：

二值化的主要目的是将图像中的前景对象与背景分离，以便于后续的图像分析和处理，如目标识别、特征提取、图像分割等。

（2）阈值选择：

通过选择一个合适的阈值（threshold），将图像的灰度值分为两部分。灰度值高于阈值的像素被归类为前景（通常赋值为255，表示白色），而低于阈值的像素被视为背景（通常赋值为0，表示黑色）。

（3）应用场景：

二值化常用于图像预处理，特别是在需要强调图像中的特定特征或在图像中区分不同区域时。例如，在文字识别、医学成像分析、工业自动化中的零件计数和缺陷检测等领域。

（4）方法：

二值化可以采用全局阈值或局部自适应阈值方法。全局阈值方法为整个图像应用单一阈值，而局部自适应阈值方法会根据图像的不同区域调整阈值，以适应不同光照和对比度条件。

（5）挑战：

在实际应用中，选择合适的阈值可能具有挑战性，因为图像的光照、对比度和噪声等因素可能影响阈值的效果。因此，可能需要使用复杂的算法来自动确定最佳阈值。

（6）结果：

二值化的结果是一个二值图像，其中像素只有两种可能的值，这简化了图像的复杂性，同时保留了重要的视觉信息。

（7）后续处理：

二值化图像可以进一步进行连通域分析、形态学操作等，以实现更高级的图像分析任务。

二、使用的opencv函数：

a.函数一：

（1）函数原型：

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

（2）函数作用：

threshold 函数对多通道数组的每个元素应用固定级别的阈值处理。通常用于从灰度图像中获取二值图像，或者用于去除噪声，即过滤掉值过小或过大的像素点。

（3）参数：

InputArray src：输入数组，可以是多通道的，数据类型为 8 位无符号整数或 32 位浮点数。
OutputArray dst：输出数组，与输入数组 src 的大小、类型和通道数相同。
double thresh：阈值，用于阈值处理的值。
double maxval：最大值，与 THRESH_BINARY 和 THRESH_BINARY_INV 阈值类型一起使用时，表示阈值之上的最大值。
int type：阈值类型，决定了阈值处理的具体方法（见 ThresholdTypes 枚举）。

（4）特殊值：

THRESH_OTSU 或 THRESH_TRIANGLE，这些特殊值可以与上述值结合使用。在这些情况下，函数使用 Otsu's 或 Triangle 算法确定最优阈值，并使用该值代替指定的 thresh。

（5）注意：

Otsu's 和 Triangle 方法目前仅实现了针对 8 位单通道图像。

（6）返回值：

如果使用了 Otsu's 或 Triangle 方法，则返回计算出的阈值。

（7）应用场景：

threshold 函数适用于图像的二值化处理，以及在需要基于阈值过滤像素的场景中。

b.函数二：

（1）函数原型：

 CV_EXPORTS_W void adaptiveThreshold( InputArray src, OutputArray dst, 
double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C );

（2）函数作用：

adaptiveThreshold 函数根据每个像素邻域的灰度值分布计算阈值，并将计算出的二值图像存储在输出数组中。

（3）参数：

InputArray src：输入的 8 位单通道灰度图像。
OutputArray dst：输出的二值图像，与输入图像 src 具有相同的大小和类型。
double maxValue：当条件满足时分配给像素的非零值。
int adaptiveMethod：使用的自适应阈值算法，见 AdaptiveThresholdTypes 枚举。
int thresholdType：阈值类型，必须是 THRESH_BINARY 或 THRESH_BINARY_INV，见 ThresholdTypes 枚举。
int blockSize：用于计算每个像素阈值的像素邻域大小，例如 3、5、7 等。
double C：从邻域的平均值或加权平均值中减去的常数。通常为正数，但也可以是零或负数。

（4）自适应阈值计算：

阈值 T(x, y) 是针对每个像素单独计算的，根据所选的自适应方法（adaptiveMethod）。

（5）阈值公式：

对于 THRESH_BINARY 类型，如果 src(x, y) 大于 T(x, y)，则 dst(x, y) 设置为 maxValue，否则设置为 0。
对于 THRESH_BINARY_INV 类型，如果 src(x, y) 大于 T(x, y)，则 dst(x, y) 设置为 0，否则设置为 maxValue。

（6）边界处理：使用 BORDER_REPLICATE | BORDER_ISOLATED 对边界进行处理。

（7）应用场景：

自适应阈值方法适用于光照不均或对比度变化较大的图像，可以更好地处理图像中的局部变化。

三、二值化的几种方法：

（1）全局二值化方法：

全局二值化方法使用单一阈值对所有像素进行分割。这种方法适用于直方图具有双峰性的图像，即前景和背景在直方图中形成两个明显的峰值。

实现过程：

计算图像的灰度直方图。
确定直方图的双峰，找到两个峰值之间的谷底作为分割阈值。

代码示例：

#include <opencv2/core/utils/logger.hpp>
#include <opencv2/opencv.hpp>
#include <opencv2/videoio.hpp>
#include <opencv2/objdetect.hpp>
#include <opencv2/highgui/highgui_c.h>
#include <iostream>
using namespace cv;
using namespace std;

int  main()
{
	utils::logging::setLogLevel(utils::logging::LOG_LEVEL_SILENT);
	//读取图片并转化为灰度图
	Mat srcMat = imread("C:\\Users\\86173\\Desktop\\TI\\Q版阿离.png", 0);
	//判断图片是否提取成功
	if (srcMat.empty())
	{
		cout << "fail to read !" << endl;
		return 0;
	}
	//定义Globalbinarization存放图像
	Mat Globalbinarization;

	//全局二值化方法，当前点值大于阈值时，取l,否则设置为0
	threshold(srcMat, Globalbinarization, 200, 255, CV_THRESH_BINARY);

	//显示结果图像
	imshow("Global binarization", Globalbinarization);
	
	waitKey(0);
	destroyAllWindows();//关闭所有窗口
	return 0;
}

运行结果：

（2）大津法（Otsu's method）：

大津法是一种自动确定阈值的方法，它通过最大化类间方差来确定最佳阈值。

实现过程：

计算图像的灰度直方图。
遍历所有可能的阈值，对于每个阈值，计算前景和背景的均值和方差。
选择使类间方差最大化的阈值作为分割阈值。

代码示例：

#include <opencv2/core/utils/logger.hpp>
#include <opencv2/opencv.hpp>
#include <opencv2/videoio.hpp>
#include <opencv2/objdetect.hpp>
#include <opencv2/highgui/highgui_c.h>
#include <iostream>
using namespace cv;
using namespace std;

int  main()
{
	utils::logging::setLogLevel(utils::logging::LOG_LEVEL_SILENT);
	//读取图片并转化为灰度图
	Mat srcMat = imread("C:\\Users\\86173\\Desktop\\TI\\Q版阿离.png", 0);
	//判断图片是否提取成功
	if (srcMat.empty())
	{
		cout << "fail to read !" << endl;
		return 0;
	}
	//定义Otsumethod存放图像
	Mat Otsumethod;

	//大津法，通过大津法求出最佳阈值，大于阈值置255，小于置0
    threshold(srcMat, Otsumethod, 100, 255, CV_THRESH_OTSU);

	//显示结果图像
	imshow("Otsumethod", Otsumethod);
	
	waitKey(0);
	destroyAllWindows();//关闭所有窗口
	return 0;
}

运行结果：

（3）区域自适应二值化：

区域自适应二值化考虑局部区域的灰度特性来计算自适应阈值。

实现过程：

选择一个局部区域的尺寸，例如3x3、5x5或7x7。
对于图像中的每个像素，考虑其周围的局部区域。
根据局部区域内的灰度分布计算自适应阈值，可以使用均值、高斯加权和等方法。

代码示例：

#include <opencv2/core/utils/logger.hpp>
#include <opencv2/opencv.hpp>
#include <opencv2/videoio.hpp>
#include <opencv2/objdetect.hpp>
#include <opencv2/highgui/highgui_c.h>
#include <iostream>
using namespace cv;
using namespace std;

int  main()
{
	utils::logging::setLogLevel(utils::logging::LOG_LEVEL_SILENT);
	//读取图片并转化为灰度图
	Mat srcMat = imread("C:\\Users\\86173\\Desktop\\TI\\Q版阿离.png", 0);
	//判断图片是否提取成功
	if (srcMat.empty())
	{
		cout << "fail to read !" << endl;
		return 0;
	}
	//定义Rdb存放图像
	Mat Rdb;

	//区域自适应二值化，适合对那些光照不均的图片进行二值化，因为它的二值化阈值是自适应的
    adaptiveThreshold(srcMat, Rdb, 255, ADAPTIVE_THRESH_GAUSSIAN_C, THRESH_BINARY, 15, 10);

	//显示结果图像
	imshow("Rdb", Rdb);
	
	waitKey(0);
	destroyAllWindows();//关闭所有窗口
	return 0;
}

运行结果：

（4）迭代法实现

迭代法是一种动态确定阈值的方法，通过不断更新阈值直到满足停止条件。

实现过程：

从一个初始阈值开始，通常是图像灰度值范围的中间值。
根据阈值分割图像，计算前景和背景的均值。
更新阈值为前景和背景均值的平均值。
重复步骤2-3，直到阈值变化小于某个预设的精度或达到最大迭代次数。

示例代码：

#include <opencv2/core/utils/logger.hpp>
#include <opencv2/opencv.hpp>
#include <opencv2/videoio.hpp>
#include <opencv2/objdetect.hpp>
#include <opencv2/highgui/highgui_c.h>
#include <iostream>
using namespace cv;
using namespace std;
int main() {
     utils::logging::setLogLevel(utils::logging::LOG_LEVEL_SILENT);
    // 加载图像
    Mat image = imread("C:\\Users\\86173\\Desktop\\TI\\Q版阿离.png", IMREAD_GRAYSCALE);
    if (image.empty()) {
        cerr << "Could not open or find the image" << endl;
        return -1;
    }

    // 初始化参数
    double threshold1 = 128.0; // 初始阈值
    double thresholdDelta = 1.0; // 阈值更新步长
    int maxIterations = 100; // 最大迭代次数

    // 迭代寻找最佳阈值
    for (int i = 0; i < maxIterations; i++) {
        // 创建二值化图像
        Mat binaryImage;
        threshold(image, binaryImage, threshold1, 255, THRESH_BINARY);

        // 计算二值图像的像素和
        int pixelSum = cv::sum(binaryImage)[0];

        // 计算图像总像素数
        int totalPixels = image.rows * image.cols;

        // 计算新的阈值，这里使用简单的算术平均作为示例
        double newThreshold = (threshold1 + (pixelSum / (double)totalPixels)) / 2;

        // 如果阈值变化小于阈值更新步长，则停止迭代
        if (abs(newThreshold - threshold1) < thresholdDelta) {
            break;
        }

        // 更新阈值
        threshold1 = newThreshold;
    }

    // 使用找到的阈值进行二值化
    Mat finalBinaryImage;
    threshold(image, finalBinaryImage, threshold1, 255, THRESH_BINARY);

    // 显示结果
    imshow("Original Image", image);
    imshow("Binary Image", finalBinaryImage);
    waitKey(0); // 等待用户按键后关闭窗口

    return 0;
}

运行结果：

（5）Chow and Kaneko二值化算法：

基于连通区域的局部自适应二值化方法，它首先将图像划分为多个子区域，然后对每个子区域中的连通区域进行分析，以确定最佳阈值，特别适合于前景和背景交错的图像。

实现过程：

图像预处理：首先将图像转换为灰度图像，如果需要的话，可以进行平滑处理以减少噪声的影响。
图像分割：将图像分割成多个小的非重叠子区域（或称为块）。
连通区域分析：在每个子区域内，寻找连通区域。连通区域是一组相邻的像素点，它们具有相同的灰度值。
确定目标区域：选择最大的连通区域作为目标区域，这个区域通常被认为是前景或背景。
计算灰度均值：计算目标区域的灰度均值。这个均值将作为该子区域的局部阈值。
二值化子区域：使用计算出的局部阈值对每个子区域进行二值化。如果子区域内的像素值高于局部阈值，则设置为白色（255）；否则，设置为黑色（0）。
合并结果：将所有子区域的二值化结果合并，形成最终的二值化图像。
后处理（可选）：根据需要，可以对二值化图像进行后处理，例如通过形态学操作来改善前景和背景的分离。

示例代码：

#include <opencv2/core/utils/logger.hpp>
#include <opencv2/opencv.hpp>
#include <opencv2/videoio.hpp>
#include <opencv2/objdetect.hpp>
#include <opencv2/highgui/highgui_c.h>
#include <iostream>
using namespace cv;
using namespace std;
// 函数用于执行Chow and Kaneko二值化算法
Mat chowKanekoThreshold(const Mat& src) {
    Mat gray, binary;
    cvtColor(src, gray, COLOR_BGR2GRAY); // 转换为灰度图像
    binary = Mat::zeros(gray.size(), gray.type()); // 创建二值图像

    int N = 1; // 连通区域的最小像素数
    int K = 2;  // 连通区域的扩展次数
    imshow("gray", gray);
    imshow("binary", binary); //二值图像全黑
    vector<vector<Point>> contours;
    vector<Vec4i> hierarchy;

    // 寻找连通区域
    findContours(gray.clone(), contours, hierarchy, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);

    for (size_t i = 0; i < contours.size(); i++) {
        if (contours[i].size() >= N) {
            // 计算连通区域的边界框
            int x = 0, y = 0, width = 0, height = 0;
            Rect boundingRect = cv::boundingRect(Mat(contours[i]));
            x = boundingRect.x;
            y = boundingRect.y;
            width = boundingRect.width;
            height = boundingRect.height;

            // 扩展边界框
            for (int k = 0; k < K; k++) {
                x = max(0, x - 1);
                y = max(0, y - 1);
                width = min(gray.cols, width + 2);
                height = min(gray.rows, height + 2);
            }

            // 计算扩展区域的均值
            Mat region = gray(Rect(x, y, width, height));
            double meanVal = mean(region)[0];

            // 应用阈值
            Mat regionBinary;
            threshold(region, regionBinary, meanVal, 255, THRESH_BINARY);

            // 将二值化结果合并到最终的二值图像中
            regionBinary.copyTo(binary(Rect(x, y, width, height)));
        }
    }

    return binary;
}

int main() {
    utils::logging::setLogLevel(utils::logging::LOG_LEVEL_SILENT);
    Mat image = imread("C:\\Users\\86173\\Desktop\\TI\\Q版阿离.png");
    if (image.empty()) {
        cerr << "Could not open or find the image" << endl;
        return -1;
    }

    Mat binaryImage = chowKanekoThreshold(image);

    imshow("Original Image", image);
    //imshow("gray", gray);
    imshow("Binary Image", binaryImage);
    waitKey(0);

    return 0;
}

运行结果：

（6）其他方法：

示例代码：

#include <opencv2/core/utils/logger.hpp>
#include <opencv2/opencv.hpp>
#include <opencv2/videoio.hpp>
#include <opencv2/objdetect.hpp>
#include <opencv2/highgui/highgui_c.h>
#include <iostream>
using namespace cv;
using namespace std;
int main() {
    utils::logging::setLogLevel(utils::logging::LOG_LEVEL_SILENT);
    Mat image, grayImage, binaryImage;
    // 读取图像
    image = imread("C:\\Users\\86173\\Desktop\\TI\\Q版阿离.png");
    if (image.empty()) {
        cerr << "Could not open or find the image" << endl;
        return -1;
    }

    // 转换为灰度图像（如果需要的话）
   cvtColor(image, grayImage, COLOR_BGR2GRAY);

    // 定义子区域的大小
    int block_size = 160; // 你可以根据需要调整这个值

    // 初始化输出的二值图像
    binaryImage = Mat::zeros(grayImage.size(), CV_8U);

    // 遍历图像的每个子区域
    for (int i = 0; i < grayImage.rows; i += block_size) {
        for (int j = 0; j < grayImage.cols; j += block_size) {
            // 定义子区域的边界
            int row_end = min(i + block_size, grayImage.rows);
            int col_end = min(j + block_size, grayImage.cols);

            // 提取子区域
            Mat block = grayImage(Rect(j, i, col_end - j, row_end - i));

            // 计算子区域的均值
            double mean = cv::mean(block)[0];

            // 将均值作为子区域的阈值
            Mat binaryBlock;
            threshold(block, binaryBlock, mean, 255, THRESH_BINARY);

            // 将二值化子区域复制到输出图像中
            binaryBlock.copyTo(binaryImage(Rect(j, i, col_end - j, row_end - i)));
        }
    }

    // 显示结果
    imshow("Original Image", image);
    imshow("Binary Image", binaryImage);
    waitKey(0); // 等待用户按键后关闭窗口

    return 0;
}

运行结果：