直方图

详细描述

类
类	cv::CLAHE
	对比度受限自适应直方图均衡化的基类。更多...

枚举
枚举	cv::HistCompMethods {   cv::HISTCMP_CORREL = 0 ,   cv::HISTCMP_CHISQR = 1 ,   cv::HISTCMP_INTERSECT = 2 ,   cv::HISTCMP_BHATTACHARYYA = 3 ,   cv::HISTCMP_HELLINGER = HISTCMP_BHATTACHARYYA ,   cv::HISTCMP_CHISQR_ALT = 4 ,   cv::HISTCMP_KL_DIV = 5 }

函数
void	cv::calcBackProject (const Mat *images, int nimages, const int *channels, const SparseMat &hist, OutputArray backProject, const float **ranges, double scale=1, bool uniform=true)
void	cv::calcBackProject (const Mat *images, int nimages, const int *channels, InputArray hist, OutputArray backProject, const float **ranges, double scale=1, bool uniform=true)
	计算直方图的反向投影。
void	cv::calcBackProject (InputArrayOfArrays images, const std::vector< int > &channels, InputArray hist, OutputArray dst, const std::vector< float > &ranges, double scale)
void	cv::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)
	计算一组数组的直方图。
void	cv::calcHist (const Mat *images, int nimages, const int *channels, InputArray mask, SparseMat &hist, int dims, const int *histSize, const float **ranges, bool uniform=true, bool accumulate=false)
void	cv::calcHist (InputArrayOfArrays images, const std::vector< int > &channels, InputArray mask, OutputArray hist, const std::vector< int > &histSize, const std::vector< float > &ranges, bool accumulate=false)
double	cv::compareHist (const SparseMat &H1, const SparseMat &H2, int method)
double	cv::compareHist (InputArray H1, InputArray H2, int method)
	Compares two histograms.
Ptr< CLAHE >	cv::createCLAHE (double clipLimit=40.0, Size tileGridSize=Size(8, 8))
	创建一个指向 cv::CLAHE 类的智能指针并初始化它。
float	cv::EMD (InputArray signature1, InputArray signature2, int distType, InputArray cost=noArray(), float *lowerBound=0, OutputArray flow=noArray())
	计算两个加权点配置之间的“最小工作量”距离。
void	cv::equalizeHist (InputArray src, OutputArray dst)
	均衡化灰度图像的直方图。
float	cv::wrapperEMD (InputArray signature1, InputArray signature2, int distType, InputArray cost=noArray(), Ptr< float > lowerBound=Ptr< float >(), OutputArray flow=noArray())

枚举类型文档

HistCompMethods

enum cv::HistCompMethods

#include <opencv2/imgproc.hpp>

直方图比较方法

枚举器
HISTCMP_CORREL  Python: cv.HISTCMP_CORREL	相关性 \[d(H_1,H_2) = \frac{\sum_I (H_1(I) - \bar{H_1}) (H_2(I) - \bar{H_2})}{\sqrt{\sum_I(H_1(I) - \bar{H_1})^2 \sum_I(H_2(I) - \bar{H_2})^2}}\] 其中 \[\bar{H_k} = \frac{1}{N} \sum _J H_k(J)\] 其中 \(N\) 是直方图 bin 的总数。
HISTCMP_CHISQR  Python: cv.HISTCMP_CHISQR	卡方 \[d(H_1,H_2) = \sum _I \frac{\left(H_1(I)-H_2(I)\right)^2}{H_1(I)}\]
HISTCMP_INTERSECT  Python: cv.HISTCMP_INTERSECT	交叉 \[d(H_1,H_2) = \sum _I \min (H_1(I), H_2(I))\]
HISTCMP_BHATTACHARYYA  Python: cv.HISTCMP_BHATTACHARYYA	巴塔查里雅距离（实际上，OpenCV 计算的是海林格距离，它与巴塔查里雅系数相关。） \[d(H_1,H_2) = \sqrt{1 - \frac{1}{\sqrt{\bar{H_1} \bar{H_2} N^2}} \sum_I \sqrt{H_1(I) \cdot H_2(I)}}\]
HISTCMP_HELLINGER  Python: cv.HISTCMP_HELLINGER	HISTCMP_BHATTACHARYYA 的同义词。
HISTCMP_CHISQR_ALT  Python: cv.HISTCMP_CHISQR_ALT	另类卡方 \[d(H_1,H_2) = 2 * \sum _I \frac{\left(H_1(I)-H_2(I)\right)^2}{H_1(I)+H_2(I)}\] 这个替代公式经常用于纹理比较。例如，参见 [224]
HISTCMP_KL_DIV  Python: cv.HISTCMP_KL_DIV	库尔巴克-莱布勒散度 \[d(H_1,H_2) = \sum _I H_1(I) \log \left(\frac{H_1(I)}{H_2(I)}\right)\]

