直方图比较

目录

• 目标
• 原理
• 代码
• 原理解释
• 结果

上一个教程： 直方图计算
下一个教程： 反向投影

原作者	Ana Huamán
兼容性	OpenCV >= 3.0

目标

在本教程中，你将学习如何：

• 使用函数 cv::compareHist 获取一个数值参数，表示两个直方图的匹配程度。
• 使用不同的度量来比较直方图

理论

• 要比较两个直方图（ \(H_{1}\) 和 \(H_{2}\) ），首先我们必须选择一个度量（ \(d(H_{1}, H_{2})\) ）来表示两个直方图的匹配程度。
• OpenCV 实现了函数 cv::compareHist 来执行比较。它还提供了 6 种不同的度量来计算匹配度。
  1. 相关性（ cv::HISTCMP_CORREL ）

     \[d(H_1,H_2) = \frac{\sum_I (H_1(I) - \bar{H_1}) (H_2(I) - \bar{H_2})}{\sqrt{\sum_I(H_1(I) - \bar{H_1})^2 \sum_I(H_2(I) - \bar{H_2})^2}}\]

     其中

     \[\bar{H_k} = \frac{1}{N} \sum _J H_k(J)\]

     其中 \(N\) 是直方图 bin 的总数。
  2. 卡方（ cv::HISTCMP_CHISQR ）

     \[d(H_1,H_2) = \sum _I \frac{\left(H_1(I)-H_2(I)\right)^2}{H_1(I)}\]

  3. 交集（ cv::HISTCMP_INTERSECT ）

     \[d(H_1,H_2) = \sum _I \min (H_1(I), H_2(I))\]

  4. 巴塔查里亚距离（ cv::HISTCMP_BHATTACHARYYA ）

     \[d(H_1,H_2) = \sqrt{1 - \frac{1}{\sqrt{\bar{H_1} \bar{H_2} N^2}} \sum_I \sqrt{H_1(I) \cdot H_2(I)}}\]

  5. 替代卡方（ cv::HISTCMP_CHISQR_ALT ）

     \[d(H_1,H_2) = 2 * \sum _I \frac{\left(H_1(I)-H_2(I)\right)^2}{H_1(I)+H_2(I)}\]

  6. Kullback-Leibler 散度（ cv::HISTCMP_KL_DIV ）

     \[d(H_1,H_2) = \sum _I H_1(I) \log \left(\frac{H_1(I)}{H_2(I)}\right)\]

代码

• 这个程序做什么？
  • 加载一个 基础图像 和 2 个 测试图像 以与基础图像进行比较。
  • 生成一个图像，它是 基础图像 的下半部分。
  • 将图像转换为 HSV 格式。
  • 计算所有图像的 H-S 直方图并进行归一化，以便进行比较。
  • 比较 基础图像 的直方图与 2 个测试直方图、下半部分基础图像的直方图以及与相同的基础图像直方图。
  • 显示获得的数值匹配参数。

C++

