直方图计算

目录

• 目标
  • 什么是直方图？
  • OpenCV 提供了什么
• 代码
• 解释
• 结果

上一篇教程： 直方图均衡化
下一篇教程： 直方图比较

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

目标

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

• 使用 OpenCV 函数 cv::split 将图像分割成其对应的平面。
• 使用 OpenCV 函数 cv::calcHist 计算图像数组的直方图。
• 使用函数 cv::normalize 归一化数组。

注意

在上一篇教程 (直方图均衡化) 中，我们讨论了一种特殊的直方图，称为 *图像直方图*。现在我们将从更一般的概念来考虑它。继续阅读！

什么是直方图？

• 直方图是将数据组织到一组预定义的 *区间* 中的 *计数* 的集合。
• 当我们说 *数据* 时，我们并没有将其限制为强度值（正如我们在上一篇教程 直方图均衡化 中看到的）。收集的数据可以是您发现对描述图像有用的任何特征。
• 让我们来看一个例子。假设一个矩阵包含图像的信息（例如，范围为 $0-255$ 的强度）。

• 如果我们想以一种有组织的方式 *计数* 此数据会发生什么？由于我们知道在这种情况下信息值的 *范围* 是 256 个值，我们可以将我们的范围细分为子部分（称为 **区间**），例如

  $$\begin{array}{l}[0,255]=[0,15]\cup [16,31]\cup ....\cup [240,255]\\ range=bi{n}_1\cup bi{n}_2\cup ....\cup bi{n}_{n=15}\end{array}$$

  我们可以计算落在每个 $bi{n}_i$ 范围内的像素数量。将其应用于上面的示例，我们得到下面的图像（x 轴表示区间，y 轴表示每个区间中的像素数量）。

• 这只是一个关于直方图如何工作以及为什么它有用的简单示例。直方图不仅可以统计颜色强度，还可以统计我们想要测量的任何图像特征（例如，梯度、方向等）。
• 让我们确定直方图的一些部分
  1. **dims**：您想要收集数据的参数数量。在我们的示例中，**dims = 1**，因为我们只统计每个像素的强度值（在灰度图像中）。
  2. **bins**：这是每个 dim 中的 **子分区** 数量。在我们的示例中，**bins = 16**
  3. **range**：要测量的值的限制。在这种情况下：**range = [0,255]**
• 如果您想计算两个特征怎么办？在这种情况下，您的结果直方图将是一个 3D 绘图（其中 x 和 y 将是每个特征的 $bi{n}_x$ 和 $bi{n}_y$，而 z 将是每个 $(bi{n}_x,bi{n}_y)$ 组合的计数数量）。对于更多特征也是如此（当然会更棘手）。

OpenCV 提供了什么

为了简单起见，OpenCV 实现了函数 cv::calcHist，它计算一组数组（通常是图像或图像平面）的直方图。它最多可以操作 32 个维度。我们将在下面的代码中看到它！

代码

C++JavaPython

• 这个程序做什么？
  • 加载图像
  • 使用函数 cv::split 将图像分割成其 R、G 和 B 平面。
  • 通过调用函数 cv::calcHist 计算每个 1 通道平面的直方图。
  • 在一个窗口中绘制三个直方图。

C++

• 可下载代码： 点击 这里
• 代码概览

   
  #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)
  {
      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 );
   
      int histSize = 256;
   
      float range[] = { 0, 256 }; //the upper boundary is exclusive
      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) );
   
  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;
  }

Java

