直方图

详细说明

类
类	cv::CLAHE
	限制对比度自适应直方图均衡化（Contrast Limited Adaptive Histogram Equalization）的基类。更多...

枚举
enum	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)
	比较两个直方图。
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())
	计算两个加权点配置之间的“最小工作量”距离（Earth Mover's Distance）。
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())

枚举类型文档 (Enumeration Type Documentation)

HistCompMethods

enum cv::HistCompMethods

#include <opencv2/imgproc.hpp>

直方图比较方法

枚举值 (Enumerator)
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	Bhattacharyya 距离 (实际上，OpenCV 计算的是 Hellinger 距离，它与 Bhattacharyya 系数相关)。 \[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)}\] 这个替代公式通常用于纹理比较。参见例如 [227]
HISTCMP_KL_DIV  Python: cv.HISTCMP_KL_DIV	Kullback-Leibler 散度 \[d(H_1,H_2) = \sum _I H_1(I) \log \left(\frac{H_1(I)}{H_2(I)}\right)\]

函数文档 (Function Documentation)

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

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( "Source", 1 );
    imshow( "Source", src );
 
    namedWindow( "H-S Histogram", 1 );
    imshow( "H-S Histogram", 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	可选掩码。如果矩阵不为空，则它必须是一个与 images[i] 大小相同的 8 位数组。非零掩码元素标记在直方图中计数的数组元素。
hist	输出直方图，这是一个密集或稀疏的 dims 维数组。
dims (维度)	直方图维度，必须是正数且不大于 CV_MAX_DIMS (在当前 OpenCV 版本中等于 32)。
histSize	每个维度的直方图大小数组。
ranges (范围数组)	每个维度的直方图 bin 边界数组。当直方图是均匀的时 (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>

比较两个直方图。

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

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

虽然该函数对于 1 维、2 维、3 维密集直方图效果很好，但它可能不适用于高维稀疏直方图。在这些直方图中，由于混叠和采样问题，非零直方图 bin 的坐标可能会略有偏移。要比较此类直方图或更通用的加权点稀疏配置，请考虑使用 EMD 函数。

参数

H1	第一个比较的直方图。
H2	第二个比较的直方图，大小与 H1 相同。
method	比较方法，请参阅 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>

计算两个加权点配置之间的“最小工作量”距离（Earth Mover's Distance）。

该函数计算两个加权点配置之间的地球搬运距离和/或距离的下界。在 [236], [237] 中描述的一个应用是用于图像检索的多维直方图比较。EMD 是一个运输问题，它使用一些单纯形算法的修改来解决，因此在最坏情况下其复杂度是指数级的，尽管平均而言它要快得多。对于真实度量，下界甚至可以更快地计算 (使用线性时间算法)，它可以用来粗略判断两个签名是否足够远，以至于它们不可能属于同一个对象。

参数

signature1	第一个签名，一个 \(\texttt{size1}\times \texttt{dims}+1\) 浮点矩阵。每行存储点权重，后跟点坐标。如果使用了用户定义的成本矩阵，则允许矩阵只有一个列 (仅权重)。权重必须是非负的，并且至少有一个非零值。
signature2	第二个签名的格式与 signature1 相同，但行数可能不同。总权重可能不同。在这种情况下，会向 signature1 或 signature2 添加一个额外的“虚拟”点。权重必须是非负的，并且至少有一个非零值。
distType	使用的度量。请参阅 DistanceTypes。
成本	用户定义的 \(\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\)。
• 归一化直方图，使直方图各箱之和为 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>