函数文档

calcBackProject() [1/3]

void cv::calcBackProject	(	const Mat *	images,
		int	nimages,
		const int *	channels,
		const SparseMat &	hist,
		OutputArray	backProject,
		const float **	ranges,
		double	scale = 1,
		bool	uniform = true )

Python
	cv.calcBackProject(	images, channels, hist, ranges, scale[, dst]	) ->	dst

#include <opencv2/imgproc.hpp>

这是一个重载成员函数，为方便起见而提供。它与上述函数的区别仅在于接受的参数。

calcBackProject() [2/3]

void cv::calcBackProject	(	const Mat *	images,
		int	nimages,
		const int *	channels,
		InputArray	hist,
		OutputArray	backProject,
		const float **	ranges,
		double	scale = 1,
		bool	uniform = true )

Python
	cv.calcBackProject(	images, channels, hist, ranges, scale[, dst]	) ->	dst

#include <opencv2/imgproc.hpp>

计算直方图的反向投影。

函数 cv::calcBackProject 计算直方图的反向投影。也就是说，与 calcHist 类似，在每个位置 (x, y)，该函数从输入图像中选定的通道收集值并找到对应的直方图 bin。但它不是增加 bin 的值，而是读取 bin 值，通过 `scale` 进行缩放，并存储在 `backProject(x,y)` 中。从统计学角度来看，该函数根据直方图表示的经验概率分布计算每个元素值的概率。例如，您可以了解如何在一个场景中查找和跟踪一个颜色鲜艳的物体。

• 在跟踪之前，将物体展示给相机，使其几乎覆盖整个帧。计算色调直方图。该直方图可能具有强烈的最大值，对应于物体中的主导颜色。
• 跟踪时，使用预计算的直方图计算每个输入视频帧的色调平面的反向投影。对反向投影进行阈值处理以抑制弱颜色。抑制颜色饱和度不足以及过暗或过亮的像素也可能是有意义的。
• 在结果图像中找到连通分量，并选择，例如，最大的分量。

这是 CamShift 颜色物体跟踪器的一种近似算法。

参数

images	源数组。它们都应该具有相同的深度（CV_8U、CV_16U 或 CV_32F）和相同的大小。每个数组可以有任意数量的通道。
nimages	源图像的数量。
channels	用于计算反向投影的通道列表。通道数必须与直方图的维度匹配。第一个数组的通道从 0 到 `images[0].channels()-1` 编号，第二个数组的通道从 `images[0].channels()` 到 `images[0].channels() + images[1].channels()-1` 计数，依此类推。
hist	输入直方图，可以是稠密的或稀疏的。
backProject	目标反向投影数组，它是与 `images[0]` 具有相同大小和深度的单通道数组。
ranges	每个维度中直方图 bin 边界的数组的数组。参见 calcHist。
scale	输出反向投影的可选比例因子。
uniform	指示直方图是否均匀的标志（参见 calcHist）。

另请参见

calcHist, compareHist

calcBackProject() [3/3]

