目标

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

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

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

什么是直方图？

直方图是将数据组织成一组预定义 bins（数据区间） 的计数集合
当我们说数据时，我们不将其限制为强度值（如我们在上一个教程直方图均衡化中所看到的）。收集到的数据可以是您认为对描述图像有用的任何特征。
让我们看一个例子。想象一个矩阵包含图像信息（即强度范围在 \(0-255\) 之间）

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

\[\begin{array}{l} [0, 255] = { [0, 15] \cup [16, 31] \cup ....\cup [240,255] } \\ range = { bin_{1} \cup bin_{2} \cup ....\cup bin_{n = 15} } \end{array}\]

我们可以统计落入每个 \(bin_{i}\) 范围内的像素数量。将其应用于上面的示例，我们得到下图（x 轴代表数据区间，y 轴代表每个数据区间中的像素数量）。

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

OpenCV 为您提供了什么

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

代码

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

可下载代码：点击此处
代码速览

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

}

bool empty() const
如果数组没有元素，则返回 true。
int64_t int64

cv::Mat
n 维密集数组类
定义 mat.hpp:830

cv::Mat::at
_Tp & at(int i0=0)
返回指定数组元素的引用。

定义 interface.h:61
cv::getTickFrequency
double getTickFrequency()

cv::Point_< int >

cv::Scalar_< double >

cv::String
std::string String
定义 cvstd.hpp:151

// 相同的通道类型。
CV_8UC3
#define CV_8UC3

cvRound
int cvRound(double value)
将浮点数舍入为最接近的整数。
Definition fast_math.hpp:200

cv::imshow
void imshow(const String &winname, InputArray mat)
在指定窗口中显示图像。

cv::waitKey
int waitKey(int delay=0)
等待按键按下。

highgui.hpp

main
int main(int argc, char *argv[])
定义 highgui_qt.cpp:3

imgcodecs.hpp

imgproc.hpp

cv
定义 core.hpp:107

std
STL 命名空间。

可下载代码：点击此处
代码速览
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}; //the upper boundary is exclusive

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

}

}

可下载代码：点击此处
代码速览
from __future__ import print_function

from __future__ import division

import cv2 as cv

import numpy as np

import argparse

parser = argparse.ArgumentParser(description='Code for Histogram Calculation tutorial.')

parser.add_argument('--input', help='Path to input image.', default='lena.jpg')

args = parser.parse_args()

src = cv.imread(cv.samples.findFile(args.input))

if src is None

print('Could not open or find the image:', args.input)

exit(0)

bgr_planes = cv.split(src)

histSize = 256

histRange = (0, 256) # the upper boundary is exclusive

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

cv::split
void split(const Mat &src, Mat *mvbegin)
将多通道数组分割成几个单通道数组。

cv::normalize
void normalize(InputArray src, InputOutputArray dst, double alpha=1, double beta=0, int norm_type=NORM_L2, int dtype=-1, InputArray mask=noArray())
对数组的范数或值范围进行归一化。

cv::samples::findFile
cv::String findFile(const cv::String &relative_path, bool required=true, bool silentMode=false)
尝试查找请求的数据文件。

cv::imread
CV_EXPORTS_W Mat imread(const String &filename, int flags=IMREAD_COLOR_BGR)
从文件加载图像。

cv::line
void line(InputOutputArray img, Point pt1, Point pt2, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0)
绘制连接两点的线段。

cv::calcHist
void calcHist(const Mat *images, int nimages, const int *channels, InputArray mask, OutputArray hist, int dims, const int *histSize, const float **ranges, bool uniform=true, bool accumulate=false)
计算一组数组的直方图。

解释

加载源图像

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='Code for Histogram Calculation tutorial.')

parser.add_argument('--input', help='Path to input image.', default='lena.jpg')

args = parser.parse_args()

src = cv.imread(cv.samples.findFile(args.input))

if src is None

print('Could not open or find the image:', 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]\) 区间内。
设置数据区间的数量（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}; //the upper boundary is exclusive

MatOfFloat histRange = new MatOfFloat(range);

Python

histRange = (0, 256) # the upper boundary is exclusive
我们希望数据区间大小相同（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: 要测量的通道（维度）。在这种情况下，它只是强度（每个数组都是单通道），所以我们只写 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（在此 1D 直方图中）

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\) 表示维度。如果它是 2D 直方图，我们将使用类似以下内容：
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()

结果

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

生成以下直方图


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

目录

目标

什么是直方图？

OpenCV 为您提供了什么

代码

解释

结果