• 可下载代码：点击此处
• 代码概览

   
  #include "opencv2/imgcodecs.hpp"
  #include "opencv2/highgui.hpp"
  #include "opencv2/imgproc.hpp"
  #include <iostream>
   
  using namespace std;
  using namespace cv;
   
  const char* keys =
      "{ help h| | Print help message. }"
      "{ @input1 |Histogram_Comparison_Source_0.jpg | 输入图像 1 的路径。}"
      "{ @input2 |Histogram_Comparison_Source_1.jpg | 输入图像 2 的路径。}"
      "{ @input3 |Histogram_Comparison_Source_2.jpg | 输入图像 3 的路径。}";
   
  int main( int argc, char** argv )
  {
      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 << "无法打开或找到图像!\n" << endl;
  parser.printMessage();
          return -1;
      }
   
      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 );
   
      Mat hsv_half_down = hsv_base( Range( hsv_base.rows/2, hsv_base.rows ), Range( 0, hsv_base.cols ) );
   
      int h_bins = 50, s_bins = 60;
      int histSize[] = { h_bins, s_bins };
   
      // 色相从 0 到 179 变化，饱和度从 0 到 255 变化
      float h_ranges[] = { 0, 180 };
      float s_ranges[] = { 0, 256 };
   
      const float* ranges[] = { h_ranges, s_ranges };
   
      // 使用第 0 个和第 1 个通道
      int channels[] = { 0, 1 };
   
      Mat hist_base, hist_half_down, hist_test1, hist_test2;
   
      calcHist( &hsv_base, 1, channels, Mat(), hist_base, 2, histSize, ranges, true, false );
      normalize( hist_base, hist_base, 1, 0, NORM_L1, -1, Mat() );
   
      calcHist( &hsv_half_down, 1, channels, Mat(), hist_half_down, 2, histSize, ranges, true, false );
      normalize( hist_half_down, hist_half_down, 1, 0, NORM_L1, -1, Mat() );
   
      calcHist( &hsv_test1, 1, channels, Mat(), hist_test1, 2, histSize, ranges, true, false );
      normalize( hist_test1, hist_test1, 1, 0, NORM_L1, -1, Mat() );
   
      calcHist( &hsv_test2, 1, channels, Mat(), hist_test2, 2, histSize, ranges, true, false );
      normalize( hist_test2, hist_test2, 1, 0, NORM_L1, -1, Mat() );
   
      for( int compare_method = 0; compare_method < 6; compare_method++ )
      {
          double base_base = compareHist( hist_base, hist_base, compare_method );
          double base_half = compareHist( hist_base, hist_half_down, compare_method );
          double base_test1 = compareHist( hist_base, hist_test1, compare_method );
          double base_test2 = compareHist( hist_base, hist_test2, compare_method );
   
  cout << "方法 " << compare_method << " 完美, 基础-一半, 基础-测试(1), 基础-测试(2) : "
  << base_base << " / " << base_half << " / " << base_test1 << " / " << base_test2 << endl;
      }
   
  cout << "完成 \n";
      return 0;
  }

Java