void cv::calcBackProject	(	InputArrayOfArrays	images,
		const std::vector< int > &	channels,
		InputArray	hist,
		OutputArray	dst,
		const std::vector< float > &	ranges,
		double	#include <opencv2/surface_matching/ppf_helpers.hpp>

Python
	cv.calcBackProject(	images, channels, hist, ranges, scale[, dst]	) ->	dst

#include <opencv2/imgproc.hpp>

这是一个重载成员函数，为方便起见而提供。它与上述函数的区别仅在于接受的参数。

calcHist() [1/3]

void cv::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 )

Python
	cv.calcHist(	images, channels, mask, histSize, ranges[, hist[, accumulate]]	) ->	hist

#include <opencv2/imgproc.hpp>

计算一组数组的直方图。

函数 cv::calcHist 计算一个或多个数组的直方图。用于增加直方图 bin 的元组元素取自相应输入数组的相同位置。下面的示例展示了如何计算彩色图像的 2D 色调-饱和度直方图。

#include <opencv2/imgproc.hpp>
#include <opencv2/highgui.hpp>
 
using namespace cv;
 
int main( int argc, char** argv )
{
    Mat src, hsv;
    if( argc != 2 || !(src=imread(argv[1], IMREAD_COLOR)).data )
        return -1;
 
    cvtColor(src, hsv, COLOR_BGR2HSV);
 
    // 将色调量化为 30 级
    // 将饱和度量化为 32 级
    int hbins = 30, sbins = 32;
    int histSize[] = {hbins, sbins};
    // 色调范围从 0 到 179，参见 cvtColor
    float hranges[] = { 0, 180 };
    // 饱和度范围从 0（黑-灰-白）到
    // 255（纯光谱色）
    float sranges[] = { 0, 256 };
    const float* ranges[] = { hranges, sranges };
MatND hist;
    // 我们从第 0 和第 1 个通道计算直方图
    int channels[] = {0, 1};
 
    calcHist( &hsv, 1, channels, Mat(), // 不使用掩码
hist, 2, histSize, ranges,
             true, // 直方图是均匀的
             false );
    double maxVal=0;
    minMaxLoc(hist, 0, &maxVal, 0, 0);
 
    int scale = 10;
    Mat histImg = Mat::zeros(sbins*scale, hbins*10, CV_8UC3);
 
    for( int h = 0; h < hbins; h++ )
        for( int s = 0; s < sbins; s++ )
        {
            float binVal = hist.at<float>(h, s);
            int intensity = cvRound(binVal*255/maxVal);
            rectangle( histImg, Point(h*scale, s*scale),
                        Point( (h+1)*scale - 1, (s+1)*scale - 1),
Scalar::all(intensity),
                        -1 );
        }
 
    namedWindow( "源图像", 1 );
    imshow( "源图像", src );
 
    namedWindow( "H-S 直方图", 1 );
    imshow( "H-S 直方图", histImg );
    waitKey();
}

参数

images	源数组。它们都应该具有相同的深度（CV_8U、CV_16U 或 CV_32F）和相同的大小。每个数组可以有任意数量的通道。
nimages	源图像的数量。
channels	用于计算直方图的 dims 通道列表。第一个数组的通道从 0 到 `images[0].channels()-1` 编号，第二个数组的通道从 `images[0].channels()` 到 `images[0].channels() + images[1].channels()-1` 计数，依此类推。
mask	可选掩码。如果矩阵不为空，它必须是一个 8 位数组，其大小与 `images[i]` 相同。非零掩码元素标记在直方图中计数的数组元素。
hist	输出直方图，它是一个稠密或稀疏的 dims 维数组。
dims	直方图维度，必须为正且不大于 CV_MAX_DIMS（当前 OpenCV 版本中等于 32）。
histSize	每个维度中直方图大小的数组。
ranges	每个维度中直方图 bin 边界的 dims 数组的数组。当直方图是均匀的（`uniform = true`）时，对于每个维度 i，只需指定第 0 个直方图 bin 的下限（包含）\(L_0\) 和最后一个直方图 bin `histSize[i]-1` 的上限（不包含）\(U_{\texttt{histSize}[i]-1}\)。也就是说，在均匀直方图的情况下，`ranges[i]` 的每个元素都是一个包含 2 个元素的数组。当直方图不均匀（`uniform = false`）时，`ranges[i]` 的每个元素包含 `histSize[i]+1` 个元素：\(L_0, U_0=L_1, U_1=L_2, ..., U_{\texttt{histSize[i]}-2}=L_{\texttt{histSize[i]}-1}, U_{\texttt{histSize[i]}-1}\)。不在 \(L_0\) 和 \(U_{\texttt{histSize[i]}-1}\) 之间的数组元素不计入直方图。
uniform	指示直方图是否均匀的标志（见上文）。
accumulate	累积标志。如果设置此标志，直方图在分配时不会在开始时被清除。此功能使您能够从多个数组集中计算单个直方图，或随时更新直方图。

