目标

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

使用 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 = { bin_{1} \cup bin_{2} \cup ....\cup bin_{n = 15} } \end{array}\]

我们还可以统计落入每个 \(bin_{i}\) 范围的像素数。对上面的示例应用此方法，我们得到以下图像（x 轴表示箱，y 轴表示每个箱中的像素数）。

这只是直方图工作原理和它为何有用的一个简单示例。直方图不仅可以统计色彩强度，还可以统计我们要测量的任何图像特征（即梯度、方向等）。
我们来识别直方图的某些部分
1. dims：要收集其数据的参数数。在我们的示例中，dims = 1，因为我们仅统计每个像素的强度值（在灰度图像中）。
2. bin：它是每个维度上的子划分数量。在我们的示例中，bin = 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))));

点( bin_w*(i), hist_h - cvRound(r_hist.at<float>(i)) ),

Scalar;( 0, 0, 255), 2, 8, 0 );

}

imshow("源图像", src );

imshow("calcHist Demo", histImage );

waitKey();

返回 EXIT_SUCCESS;

}

cv::CommandLineParser
设计用于命令行解析。
定义 utility.hpp:820

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

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:102

std
STL 命名空间。

可下载代码：单击此处
代码一览
导入 java.util.ArrayList；

导入 java.util.List；

导入 org.opencv.core.Core；

导入 org.opencv.core.CvType；

导入 org.opencv.core.Mat；

导入 org.opencv.core.MatOfFloat；

导入 org.opencv.core.MatOfInt；

导入 org.opencv.core.Point；

导入 org.opencv.core.Scalar；

导入 org.opencv.highgui.HighGui；

导入 org.opencv.imgcodecs.Imgcodecs；

导入 org.opencv.imgproc.Imgproc；

类 CalcHist {

公共 void run(String[] args) {

String filename = args.length > 0 ? args[0] : "../data/lena.jpg"；

Mat src = Imgcodecs.imread(filename)；

如果 (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( "源图像", src );

HighGui.imshow( "calcHist 演示", histImage );

HighGui.waitKey(0);

System.exit(0)；

}

}

public class CalcHistDemo {

public static void main(String[] args) {

// 加载 native 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='直方图计算教程的代码.')

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

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)
从文件中加载图像。

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

如果 (src.empty()) {

System.err.println("无法读取图像：" + 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]\)
确定组数 (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) # 上限不包括在内
希望我们的组具有相同大小（均匀）并在开始时清除直方图，因此

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()：要在源阵列上使用的掩码（0 表示要忽略的像素）。如果没有定义，则不使用
- b_hist：要存储直方图的 Mat 对象
- 1：直方图维数。
- histSize：每个已使用的维度的柱数量
- histRange：每个维度要测量的值范围
- uniform 和 accumulate：柱大小相同，直方图在开始时已清除。
创建一个图像来显示直方图

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()：可选掩码
注意要访问柱（在本例为 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))));

点( 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("源图像", src );

imshow("calcHist 演示", histImage );

waitKey();

Java

HighGui.imshow( "源图像", src );

HighGui.imshow( "calcHist 演示", histImage );

HighGui.waitKey(0);

Python

cv.imshow('Source image', src)

cv.imshow('calcHist Demo', histImage)

cv.waitKey()

结果

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

可生成以下直方图


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

目录

目标

什么是直方图？

OpenCV 提供了什么

代码

解释

结果