目標

在本教程中，您將學習如何

使用 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 為您提供了什麼

程式碼

解釋

結果