calcHist() [2/3]

void cv::calcHist	(	const Mat *	images,
		int	nimages,
		const int *	channels,
		InputArray	mask,
		SparseMat &	hist,
		int	dims,
		const int *	histSize,
		const float **	ranges,
		bool	uniform = true,
		bool	accumulate = false )

Python
	cv.calcHist(	images, channels, mask, histSize, ranges[, hist[, accumulate]]	) ->	hist

#include <opencv2/imgproc.hpp>

这是一个重载成员函数，为方便起见而提供。它与上述函数的区别仅在于接受的参数。

此变体使用 SparseMat 作为输出

calcHist() [3/3]

void cv::calcHist	(	InputArrayOfArrays	images,
		const std::vector< int > &	channels,
		InputArray	mask,
		OutputArray	hist,
		const std::vector< int > &	histSize,
		const std::vector< float > &	ranges,
		bool	accumulate = false )

Python
	cv.calcHist(	images, channels, mask, histSize, ranges[, hist[, accumulate]]	) ->	hist

#include <opencv2/imgproc.hpp>

这是一个重载成员函数，为方便起见而提供。它与上述函数的区别仅在于接受的参数。

此变体仅支持均匀直方图。

`ranges` 参数可以是空向量，也可以是 `histSize.size()*2` 个元素（`histSize.size()` 对元素）的扁平向量。每对的第一个和第二个元素指定下限和上限。

compareHist() [1/2]

double cv::compareHist	(	const SparseMat &	H1,
		const SparseMat &	H2,
		int	method )

Python
	cv.compareHist(	H1, H2, method	) ->	retval

#include <opencv2/imgproc.hpp>

这是一个重载成员函数，为方便起见而提供。它与上述函数的区别仅在于接受的参数。

compareHist() [2/2]

double cv::compareHist	(	InputArray	H1,
		InputArray	H2,
		int	method )

Python
	cv.compareHist(	H1, H2, method	) ->	retval

#include <opencv2/imgproc.hpp>

Compares two histograms.

函数 cv::compareHist 使用指定的方法比较两个稠密或两个稀疏直方图。

该函数返回 \(d(H_1, H_2)\)。

尽管该函数在 1、2、3 维稠密直方图上表现良好，但它可能不适用于高维稀疏直方图。在此类直方图中，由于混叠和采样问题，非零直方图 bin 的坐标可能会略微偏移。为了比较此类直方图或更一般的加权点稀疏配置，请考虑使用 EMD 函数。

参数

H1	第一个比较的直方图。
H2	第二个比较的直方图，其大小与 H1 相同。
方法	比较方法，参见 HistCompMethods

createCLAHE()

Ptr< CLAHE > cv::createCLAHE	(	double	clipLimit = 40.0,
		Size	tileGridSize = Size(8, 8) )

Python
	cv.createCLAHE(	[, clipLimit[, tileGridSize]]	) ->	retval

#include <opencv2/imgproc.hpp>

创建一个指向 cv::CLAHE 类的智能指针并初始化它。