• **可下载代码:** 点击这里
• 代码概览

  import java.util.ArrayList;
  import java.util.List;
   
  import org.opencv.core.Core;
  import org.opencv.core.CvType;
  import org.opencv.core.Mat;
  import org.opencv.core.MatOfFloat;
  import org.opencv.core.MatOfInt;
  import org.opencv.core.Point;
  import org.opencv.core.Scalar;
  import org.opencv.highgui.HighGui;
  import org.opencv.imgcodecs.Imgcodecs;
  import org.opencv.imgproc.Imgproc;
   
  class CalcHist {
      public void run(String[] args) {
  String filename = args.length > 0 ? args[0] : "../data/lena.jpg";
  Mat src = Imgcodecs.imread(filename);
          if (src.empty()) {
  System.err.println("Cannot read image: " + filename);
  System.exit(0);
          }
   
  List<Mat> bgrPlanes = new ArrayList<>();
  Core.split(src, bgrPlanes);
   
          int histSize = 256;
   
          float[] range = {0, 256}; //上边界不包含
  MatOfFloat histRange = new MatOfFloat(range);
   
          boolean accumulate = false;
   
  Mat bHist = new Mat(), gHist = new Mat(), rHist = new Mat();
  Imgproc.calcHist(bgrPlanes, new MatOfInt(0), new Mat(), bHist, new MatOfInt(histSize), histRange, accumulate);
  Imgproc.calcHist(bgrPlanes, new MatOfInt(1), new Mat(), gHist, new MatOfInt(histSize), histRange, accumulate);
  Imgproc.calcHist(bgrPlanes, new MatOfInt(2), new Mat(), rHist, new MatOfInt(histSize), histRange, accumulate);
   
          int histW = 512, histH = 400;
          int binW = (int) Math.round((double) histW / histSize);
   
  Mat histImage = new Mat(histH, histW, CvType.CV_8UC3, new Scalar(0,0,0) );
   
  Core.normalize(bHist, bHist, 0, histImage.rows(), Core.NORM_MINMAX);
  Core.normalize(gHist, gHist, 0, histImage.rows(), Core.NORM_MINMAX);
  Core.normalize(rHist, rHist, 0, histImage.rows(), Core.NORM_MINMAX);
   
          float[] bHistData = new float[(int) (bHist.total() * bHist.channels())];
  bHist.get(0, 0, bHistData);
          float[] gHistData = new float[(int) (gHist.total() * gHist.channels())];
  gHist.get(0, 0, gHistData);
          float[] rHistData = new float[(int) (rHist.total() * rHist.channels())];
  rHist.get(0, 0, rHistData);
   
          for( int i = 1; i < histSize; i++ ) {
  Imgproc.line(histImage, new Point(binW * (i - 1), histH - Math.round(bHistData[i - 1])),
                      new Point(binW * (i), histH - Math.round(bHistData[i])), new Scalar(255, 0, 0), 2);
  Imgproc.line(histImage, new Point(binW * (i - 1), histH - Math.round(gHistData[i - 1])),
                      new Point(binW * (i), histH - Math.round(gHistData[i])), new Scalar(0, 255, 0), 2);
  Imgproc.line(histImage, new Point(binW * (i - 1), histH - Math.round(rHistData[i - 1])),
                      new Point(binW * (i), histH - Math.round(rHistData[i])), new Scalar(0, 0, 255), 2);
          }
   
  HighGui.imshow( "Source image", src );
  HighGui.imshow( "calcHist Demo", histImage );
  HighGui.waitKey(0);
   
  System.exit(0);
      }
  }
   
  public class CalcHistDemo {
      public static void main(String[] args) {
          // 加载本地 OpenCV 库
  System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
   
          new CalcHist().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('--input', help='输入图像路径。', default='lena.jpg')
  args = parser.parse_args()
   
  src = cv.imread(cv.samples.findFile(args.input))
  if src is None
  print('无法打开或找到图像：', args.input)
  exit(0)
   
   
   
  bgr_planes = cv.split(src)
   
   
   
  histSize = 256
   
   
   
  histRange = (0, 256) # 上边界不包含
   
   
   
  accumulate = False
   
   
   
  b_hist = cv.calcHist(bgr_planes, [0], None, [histSize], histRange, accumulate=accumulate)
  g_hist = cv.calcHist(bgr_planes, [1], None, [histSize], histRange, accumulate=accumulate)
  r_hist = cv.calcHist(bgr_planes, [2], None, [histSize], histRange, accumulate=accumulate)
   
   
   
  hist_w = 512
  hist_h = 400
  bin_w = int(round( hist_w/histSize ))
   
  histImage = np.zeros((hist_h, hist_w, 3), dtype=np.uint8)
   
   
   
  cv.normalize(b_hist, b_hist, alpha=0, beta=hist_h, norm_type=cv.NORM_MINMAX)
  cv.normalize(g_hist, g_hist, alpha=0, beta=hist_h, norm_type=cv.NORM_MINMAX)
  cv.normalize(r_hist, r_hist, alpha=0, beta=hist_h, norm_type=cv.NORM_MINMAX)
   
   
   
  for i in range(1, histSize)
      cv.line(histImage, ( bin_w*(i-1), hist_h - int(b_hist[i-1]) ),
  ( bin_w*(i), hist_h - int(b_hist[i]) ),
  ( 255, 0, 0), thickness=2)
      cv.line(histImage, ( bin_w*(i-1), hist_h - int(g_hist[i-1]) ),
  ( bin_w*(i), hist_h - int(g_hist[i]) ),
  ( 0, 255, 0), thickness=2)
      cv.line(histImage, ( bin_w*(i-1), hist_h - int(r_hist[i-1]) ),
  ( bin_w*(i), hist_h - int(r_hist[i]) ),
  ( 0, 0, 255), thickness=2)
   
   
   
  cv.imshow('Source image', src)
  cv.imshow('calcHist Demo', histImage)
  cv.waitKey()
   

说明

C++JavaPython

• 加载源图像

  C++

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

  Java

          String filename = args.length > 0 ? args[0] : "../data/lena.jpg";
  Mat src = Imgcodecs.imread(filename);
          if (src.empty()) {
  System.err.println("Cannot read image: " + filename);
  System.exit(0);
          }

  Python

  parser = argparse.ArgumentParser(description='直方图计算教程代码。')
  parser.add_argument('--input', help='输入图像路径。', default='lena.jpg')
  args = parser.parse_args()
   
  src = cv.imread(cv.samples.findFile(args.input))
  if src is None
  print('无法打开或找到图像：', args.input)
  exit(0)

• 将源图像分离成三个R、G和B平面。为此，我们使用OpenCV函数cv::split

  C++

  vector<Mat> bgr_planes;
      split( src, bgr_planes );

  Java

  List<Mat> bgrPlanes = new ArrayList<>();
  Core.split(src, bgrPlanes);

  Python

  bgr_planes = cv.split(src)

  我们的输入是要分割的图像（本例中包含三个通道），输出是Mat的向量。

• 现在我们准备开始为每个平面配置**直方图**。由于我们使用的是B、G和R平面，因此我们知道我们的值将在区间[0,255]内。

• 确定bin的数量（5、10……）

  C++

      int histSize = 256;

  Java

          int histSize = 256;

  Python

  histSize = 256

• 设置值的范围（如前所述，在0到255之间）

  C++

      float range[] = { 0, 256 }; //the upper boundary is exclusive
      const float* histRange[] = { range };

  Java

          float[] range = {0, 256}; //上边界不包含
  MatOfFloat histRange = new MatOfFloat(range);

  Python

  histRange = (0, 256) # 上边界不包含

• 我们希望我们的bin大小相同（uniform），并在开始时清除直方图，因此

  C++

      bool uniform = true, accumulate = false;

  Java

          boolean accumulate = false;

  Python

  accumulate = False

• 我们使用OpenCV函数cv::calcHist来计算直方图

  C++

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

  Java

  Mat bHist = new Mat(), gHist = new Mat(), rHist = new Mat();
  Imgproc.calcHist(bgrPlanes, new MatOfInt(0), new Mat(), bHist, new MatOfInt(histSize), histRange, accumulate);
  Imgproc.calcHist(bgrPlanes, new MatOfInt(1), new Mat(), gHist, new MatOfInt(histSize), histRange, accumulate);
  Imgproc.calcHist(bgrPlanes, new MatOfInt(2), new Mat(), rHist, new MatOfInt(histSize), histRange, accumulate);

  Python

  b_hist = cv.calcHist(bgr_planes, [0], None, [histSize], histRange, accumulate=accumulate)
  g_hist = cv.calcHist(bgr_planes, [1], None, [histSize], histRange, accumulate=accumulate)
  r_hist = cv.calcHist(bgr_planes, [2], None, [histSize], histRange, accumulate=accumulate)

• 参数为（**C++代码**）
  • **&bgr_planes[0]:** 源数组
  • **1:** 源数组的数量（在本例中我们使用1。我们也可以在这里输入数组列表）
  • **0:** 要测量的通道（_dim_）。在本例中，它只是强度（每个数组都是单通道），因此我们只写0。
  • **Mat():** 要用于源数组的掩码（零表示要忽略的像素）。如果未定义，则不使用。
  • **b_hist:** 将存储直方图的Mat对象
  • **1:** 直方图维度。
  • **histSize:** 每个维度使用的bin的数量
  • **histRange:** 每个维度要测量的值范围
  • **uniform** 和 **accumulate:** bin大小相同，并且直方图在开始时被清除。

• 创建图像以显示直方图

  C++

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

  Java

          int histW = 512, histH = 400;
          int binW = (int) Math.round((double) histW / histSize);
   
  Mat histImage = new Mat( histH, histW, CvType.CV_8UC3, new Scalar( 0,0,0) );

  Python

  hist_w = 512
  hist_h = 400
  bin_w = int(round( hist_w/histSize ))
   
  histImage = np.zeros((hist_h, hist_w, 3), dtype=np.uint8)

• 请注意，在绘制之前，我们首先cv::normalize直方图，以便其值落在输入参数指示的范围内。

  C++

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

  Java

  Core.normalize(bHist, bHist, 0, histImage.rows(), Core.NORM_MINMAX);
  Core.normalize(gHist, gHist, 0, histImage.rows(), Core.NORM_MINMAX);
  Core.normalize(rHist, rHist, 0, histImage.rows(), Core.NORM_MINMAX);

  Python

  cv.normalize(b_hist, b_hist, alpha=0, beta=hist_h, norm_type=cv.NORM_MINMAX)
  cv.normalize(g_hist, g_hist, alpha=0, beta=hist_h, norm_type=cv.NORM_MINMAX)
  cv.normalize(r_hist, r_hist, alpha=0, beta=hist_h, norm_type=cv.NORM_MINMAX)

• 此函数接收以下参数（**C++代码**）
  • **b_hist:** 输入数组
  • **b_hist:** 输出归一化数组（可以相同）
  • **0** 和 **histImage.rows:** 对于此示例，它们是将**r_hist**的值归一化到的下限和上限。
  • **NORM_MINMAX:** 指示归一化类型的参数（如上所述，它将值调整到之前设置的两个限制之间）
  • **-1:** 表示输出归一化数组将与输入类型相同。
  • **Mat():** 可选掩码

• 观察访问bin的方法（在本例的一维直方图中）

  C++

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

  Java

          float[] bHistData = new float[(int) (bHist.total() * bHist.channels())];
  bHist.get(0, 0, bHistData);
          float[] gHistData = new float[(int) (gHist.total() * gHist.channels())];
  gHist.get(0, 0, gHistData);
          float[] rHistData = new float[(int) (rHist.total() * rHist.channels())];
  rHist.get(0, 0, rHistData);
   
          for( int i = 1; i < histSize; i++ ) {
  Imgproc.line(histImage, new Point(binW * (i - 1), histH - Math.round(bHistData[i - 1])),
                      new Point(binW * (i), histH - Math.round(bHistData[i])), new Scalar(255, 0, 0), 2);
  Imgproc.line(histImage, new Point(binW * (i - 1), histH - Math.round(gHistData[i - 1])),
                      new Point(binW * (i), histH - Math.round(gHistData[i])), new Scalar(0, 255, 0), 2);
  Imgproc.line(histImage, new Point(binW * (i - 1), histH - Math.round(rHistData[i - 1])),
                      new Point(binW * (i), histH - Math.round(rHistData[i])), new Scalar(0, 0, 255), 2);
          }

  Python

  for i in range(1, histSize)
      cv.line(histImage, ( bin_w*(i-1), hist_h - int(b_hist[i-1]) ),
  ( bin_w*(i), hist_h - int(b_hist[i]) ),
  ( 255, 0, 0), thickness=2)
      cv.line(histImage, ( bin_w*(i-1), hist_h - int(g_hist[i-1]) ),
  ( bin_w*(i), hist_h - int(g_hist[i]) ),
  ( 0, 255, 0), thickness=2)
      cv.line(histImage, ( bin_w*(i-1), hist_h - int(r_hist[i-1]) ),
  ( bin_w*(i), hist_h - int(r_hist[i]) ),
  ( 0, 0, 255), thickness=2)

  我们使用表达式（**C++代码**）

  b_hist.at<float>(i)

  其中$i$表示维度。如果是二维直方图，我们会使用类似这样的表达式：

  b_hist.at<float>(i, j)

• 最后，我们显示直方图并等待用户退出。

  C++

      imshow("Source image", src );
      imshow("calcHist Demo", histImage );
      waitKey();

  Java

  HighGui.imshow( "Source image", src );
  HighGui.imshow( "calcHist Demo", histImage );
  HighGui.waitKey(0);

  Python

  cv.imshow('Source image', src)
  cv.imshow('calcHist Demo', histImage)
  cv.waitKey()

结果

1. 使用如下所示的图像作为输入参数

1. 会生成以下直方图