• 可下载代码：点击此处
• 代码概览

  import java.util.Arrays;
  import java.util.List;
   
  import org.opencv.core.Core;
  import org.opencv.core.Mat;
  import org.opencv.core.MatOfFloat;
  import org.opencv.core.MatOfInt;
  import org.opencv.core.Range;
  import org.opencv.imgcodecs.Imgcodecs;
  import org.opencv.imgproc.Imgproc;
   
  class CompareHist {
      public void run(String[] args) {
          if (args.length != 3) {
  System.err.println("您必须提供 3 个参数，对应 3 个图像的路径。");
  System.exit(0);
          }
  Mat srcBase = Imgcodecs.imread(args[0]);
  Mat srcTest1 = Imgcodecs.imread(args[1]);
  Mat srcTest2 = Imgcodecs.imread(args[2]);
          if (srcBase.empty() || srcTest1.empty() || srcTest2.empty()) {
  System.err.println("无法读取图像");
  System.exit(0);
          }
   
  Mat hsvBase = new Mat(), hsvTest1 = new Mat(), hsvTest2 = new Mat();
  Imgproc.cvtColor( srcBase, hsvBase, Imgproc.COLOR_BGR2HSV );
  Imgproc.cvtColor( srcTest1, hsvTest1, Imgproc.COLOR_BGR2HSV );
  Imgproc.cvtColor( srcTest2, hsvTest2, Imgproc.COLOR_BGR2HSV );
   
  Mat hsvHalfDown = hsvBase.submat( new Range( hsvBase.rows()/2, hsvBase.rows() - 1 ), new Range( 0, hsvBase.cols() - 1 ) );
   
          int hBins = 50, sBins = 60;
          int[] histSize = { hBins, sBins };
   
          // 色相从 0 到 179 变化，饱和度从 0 到 255 变化
          float[] ranges = { 0, 180, 0, 256 };
   
          // 使用第 0 个和第 1 个通道
          int[] channels = { 0, 1 };
   
  Mat histBase = new Mat(), histHalfDown = new Mat(), histTest1 = new Mat(), histTest2 = new Mat();
   
  List<Mat> hsvBaseList = Arrays.asList(hsvBase);
  Imgproc.calcHist(hsvBaseList, new MatOfInt(channels), new Mat(), histBase, new MatOfInt(histSize), new MatOfFloat(ranges), false);
  Core.normalize(histBase, histBase, 1, 0, Core.NORM_L1);
   
  List<Mat> hsvHalfDownList = Arrays.asList(hsvHalfDown);
  Imgproc.calcHist(hsvHalfDownList, new MatOfInt(channels), new Mat(), histHalfDown, new MatOfInt(histSize), new MatOfFloat(ranges), false);
  Core.normalize(histHalfDown, histHalfDown, 1, 0, Core.NORM_L1);
   
  List<Mat> hsvTest1List = Arrays.asList(hsvTest1);
  Imgproc.calcHist(hsvTest1List, new MatOfInt(channels), new Mat(), histTest1, new MatOfInt(histSize), new MatOfFloat(ranges), false);
  Core.normalize(histTest1, histTest1, 1, 0, Core.NORM_L1);
   
  List<Mat> hsvTest2List = Arrays.asList(hsvTest2);
  Imgproc.calcHist(hsvTest2List, new MatOfInt(channels), new Mat(), histTest2, new MatOfInt(histSize), new MatOfFloat(ranges), false);
  Core.normalize(histTest2, histTest2, 1, 0, Core.NORM_L1);
   
          for( int compareMethod = 0; compareMethod < 6; compareMethod++ ) {
              double baseBase = Imgproc.compareHist( histBase, histBase, compareMethod );
              double baseHalf = Imgproc.compareHist( histBase, histHalfDown, compareMethod );
              double baseTest1 = Imgproc.compareHist( histBase, histTest1, compareMethod );
              double baseTest2 = Imgproc.compareHist( histBase, histTest2, compareMethod );
   
  System.out.println("方法 " + compareMethod + " 完美, 基础-一半, 基础-测试(1), 基础-测试(2) : " + baseBase + " / " + baseHalf
  + " / " + baseTest1 + " / " + baseTest2);
          }
      }
  }
   
  public class CompareHistDemo {
      public static void main(String[] args) {
          // 加载本地 OpenCV 库
  System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
   
          new CompareHist().run(args);
      }
  }

Python