参数

clipLimit	对比度限制的阈值。
tileGridSize	直方图均衡化的网格大小。输入图像将被划分为大小相等的矩形瓦片。`tileGridSize` 定义了行和列中的瓦片数量。

EMD()

float cv::EMD	(	InputArray	signature1,
		InputArray	signature2,
		int	distType,
		InputArray	cost = noArray(),
		float *	lowerBound = 0,
		OutputArray	flow = noArray() )

#include <opencv2/imgproc.hpp>

计算两个加权点配置之间的“最小工作量”距离。

该函数计算两个加权点配置之间的地球移动距离和/或距离的下限。在 [233]、[234] 中描述的应用之一是用于图像检索的多维直方图比较。EMD 是一个运输问题，通过单纯形算法的一些修改来解决，因此在最坏情况下复杂度是指数级的，但平均而言速度要快得多。在真实度量的情况下，下限可以更快地计算（使用线性时间算法），并且可以用来粗略地判断两个特征是否足够远，以至于它们不能与同一个对象相关。

参数

signature1	第一个特征，一个 \(\texttt{size1}\times \texttt{dims}+1\) 的浮点矩阵。每行存储点权重，后跟点坐标。如果使用用户定义的成本矩阵，则该矩阵可以只有一列（仅权重）。权重必须是非负数并且至少有一个非零值。
signature2	第二个特征，格式与 `signature1` 相同，但行数可能不同。总权重可能不同。在这种情况下，会向 `signature1` 或 `signature2` 添加一个额外的“虚拟”点。权重必须是非负数并且至少有一个非零值。
distType	使用的度量。参见 DistanceTypes。
cost	用户定义的 \(\texttt{size1}\times \texttt{size2}\) 成本矩阵。此外，如果使用成本矩阵，则无法计算下限 `lowerBound`，因为它需要度量函数。
lowerBound	可选输入/输出参数：两个特征之间距离的下限，它是质心之间的距离。如果使用用户定义的成本矩阵、点配置的总权重不相等，或者如果特征仅由权重组成（特征矩阵只有一列），则可能无法计算下限。您必须**初始化 `*lowerBound`。如果计算出的质心距离大于或等于 `*lowerBound`（这意味着特征足够远），则函数不计算 EMD。在任何情况下，`*lowerBound` 在返回时都设置为计算出的质心距离。因此，如果您想同时计算质心距离和 EMD，`*lowerBound` 应设置为 0。
flow	结果 \(\texttt{size1} \times \texttt{size2}\) 流矩阵：\(\texttt{flow}_{i,j}\) 是从 `signature1` 的第 \(i\) 个点到 `signature2` 的第 \(j\) 个点的流。

equalizeHist()

void cv::equalizeHist	(	InputArray	src,
		OutputArray	dst )

Python
	cv.equalizeHist(	src[, dst]	) ->	dst

#include <opencv2/imgproc.hpp>

均衡化灰度图像的直方图。

该函数使用以下算法均衡输入图像的直方图：

• 计算src的直方图\(H\)。
• 归一化直方图，使直方图 bin 的总和为 255。
• 计算直方图的积分

  \[H'_i = \sum _{0 \le j < i} H(j)\]

• 使用 \(H'\) 作为查找表转换图像：\(\texttt{dst}(x,y) = H'(\texttt{src}(x,y))\)

该算法可使图像亮度归一化并增加对比度。

参数

src	源8位单通道图像。
dst	与 src 具有相同大小和类型的目标图像。

wrapperEMD()

float cv::wrapperEMD	(	InputArray	signature1,
		InputArray	signature2,
		int	distType,
		InputArray	cost = noArray(),
		Ptr< float >	lowerBound = Ptr< float >(),
		OutputArray	flow = noArray() )

Python
	cv.EMD(	signature1, signature2, distType[, cost[, lowerBound[, flow]]]	) ->	retval, lowerBound, flow

#include <opencv2/imgproc.hpp>