【opencv】教程代码 —Histograms_Matching（2）计算直方图、直方图比较、直方图均衡、模板匹配...

计算直方图
直方图比较
图像进行直方图均衡化处理
模板匹配

1. calcHist_Demo.cpp 计算直方图

这段代码的功能是加载图像，分离图像的三个颜色通道，然后分别计算这三个通道的直方图，绘制出来并显示结果。直方图是图像中像素值分布的图形表示，可以用于图像分析或图像处理中。

cpp 复制代码

// 加载OpenCV库，并用cv和std命名空间
#include "opencv2/highgui.hpp"
#include "opencv2/imgcodecs.hpp"
#include "opencv2/imgproc.hpp"
#include <iostream>
using namespace std;
using namespace cv;


// 主函数
int main(int argc, char** argv)
{
    // 从命令行参数中加载图像，如果不指定，则默认加载lena.jpg
    CommandLineParser parser( argc, argv, "{@input | lena.jpg | input image}" );
    Mat src = imread( samples::findFile( parser.get<String>( "@input" ) ), IMREAD_COLOR );
    // 如果图像为空，则返回退出失败
    if( src.empty() )
    {
        return EXIT_FAILURE;
    }


    // 分离图像的三个通道：蓝色、绿色和红色
    vector<Mat> bgr_planes;
    split( src, bgr_planes );


    // 确定直方图中的柱子数量（bin的数量），这里设置为256
    int histSize = 256;


    // 设置B、G、R通道的范围，由于直方图的上界是独占的，所以设置的范围是{0，256}
    float range[] = { 0, 256 };
    const float* histRange[] = { range };


    // 设置直方图参数，设置为均匀的，并且不累计
    bool uniform = true, accumulate = false;


    // 计算蓝色、绿色和红色通道的直方图
    Mat b_hist, g_hist, r_hist;
    calcHist( &bgr_planes[0], 1, 0, Mat(), b_hist, 1, &histSize, histRange, uniform, accumulate );
    calcHist( &bgr_planes[1], 1, 0, Mat(), g_hist, 1, &histSize, histRange, uniform, accumulate );
    calcHist( &bgr_planes[2], 1, 0, Mat(), r_hist, 1, &histSize, histRange, uniform, accumulate );


    // 创建一个用于绘制直方图的图像
    int hist_w = 512, hist_h = 400;
    int bin_w = cvRound( (double) hist_w/histSize );
    Mat histImage( hist_h, hist_w, CV_8UC3, Scalar( 0,0,0) );


    // 将直方图的结果归一化到(0, histImage.rows)
    normalize(b_hist, b_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
    normalize(g_hist, g_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
    normalize(r_hist, r_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );


    // 为每个通道绘制直方图
    for( int i = 1; i < histSize; i++ )
    {
        line( histImage, Point( bin_w*(i-1), hist_h - cvRound(b_hist.at<float>(i-1)) ),
              Point( bin_w*(i), hist_h - cvRound(b_hist.at<float>(i)) ),
              Scalar( 255, 0, 0), 2, 8, 0  );
        line( histImage, Point( bin_w*(i-1), hist_h - cvRound(g_hist.at<float>(i-1)) ),
              Point( bin_w*(i), hist_h - cvRound(g_hist.at<float>(i)) ),
              Scalar( 0, 255, 0), 2, 8, 0  );
        line( histImage, Point( bin_w*(i-1), hist_h - cvRound(r_hist.at<float>(i-1)) ),
              Point( bin_w*(i), hist_h - cvRound(r_hist.at<float>(i)) ),
              Scalar( 0, 0, 255), 2, 8, 0  );
    }


    // 显示源图像和计算的直方图
    imshow("Source image", src );
    imshow("calcHist Demo", histImage );
    waitKey();


    return EXIT_SUCCESS;
}

calcHist( &bgr_planes[0], 1, 0, Mat(), b_hist, 1, &histSize, histRange, uniform, accumulate );

normalize(b_hist, b_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );

2. compareHist_Demo.cpp 比较直方图

cpp 复制代码

/**
 * @file compareHist_Demo.cpp
 * @brief Sample code to use the function compareHist
 * @author OpenCV team
 */


// 引入必要的头文件
#include "opencv2/imgcodecs.hpp" //图像编解码相关功能
#include "opencv2/highgui.hpp"   //高级图形用户界面
#include "opencv2/imgproc.hpp"   //图像处理相关功能
#include <iostream>              //标准输入输出流


// 使用标准和opencv命名空间
using namespace std;
using namespace cv;


// 定义命令行参数
const char* keys =
    "{ help  h| | Print help message. }" // 输出帮助信息
    "{ @input1 |Histogram_Comparison_Source_0.jpg | Path to input image 1. }" // 输入图片1的路径
    "{ @input2 |Histogram_Comparison_Source_1.jpg | Path to input image 2. }" // 输入图片2的路径
    "{ @input3 |Histogram_Comparison_Source_2.jpg | Path to input image 3. }"; // 输入图片3的路径


/**
 * @function main
 */
int main( int argc, char** argv )
{
    //! [Load three images with different environment settings]
    // 解析命令行参数
    CommandLineParser parser( argc, argv, keys );
    // 添加样本数据搜索子目录
    samples::addSamplesDataSearchSubDirectory( "doc/tutorials/imgproc/histograms/histogram_comparison/images" );
    // 读取三个输入图片
    Mat src_base = imread(samples::findFile( parser.get<String>( "@input1" ) ) );
    Mat src_test1 = imread(samples::findFile( parser.get<String>( "@input2" ) ) );
    Mat src_test2 = imread(samples::findFile( parser.get<String>( "@input3" ) ) );
    // 检查图片是否正确加载
    if( src_base.empty() || src_test1.empty() || src_test2.empty() )
    {
        cout << "Could not open or find the images!\n" << endl;
        // 打印帮助信息并退出
        parser.printMessage();
        return -1;
    }
    //! [Load three images with different environment settings]


    //! [Convert to HSV]
    // 将三个图片转换为HSV颜色空间
    Mat hsv_base, hsv_test1, hsv_test2;
    cvtColor( src_base, hsv_base, COLOR_BGR2HSV );
    cvtColor( src_test1, hsv_test1, COLOR_BGR2HSV );
    cvtColor( src_test2, hsv_test2, COLOR_BGR2HSV );
    //! [Convert to HSV]


    //! [Convert to HSV half]
    // 取hsv_base图像的下半部分用于后续的直方图比较
    Mat hsv_half_down = hsv_base( Range( hsv_base.rows/2, hsv_base.rows ), Range( 0, hsv_base.cols ) );
    //! [Convert to HSV half]


    //! [Using 50 bins for hue and 60 for saturation]
    // 定义hue和saturation两个维度的直方图bin数
    int h_bins = 50, s_bins = 60;
    int histSize[] = { h_bins, s_bins };


    // hue的取值范围从0到179, saturation的取值范围从0到255
    float h_ranges[] = { 0, 180 };
    float s_ranges[] = { 0, 256 };


    const float* ranges[] = { h_ranges, s_ranges };


    // 选择使用的通道
    int channels[] = { 0, 1 };
    //! [Using 50 bins for hue and 60 for saturation]


    //! [Calculate the histograms for the HSV images]
    // 计算本基准图像、下半部分图像和两个测试图像的直方图
    // 定义存储直方图数据的Mat对象
    Mat hist_base, hist_half_down, hist_test1, hist_test2;
    
    // 计算基准图像的直方图，并存储在hist_base中
    calcHist( &hsv_base, 1, channels, Mat(), hist_base, 2, histSize, ranges, true, false );
    // 将基准图像的直方图归一化到[0, 1]
    normalize( hist_base, hist_base, 0, 1, NORM_MINMAX, -1, Mat() );
    
    // 计算半幅图像的直方图，并存储在hist_half_down中
    calcHist( &hsv_half_down, 1, channels, Mat(), hist_half_down, 2, histSize, ranges, true, false );
    // 将半幅图像的直方图归一化到[0, 1]
    normalize( hist_half_down, hist_half_down, 0, 1, NORM_MINMAX, -1, Mat() );
    
    // 计算测试图像1的直方图，并存储在hist_test1中
    calcHist( &hsv_test1, 1, channels, Mat(), hist_test1, 2, histSize, ranges, true, false );
    // 将测试图像1的直方图归一化到[0, 1]
    normalize( hist_test1, hist_test1, 0, 1, NORM_MINMAX, -1, Mat() );
    
    // 计算测试图像2的直方图，并存储在hist_test2中
    calcHist( &hsv_test2, 1, channels, Mat(), hist_test2, 2, histSize, ranges, true, false );
    // 将测试图像2的直方图归一化到[0, 1]
    normalize( hist_test2, hist_test2, 0, 1, NORM_MINMAX, -1, Mat() );
    //! [Calculate the histograms for the HSV images]
    
    //! [Apply the histogram comparison methods]
    // 使用四种不同的方法比较直方图
    for( int compare_method = 0; compare_method < 4; compare_method++ )
    {
        // 与自己比较，理想值对照
        double base_base = compareHist( hist_base, hist_base, compare_method );
        // 与半幅图像比较
        double base_half = compareHist( hist_base, hist_half_down, compare_method );
        // 与测试图像1比较
        double base_test1 = compareHist( hist_base, hist_test1, compare_method );
        // 与测试图像2比较
        double base_test2 = compareHist( hist_base, hist_test2, compare_method );
    
        // 输出比较结果
        cout << "Method " << compare_method << " Perfect, Base-Half, Base-Test(1), Base-Test(2) : "
             <<  base_base << " / " << base_half << " / " << base_test1 << " / " << base_test2 << endl;
    }
    //! [Apply the histogram comparison methods]
    
    // 输出完成的提示
    cout << "Done \n";
    // 正常结束程序
    return 0;
}

终端输出：

properties 复制代码

Method 0 Perfect, Base-Half, Base-Test(1), Base-Test(2) : 1 / 0.880438 / 0.20457 / 0.0664547
Method 1 Perfect, Base-Half, Base-Test(1), Base-Test(2) : 0 / 4.6834 / 2697.98 / 4763.8
Method 2 Perfect, Base-Half, Base-Test(1), Base-Test(2) : 18.8947 / 13.022 / 5.44085 / 2.58173
Method 3 Perfect, Base-Half, Base-Test(1), Base-Test(2) : 0 / 0.237887 / 0.679826 / 0.874173
Done

该代码运行后，输出了四种不同直方图比较方法的结果。这四种方法包括：相关性(Correlation)、卡方(Chi-Square)、相互信息(Intersection)和巴氏距离(Bhattacharyya)。

Method 0: 相关性（Correlation）比较方法的结果。相关性比较法是检查两个图像的相似性。分数为1表示完全匹配，接近0的分数表示不匹配。输出结果1表示基本图像与自身完全匹配，0.880438表示基础图像与一半图像较为匹配，0.20457和0.0664547分别表示基础图像与两张测试图像的匹配程度较低。
Method 1: 卡方（Chi-Square）比较方法的结果。卡方方法比较适合用于检查两个图像的差异程度，而不是他们的相似度。输出结果0表示基础图像与自身完全匹配，4.6834表示基础图像与一半的图像差异较小，2697.98和4763.8分别表示基础图像与两张测试图像的差异较大。
Method 2: 相互信息（Intersection）比较方法的结果。它计算两张图片的交集，数值越大则越相似。输出结果18.8947表示基础图像与自身完全匹配，13.022表示基础图像与一半图像比较相近，5.44085和2.58173分别表示基础图像与两张测试图像相似度较低。
Method 3: 巴氏距离（Bhattacharyya）比较方法的结果。它也是检查两个图像的差异度。输出结果0表示基础图像与自身完全匹配，0.237887表示基础图像与一半图像的差异较小，而0.679826和0.874173则表示基础图像与两张测试图像的差异较大。

3. EqualizeHist_Demo.cpp 图像进行直方图均衡化处理

cpp 复制代码

/**
 * @function EqualizeHist_Demo.cpp
 * @brief Demo code for equalizeHist function    // 程序功能介绍，为OpenCV中的equalizeHist函数的示例代码
 * @author OpenCV team                             // 作者为OpenCV团队
 */


#include "opencv2/imgcodecs.hpp"    // 包含进行图像编解码操作的头文件
#include "opencv2/highgui.hpp"      // 包含用于创建图像窗口和处理图像交互功能的头文件
#include "opencv2/imgproc.hpp"      // 包含进行图像处理的函数头文件
#include <iostream>                 // 包含用于输入输出流的头文件


using namespace cv;                 // 使用命名空间cv，可以直接使用OpenCV库中的函数和类
using namespace std;                // 使用命名空间std，可以直接使用标准库中的函数和类


/**
 * @function main                               // 主函数
 */
int main( int argc, char** argv )
{
    //! [Load image]                          // 加载图片
    CommandLineParser parser( argc, argv, "{@input | lena.jpg | input image}" );
    Mat src = imread( samples::findFile( parser.get<String>( "@input" ) ), IMREAD_COLOR );   
    
    // 如果图片为空，则输出错误信息，并给出使用方法，然后返回-1
    if( src.empty() )
    {
        cout << "Could not open or find the image！\n" << endl;
        cout << "Usage:" << argv[0] << " <Input image>" << endl;
        return -1;
    }
    //! [Load image]


    //! [Convert to grayscale]               // 将图片转换为灰度图
    cvtColor( src, src, COLOR_BGR2GRAY );
    //! [Convert to grayscale]


    //! [Apply Histogram Equalization]     // 对图片进行直方图均衡化
    Mat dst;
    equalizeHist( src, dst );
    //! [Apply Histogram Equalization]


    //! [Display results]                  // 显示结果
    imshow( "Source image", src );
    imshow( "Equalized Image", dst );
    //! [Display results]


    //! [Wait until user exits the program] //等待直到用户退出程序
    waitKey();
    //! [Wait until user exits the program]


    return 0;


}

这段代码的主要功能是读取一张图片，将其转换为灰度图，然后对其进行直方图均衡化处理，最后显示原图和处理后的图像。直方图均衡化是一种能改善图像对比度的方法，尤其对于背景和前景灰度级相近的图像处理很有效。

4. MatchTemplate_Demo.cpp

这段代码是使用OpenCV库进行模板匹配的示例程序。代码的主要功能是从源图像中寻找与给定模板最匹配的部分 。通过滑动条控件可以选择不同的模板匹配方法 ，并通过结果显示最佳匹配位置。支持命令行参数输入，加载相应的源图像、模板图像及掩码图像（如果提供），并显示匹配过程的结果。**匹配方法包括平方差匹配(SQDIFF)和相关系数匹配(CCORR)**等多种方式。

cpp 复制代码

/**
 * @file MatchTemplate_Demo.cpp
 * @brief Sample code to use the function MatchTemplate
 * @author OpenCV team
 */
// MatchTemplate_Demo.cpp 文件
// 使用 MatchTemplate 函数的示例代码
// 作者：OpenCV团队


#include "opencv2/imgcodecs.hpp" // 包含OpenCV的图像编解码头文件
#include "opencv2/highgui.hpp" // 包含OpenCV的GUI头文件
#include "opencv2/imgproc.hpp" // 包含OpenCV的图像处理头文件
#include <iostream> // 包含标准输入输出流头文件


using namespace std; // 使用标准命名空间
using namespace cv; // 使用OpenCV命名空间


//! [declare]
/// Global Variables
// 全局变量声明
bool use_mask; // 是否使用掩码的标志变量
Mat img; Mat templ; Mat mask; Mat result; // 定义图像矩阵，模板，掩码以及匹配结果矩阵
const char* image_window = "Source Image"; // 原始图像窗口名
const char* result_window = "Result window"; // 结果窗口名


int match_method; // 匹配方法
int max_Trackbar = 5; // 滑动条的最大值
//! [declare]


/// Function Headers
// 函数声明
void MatchingMethod( int, void* ); // 匹配方法的函数声明


const char* keys =
"{ help  h| | Print help message. }"
"{ @input1 | Template_Matching_Original_Image.jpg | image_name }"
"{ @input2 | Template_Matching_Template_Image.jpg | template_name }"
"{ @input3 |  | mask_name }";


/**
 * @function main
 */
int main( int argc, char** argv )
{
  CommandLineParser parser( argc, argv, keys ); // 解析命令行参数
  samples::addSamplesDataSearchSubDirectory( "doc/tutorials/imgproc/histograms/template_matching/images" );


  //! [load_image]
  /// Load image and template
  // 加载图像和模板
  img = imread( samples::findFile( parser.get<String>("@input1") ) ); // 读取原始图像
  templ = imread( samples::findFile( parser.get<String>("@input2") ), IMREAD_COLOR ); // 读取模板图像


  if(argc > 3) {
    use_mask = true; // 如果提供了掩码，则设置使用掩码标志为true
    mask = imread(samples::findFile( parser.get<String>("@input3") ), IMREAD_COLOR ); // 读取掩码图像
  }


  if(img.empty() || templ.empty() || (use_mask && mask.empty()))
  {
    cout << "Can't read one of the images" << endl; // 如果任一图像为空则输出错误消息
    return EXIT_FAILURE; // 返回退出代码
  }
  //! [load_image]


  //! [create_windows]
  /// Create windows
  // 创建窗口
  namedWindow( image_window, WINDOW_AUTOSIZE ); // 创建原始图像窗口
  namedWindow( result_window, WINDOW_AUTOSIZE ); // 创建结果窗口
  //! [create_windows]


  //! [create_trackbar]
  /// Create Trackbar
  // 创建滑块
  const char* trackbar_label = "Method: \n 0: SQDIFF \n 1: SQDIFF NORMED \n 2: TM CCORR \n 3: TM CCORR NORMED \n 4: TM COEFF \n 5: TM COEFF NORMED";
  createTrackbar( trackbar_label, image_window, &match_method, max_Trackbar, MatchingMethod ); // 在原始图像窗口创建滑块用以选择匹配方法
  //! [create_trackbar]


  MatchingMethod( 0, 0 ); // 使用初始方法进行匹配


  //! [wait_key]
  waitKey(0); // 等待按键退出
  return EXIT_SUCCESS; // 返回成功退出代码
  //! [wait_key]
}


/**
 * @function MatchingMethod
 * @brief Trackbar callback
 */
void MatchingMethod( int, void* )
{
  //! [copy_source]
  /// Source image to display
  // 显示的源图像
  Mat img_display; // 定义一个用于显示的图像矩阵
  img.copyTo( img_display ); // 原始图像拷贝到显示图像矩阵中
  //! [copy_source]


  //! [create_result_matrix]
  /// Create the result matrix
  // 创建结果矩阵
  int result_cols = img.cols - templ.cols + 1; // 计算结果矩阵的列数
  int result_rows = img.rows - templ.rows + 1; // 计算结果矩阵的行数


  result.create( result_rows, result_cols, CV_32FC1 ); // 创建结果矩阵
  //! [create_result_matrix]


  //! [match_template]
  /// Do the Matching and Normalize
  // 进行匹配和标准化
  bool method_accepts_mask = (TM_SQDIFF == match_method || match_method == TM_CCORR_NORMED); // 判断匹配方法是否接受掩码
  if (use_mask && method_accepts_mask)
    { matchTemplate( img, templ, result, match_method, mask); } // 如果使用掩码且方法接受掩码，则进行匹配
  else
    { matchTemplate( img, templ, result, match_method); } // 否则不使用掩码进行匹配
  //! [match_template]


  //! [normalize]
  normalize( result, result, 0, 1, NORM_MINMAX, -1, Mat() ); // 将结果矩阵标准化到0-1之间
  //! [normalize]


  //! [best_match]
  /// Localizing the best match with minMaxLoc
  // 使用minMaxLoc定位最佳匹配
  double minVal; double maxVal; Point minLoc; Point maxLoc; // 定义最小值，最大值以及它们的位置
  Point matchLoc; // 定义匹配位置


  minMaxLoc( result, &minVal, &maxVal, &minLoc, &maxLoc, Mat() ); // 寻找最小值和最大值以及它们的位置
  //! [best_match]


  //! [match_loc]
  /// For SQDIFF and SQDIFF_NORMED, the best matches are lower values. For all the other methods, the higher the better
  // 对于SQDIFF和SQDIFF_NORMED方法，较小的值表示更好的匹配。对于其它方法，较大值表示更好的匹配
  if( match_method  == TM_SQDIFF || match_method == TM_SQDIFF_NORMED )
    { matchLoc = minLoc; } // 如果是SQDIFF或者SQDIFF_NORMED方法，选择最小值位置作为匹配位置
  else
    { matchLoc = maxLoc; } // 否则选择最大值位置作为匹配位置
  //! [match_loc]


  //! [imshow]
  /// Show me what you got
  // 展示结果
  rectangle( img_display, matchLoc, Point( matchLoc.x + templ.cols , matchLoc.y + templ.rows ), Scalar::all(0), 2, 8, 0 ); // 在显示图像上画出匹配位置的矩形框
  rectangle( result, matchLoc, Point( matchLoc.x + templ.cols , matchLoc.y + templ.rows ), Scalar::all(0), 2, 8, 0 ); // 在结果矩阵上画出匹配位置的矩形框


  imshow( image_window, img_display ); // 显示原始图像和匹配框
  imshow( result_window, result ); // 显示结果矩阵
  //! [imshow]


  return; // 返回
}