• 可下载代码：点击此处
• 代码概览

  from __future__ import print_function
  from __future__ import division
  import cv2 as cv
  import numpy as np
  import argparse
   
   
  parser = argparse.ArgumentParser(description='直方图比较教程代码。')
  parser.add_argument('--input1', help='输入图像 1 的路径。')
  parser.add_argument('--input2', help='输入图像 2 的路径。')
  parser.add_argument('--input3', help='输入图像 3 的路径。')
  args = parser.parse_args()
   
  src_base = cv.imread(args.input1)
  src_test1 = cv.imread(args.input2)
  src_test2 = cv.imread(args.input3)
  if src_base is None or src_test1 is None or src_test2 is None
  print('无法打开或找到图像！')
  exit(0)
   
   
   
  hsv_base = cv.cvtColor(src_base, cv.COLOR_BGR2HSV)
  hsv_test1 = cv.cvtColor(src_test1, cv.COLOR_BGR2HSV)
  hsv_test2 = cv.cvtColor(src_test2, cv.COLOR_BGR2HSV)
   
   
   
  hsv_half_down = hsv_base[hsv_base.shape[0]//2:,:]
   
   
   
  h_bins = 50
  s_bins = 60
  histSize = [h_bins, s_bins]
   
  # 色相从 0 到 179 变化，饱和度从 0 到 255 变化
  h_ranges = [0, 180]
  s_ranges = [0, 256]
  ranges = h_ranges + s_ranges # 连接列表
   
  # 使用第 0 个和第 1 个通道
  channels = [0, 1]
   
   
   
  hist_base = cv.calcHist([hsv_base], channels, None, histSize, ranges, accumulate=False)
  cv.normalize(hist_base, hist_base, alpha=1, beta=0, norm_type=cv.NORM_L1)
   
  hist_half_down = cv.calcHist([hsv_half_down], channels, None, histSize, ranges, accumulate=False)
  cv.normalize(hist_half_down, hist_half_down, alpha=1, beta=0, norm_type=cv.NORM_L1)
   
  hist_test1 = cv.calcHist([hsv_test1], channels, None, histSize, ranges, accumulate=False)
  cv.normalize(hist_test1, hist_test1, alpha=1, beta=0, norm_type=cv.NORM_L1)
   
  hist_test2 = cv.calcHist([hsv_test2], channels, None, histSize, ranges, accumulate=False)
  cv.normalize(hist_test2, hist_test2, alpha=1, beta=0, norm_type=cv.NORM_L1)
   
   
   
  for compare_method in range(6)
  base_base = cv.compareHist(hist_base, hist_base, compare_method)
  base_half = cv.compareHist(hist_base, hist_half_down, compare_method)
  base_test1 = cv.compareHist(hist_base, hist_test1, compare_method)
  base_test2 = cv.compareHist(hist_base, hist_test2, compare_method)
   
  print('方法:', compare_method, '完美, 基础-一半, 基础-测试(1), 基础-测试(2) :',\
  base_base, '/', base_half, '/', base_test1, '/', base_test2)
   

解释

• 加载基础图像 (src_base) 和其他两个测试图像

  C++

      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 << "无法打开或找到图像!\n" << endl;
  parser.printMessage();
          return -1;
      }

  Java

          if (args.length != 3) {
  System.err.println("您必须提供 3 个参数，对应 3 个图像的路径。");
  System.exit(0);
          }
  Mat srcBase = Imgcodecs.imread(args[0]);
  Mat srcTest1 = Imgcodecs.imread(args[1]);
  Mat srcTest2 = Imgcodecs.imread(args[2]);
          if (srcBase.empty() || srcTest1.empty() || srcTest2.empty()) {
  System.err.println("无法读取图像");
  System.exit(0);
          }

  Python

  parser = argparse.ArgumentParser(description='直方图比较教程代码。')
  parser.add_argument('--input1', help='输入图像 1 的路径。')
  parser.add_argument('--input2', help='输入图像 2 的路径。')
  parser.add_argument('--input3', help='输入图像 3 的路径。')
  args = parser.parse_args()
   
  src_base = cv.imread(args.input1)
  src_test1 = cv.imread(args.input2)
  src_test2 = cv.imread(args.input3)
  if src_base is None or src_test1 is None or src_test2 is None
  print('无法打开或找到图像！')
  exit(0)

• 将它们转换为 HSV 格式

  C++

      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 );

  Java

  Mat hsvBase = new Mat(), hsvTest1 = new Mat(), hsvTest2 = new Mat();
  Imgproc.cvtColor( srcBase, hsvBase, Imgproc.COLOR_BGR2HSV );
  Imgproc.cvtColor( srcTest1, hsvTest1, Imgproc.COLOR_BGR2HSV );
  Imgproc.cvtColor( srcTest2, hsvTest2, Imgproc.COLOR_BGR2HSV );

  Python

  hsv_base = cv.cvtColor(src_base, cv.COLOR_BGR2HSV)
  hsv_test1 = cv.cvtColor(src_test1, cv.COLOR_BGR2HSV)
  hsv_test2 = cv.cvtColor(src_test2, cv.COLOR_BGR2HSV)

