目标

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

使用 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 轴表示 bins，y 轴表示每个 bin 中的像素数量）。

这只是一个关于直方图如何工作以及为什么它有用的简单示例。直方图不仅可以统计颜色强度，还可以统计我们想要测量的任何图像特征（例如梯度、方向等）。
我们来识别直方图的几个部分
1. dims：您想要收集数据的参数数量。在我们的示例中，dims = 1，因为我们只计算每个像素的强度值（在灰度图像中）。
2. bins：它是每个 dims 中的细分数量。在我们的示例中，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 计算每个单通道平面的直方图
- 在一个窗口中绘制三个直方图

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

#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 }; //上边界是排他性的

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;

}

cv::CommandLineParser
专为命令行解析设计。
定义 utility.hpp:890

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

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

cv::Mat::empty
bool empty() const
如果数组没有元素，则返回 true。

cv::Point_< int >

cv::Scalar_< double >

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

CV_8UC3
#define CV_8UC3
定义于 interface.h:90

cvRound
int cvRound(double value)
将浮点数舍入为最近的整数。
定义 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("无法读取图像: " + 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);

}

}

可下载代码：点击此处
代码概览
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('无法打开或找到图像:', 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()

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
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("无法读取图像: " + 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('无法打开或找到图像:', 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 }; //上边界是排他性的

const float* histRange[] = { range };

Java

float[] range = {0, 256}; //上边界是排他性的

MatOfFloat histRange = new MatOfFloat(range);

Python

histRange = (0, 256) # 上边界是排他性的
我们希望我们的 bins 具有相同的大小（均匀），并且在开始时清除直方图，所以

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（在此案例中是 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 为您提供什么

代码

解释

结果