• 此外，创建一个基础图像一半的图像（HSV 格式）。

  C++

      Mat hsv_half_down = hsv_base( Range( hsv_base.rows/2, hsv_base.rows ), Range( 0, hsv_base.cols ) );

  Java

  Mat hsvHalfDown = hsvBase.submat( new Range( hsvBase.rows()/2, hsvBase.rows() - 1 ), new Range( 0, hsvBase.cols() - 1 ) );

  Python

  hsv_half_down = hsv_base[hsv_base.shape[0]//2:,:]

• 初始化计算直方图的参数（bin、范围和通道 H 和 S）。

  C++

      int h_bins = 50, s_bins = 60;
      int histSize[] = { h_bins, s_bins };
   
      // 色相从 0 到 179 变化，饱和度从 0 到 255 变化
      float h_ranges[] = { 0, 180 };
      float s_ranges[] = { 0, 256 };
   
      const float* ranges[] = { h_ranges, s_ranges };
   
      // 使用第 0 个和第 1 个通道
      int channels[] = { 0, 1 };

  Java

          int hBins = 50, sBins = 60;
          int[] histSize = { hBins, sBins };
   
          // 色相从 0 到 179 变化，饱和度从 0 到 255 变化
          float[] ranges = { 0, 180, 0, 256 };
   
          // 使用第 0 个和第 1 个通道
          int[] channels = { 0, 1 };

  Python

  h_bins = 50
  s_bins = 60
  histSize = [h_bins, s_bins]
   
  # 色相从 0 到 179 变化，饱和度从 0 到 255 变化
  h_ranges = [0, 180]
  s_ranges = [0, 256]
  ranges = h_ranges + s_ranges # 连接列表
   
  # 使用第 0 个和第 1 个通道
  channels = [0, 1]

• 计算基础图像、2 个测试图像和下半部分基础图像的直方图。

  C++

      Mat hist_base, hist_half_down, hist_test1, hist_test2;
   
      calcHist( &hsv_base, 1, channels, Mat(), hist_base, 2, histSize, ranges, true, false );
      normalize( hist_base, hist_base, 1, 0, NORM_L1, -1, Mat() );
   
      calcHist( &hsv_half_down, 1, channels, Mat(), hist_half_down, 2, histSize, ranges, true, false );
      normalize( hist_half_down, hist_half_down, 1, 0, NORM_L1, -1, Mat() );
   
      calcHist( &hsv_test1, 1, channels, Mat(), hist_test1, 2, histSize, ranges, true, false );
      normalize( hist_test1, hist_test1, 1, 0, NORM_L1, -1, Mat() );
   
      calcHist( &hsv_test2, 1, channels, Mat(), hist_test2, 2, histSize, ranges, true, false );
      normalize( hist_test2, hist_test2, 1, 0, NORM_L1, -1, Mat() );

  Java

  Mat histBase = new Mat(), histHalfDown = new Mat(), histTest1 = new Mat(), histTest2 = new Mat();
   
  List<Mat> hsvBaseList = Arrays.asList(hsvBase);
  Imgproc.calcHist(hsvBaseList, new MatOfInt(channels), new Mat(), histBase, new MatOfInt(histSize), new MatOfFloat(ranges), false);
  Core.normalize(histBase, histBase, 1, 0, Core.NORM_L1);
   
  List<Mat> hsvHalfDownList = Arrays.asList(hsvHalfDown);
  Imgproc.calcHist(hsvHalfDownList, new MatOfInt(channels), new Mat(), histHalfDown, new MatOfInt(histSize), new MatOfFloat(ranges), false);
  Core.normalize(histHalfDown, histHalfDown, 1, 0, Core.NORM_L1);
   
  List<Mat> hsvTest1List = Arrays.asList(hsvTest1);
  Imgproc.calcHist(hsvTest1List, new MatOfInt(channels), new Mat(), histTest1, new MatOfInt(histSize), new MatOfFloat(ranges), false);
  Core.normalize(histTest1, histTest1, 1, 0, Core.NORM_L1);
   
  List<Mat> hsvTest2List = Arrays.asList(hsvTest2);
  Imgproc.calcHist(hsvTest2List, new MatOfInt(channels), new Mat(), histTest2, new MatOfInt(histSize), new MatOfFloat(ranges), false);
  Core.normalize(histTest2, histTest2, 1, 0, Core.NORM_L1);

  Python

  hist_base = cv.calcHist([hsv_base], channels, None, histSize, ranges, accumulate=False)
  cv.normalize(hist_base, hist_base, alpha=1, beta=0, norm_type=cv.NORM_L1)
   
  hist_half_down = cv.calcHist([hsv_half_down], channels, None, histSize, ranges, accumulate=False)
  cv.normalize(hist_half_down, hist_half_down, alpha=1, beta=0, norm_type=cv.NORM_L1)
   
  hist_test1 = cv.calcHist([hsv_test1], channels, None, histSize, ranges, accumulate=False)
  cv.normalize(hist_test1, hist_test1, alpha=1, beta=0, norm_type=cv.NORM_L1)
   
  hist_test2 = cv.calcHist([hsv_test2], channels, None, histSize, ranges, accumulate=False)
  cv.normalize(hist_test2, hist_test2, alpha=1, beta=0, norm_type=cv.NORM_L1)

• 顺序应用 6 种比较方法，比较基础图像 (hist_base) 的直方图与其他直方图。

  C++

      for( int compare_method = 0; compare_method < 6; compare_method++ )
      {
          double base_base = compareHist( hist_base, hist_base, compare_method );
          double base_half = compareHist( hist_base, hist_half_down, compare_method );
          double base_test1 = compareHist( hist_base, hist_test1, compare_method );
          double base_test2 = compareHist( hist_base, hist_test2, compare_method );
   
  cout << "方法 " << compare_method << " 完美, 基础-一半, 基础-测试(1), 基础-测试(2) : "
  << base_base << " / " << base_half << " / " << base_test1 << " / " << base_test2 << endl;
      }

  Java

          for( int compareMethod = 0; compareMethod < 6; compareMethod++ ) {
              double baseBase = Imgproc.compareHist( histBase, histBase, compareMethod );
              double baseHalf = Imgproc.compareHist( histBase, histHalfDown, compareMethod );
              double baseTest1 = Imgproc.compareHist( histBase, histTest1, compareMethod );
              double baseTest2 = Imgproc.compareHist( histBase, histTest2, compareMethod );
   
  System.out.println("方法 " + compareMethod + " 完美, 基础-一半, 基础-测试(1), 基础-测试(2) : " + baseBase + " / " + baseHalf
  + " / " + baseTest1 + " / " + baseTest2);
          }

  Python

  for compare_method in range(6)
  base_base = cv.compareHist(hist_base, hist_base, compare_method)
  base_half = cv.compareHist(hist_base, hist_half_down, compare_method)
  base_test1 = cv.compareHist(hist_base, hist_test1, compare_method)
  base_test2 = cv.compareHist(hist_base, hist_test2, compare_method)
   
  print('方法:', compare_method, '完美, 基础-一半, 基础-测试(1), 基础-测试(2) :',\
  base_base, '/', base_half, '/', base_test1, '/', base_test2)

结果

1. 我们使用以下图像作为输入：

其中第一个是基础图像（用于与其他图像进行比较），另外两个是测试图像。我们还将比较第一个图像与它自身以及与基础图像下半部分的比较。

1. 我们期望将基础图像直方图与自身比较时得到完美匹配。此外，与基础图像下半部分的直方图相比，它应该呈现高度匹配，因为两者来自同一来源。对于其他两个测试图像，我们可以观察到它们具有非常不同的照明条件，因此匹配度应该不会很好。

2. 以下是我们使用 OpenCV 4.12.0 获得的数值结果

   方法	基础 - 基础	基础 - 一半	基础 - 测试 1	基础 - 测试 2
   相关性	1.000000	0.880438	0.20457	0.065752
   卡方	0.000000	0.328307	181.674	80.1494
   交集	1.000000	0.75005	0.315061	0.0908022
   巴塔查里亚	0.000000	0.237866	0.679825	0.873709
   卡方替代	0.000000	0.395046	2.31572	3.41024
   KL 散度	0.000000	0.321064	2.6616	9.55412

   对于 相关性 和 交集 方法，度量值越高，匹配越准确。正如我们所见，基础-基础 的匹配度是所有方法中最高的，符合预期。我们还可以观察到 基础-一半 的匹配度是第二好的匹配（正如我们预测的那样）。对于其他四种度量，结果越小，匹配越好。