详细描述

枚举
枚举	cv::AdaptiveThresholdTypes { cv::ADAPTIVE_THRESH_MEAN_C = 0 , cv::ADAPTIVE_THRESH_GAUSSIAN_C = 1 }

枚举	cv::DistanceTransformLabelTypes { cv::DIST_LABEL_CCOMP = 0 , cv::DIST_LABEL_PIXEL = 1 }
	distanceTransform 算法标志更多…

枚举	cv::DistanceTransformMasks { cv::DIST_MASK_3 = 3 , cv::DIST_MASK_5 = 5 , cv::DIST_MASK_PRECISE = 0 }
	距离变换的掩码大小。更多…

枚举	cv::DistanceTypes { cv::DIST_USER = -1 , cv::DIST_L1 = 1 , cv::DIST_L2 = 2 , cv::DIST_C = 3 , cv::DIST_L12 = 4 , cv::DIST_FAIR = 5 , cv::DIST_WELSCH = 6 , cv::DIST_HUBER = 7 }

枚举	cv::FloodFillFlags { cv::FLOODFILL_FIXED_RANGE = 1 << 16 , cv::FLOODFILL_MASK_ONLY = 1 << 17 }
	floodfill 算法标志更多…

枚举	cv::GrabCutClasses { cv::GC_BGD = 0 , cv::GC_FGD = 1 , cv::GC_PR_BGD = 2 , cv::GC_PR_FGD = 3 }
	GrabCut 算法中像素的类别更多…

枚举	cv::GrabCutModes { cv::GC_INIT_WITH_RECT = 0 , cv::GC_INIT_WITH_MASK = 1 , cv::GC_EVAL = 2 , cv::GC_EVAL_FREEZE_MODEL = 3 }
	GrabCut 算法标志。更多…

枚举	cv::ThresholdTypes { cv::THRESH_BINARY = 0 , cv::THRESH_BINARY_INV = 1 , cv::THRESH_TRUNC = 2 , cv::THRESH_TOZERO = 3 , cv::THRESH_TOZERO_INV = 4 , cv::THRESH_MASK = 7 , cv::THRESH_OTSU = 8 , cv::THRESH_TRIANGLE = 16 }

函数
void	cv::adaptiveThreshold (InputArray src, OutputArray dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C)
	对数组应用自适应阈值。

void	cv::blendLinear (InputArray src1, InputArray src2, InputArray weights1, InputArray weights2, OutputArray dst)

void	cv::distanceTransform (InputArray src, OutputArray dst, int distanceType, int maskSize, int dstType=CV_32F)

void	cv::distanceTransform (InputArray src, OutputArray dst, OutputArray labels, int distanceType, int maskSize, int labelType=DIST_LABEL_CCOMP)
	计算源图像每个像素到最近的零像素的距离。

int	cv::floodFill (InputOutputArray image, InputOutputArray mask, Point seedPoint, Scalar newVal, Rect *rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4)
	用给定的颜色填充连通区域。

int	cv::floodFill (InputOutputArray image, Point seedPoint, Scalar newVal, Rect *rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4)

void	cv::integral (InputArray src, OutputArray sum, int sdepth=-1)

void	cv::integral (InputArray src, OutputArray sum, OutputArray sqsum, int sdepth=-1, int sqdepth=-1)

void	cv::integral (InputArray src, OutputArray sum, OutputArray sqsum, OutputArray tilted, int sdepth=-1, int sqdepth=-1)
	计算图像的积分。

double	cv::threshold (InputArray src, OutputArray dst, double thresh, double maxval, int type)
	对每个数组元素应用固定级别的阈值。

枚举类型文档

◆ AdaptiveThresholdTypes

枚举 cv::AdaptiveThresholdTypes

#include <opencv2/imgproc.hpp>

自适应阈值算法

另请参见: adaptiveThreshold

枚举器
ADAPTIVE_THRESH_MEAN_C Python: cv.ADAPTIVE_THRESH_MEAN_C	阈值 \(T(x,y)\) 是 \(\texttt{blockSize} \times \texttt{blockSize}\) 邻域的均值减去 C
ADAPTIVE_THRESH_GAUSSIAN_C Python: cv.ADAPTIVE_THRESH_GAUSSIAN_C	阈值 \(T(x, y)\) 是 \(\texttt{blockSize} \times \texttt{blockSize}\) 邻域的加权和（与高斯窗口的互相关）减去 C。对指定的 blockSize 使用默认的 sigma（标准差）。参见 getGaussianKernel

◆ DistanceTransformLabelTypes

枚举 cv::DistanceTransformLabelTypes

#include <opencv2/imgproc.hpp>

距离变换算法标志

枚举器
DIST_LABEL_CCOMP Python: cv.DIST_LABEL_CCOMP	src 中每个连接的零值分量（以及所有最接近该连接分量的非零像素）将被赋予相同的标签。
DIST_LABEL_PIXEL Python: cv.DIST_LABEL_PIXEL	每个零像素（以及所有最接近它的非零像素）都获得它自己的标签。

◆ DistanceTransformMasks

枚举 cv::DistanceTransformMasks

#include <opencv2/imgproc.hpp>

距离变换的掩码大小。

枚举器
DIST_MASK_3 Python: cv.DIST_MASK_3	mask=3
DIST_MASK_5 Python: cv.DIST_MASK_5	mask=5
DIST_MASK_PRECISE Python: cv.DIST_MASK_PRECISE

◆ DistanceTypes

枚举 cv::DistanceTypes

#include <opencv2/imgproc.hpp>

距离变换和M估计器的距离类型

另请参见: distanceTransform, fitLine

枚举器
DIST_USER Python: cv.DIST_USER	用户自定义距离。
DIST_L1 Python: cv.DIST_L1	距离 = \|x1-x2\| + \|y1-y2\|
DIST_L2 Python: cv.DIST_L2	简单的欧几里得距离
DIST_C Python: cv.DIST_C	距离 = max(\|x1-x2\|,\|y1-y2\|)
DIST_L12 Python: cv.DIST_L12	L1-L2度量：距离 = 2(sqrt(1+x*x/2) - 1))
DIST_FAIR Python: cv.DIST_FAIR	距离 = c^2(\|x\|/c-log(1+\|x\|/c)), c = 1.3998
DIST_WELSCH Python: cv.DIST_WELSCH	距离 = c^2/2(1-exp(-(x/c)^2)), c = 2.9846
DIST_HUBER Python: cv.DIST_HUBER	距离 = \|x\|<c ? x^2/2 : c(\|x\|-c/2), c=1.345

◆ FloodFillFlags

枚举 cv::FloodFillFlags

#include <opencv2/imgproc.hpp>

泛洪填充算法标志

枚举器
FLOODFILL_FIXED_RANGE Python: cv.FLOODFILL_FIXED_RANGE	如果设置，则考虑当前像素和种子像素之间的差异。否则，考虑相邻像素之间的差异（即，范围是浮动的）。
FLOODFILL_MASK_ONLY Python: cv.FLOODFILL_MASK_ONLY	如果设置，则函数不更改图像（忽略 newVal），并且仅使用上面描述的标志的 8-16 位中指定的数值填充掩码。此选项仅在具有掩码参数的函数变体中才有意义。

◆ GrabCutClasses

枚举 cv::GrabCutClasses

#include <opencv2/imgproc.hpp>

GrabCut 算法中像素的类别

枚举器
GC_BGD Python: cv.GC_BGD	明显的背景像素
GC_FGD Python: cv.GC_FGD	明显的前景（目标）像素
GC_PR_BGD Python: cv.GC_PR_BGD	可能的背景像素
GC_PR_FGD Python: cv.GC_PR_FGD	可能的前景像素

◆ GrabCutModes

枚举 cv::GrabCutModes

#include <opencv2/imgproc.hpp>

GrabCut 算法标志。

枚举器
GC_INIT_WITH_RECT Python: cv.GC_INIT_WITH_RECT	该函数使用提供的矩形初始化状态和掩码。之后，它运行算法的 iterCount 次迭代。
GC_INIT_WITH_MASK Python: cv.GC_INIT_WITH_MASK	该函数使用提供的掩码初始化状态。注意，GC_INIT_WITH_RECT 和 GC_INIT_WITH_MASK 可以组合使用。然后，ROI 外的所有像素都将自动初始化为 GC_BGD。
GC_EVAL Python: cv.GC_EVAL	该值表示算法应该继续运行。
GC_EVAL_FREEZE_MODEL Python: cv.GC_EVAL_FREEZE_MODEL	该值表示算法应该只运行 GrabCut 算法（单次迭代），并使用固定模型。

◆ ThresholdTypes

枚举 cv::ThresholdTypes

#include <opencv2/imgproc.hpp>

阈值操作的类型

枚举器
THRESH_BINARY Python: cv.THRESH_BINARY	\[\texttt{dst} (x,y) = \fork{\texttt{maxval}}{if \(\texttt{src}(x,y) > \texttt{thresh}\)}{0}{otherwise}\]
THRESH_BINARY_INV Python: cv.THRESH_BINARY_INV	\[\texttt{dst} (x,y) = \fork{0}{if \(\texttt{src}(x,y) > \texttt{thresh}\)}{\texttt{maxval}}{otherwise}\]
THRESH_TRUNC Python: cv.THRESH_TRUNC	\[\texttt{dst} (x,y) = \fork{\texttt{threshold}}{if \(\texttt{src}(x,y) > \texttt{thresh}\)}{\texttt{src}(x,y)}{otherwise}\]
THRESH_TOZERO Python: cv.THRESH_TOZERO	\[\texttt{dst} (x,y) = \fork{\texttt{src}(x,y)}{if \(\texttt{src}(x,y) > \texttt{thresh}\)}{0}{otherwise}\]
THRESH_TOZERO_INV Python: cv.THRESH_TOZERO_INV	\[\texttt{dst} (x,y) = \fork{0}{if \(\texttt{src}(x,y) > \texttt{thresh}\)}{\texttt{src}(x,y)}{otherwise}\]
THRESH_MASK Python: cv.THRESH_MASK
THRESH_OTSU Python: cv.THRESH_OTSU	标志，使用Otsu算法选择最佳阈值
THRESH_TRIANGLE Python: cv.THRESH_TRIANGLE	标志，使用Triangle算法选择最佳阈值

函数文档

◆ adaptiveThreshold()

void cv::adaptiveThreshold	(	输入数组	src,
		输出数组	dst,
		双精度浮点数	maxValue,
		整数	adaptiveMethod,
		整数	thresholdType,
		整数	blockSize,
		双精度浮点数	C )

Python
	cv.adaptiveThreshold(	src, maxValue, adaptiveMethod, thresholdType, blockSize, C[, dst]	) ->	dst

#include <opencv2/imgproc.hpp>

对数组应用自适应阈值。

该函数根据以下公式将灰度图像转换为二值图像

THRESH_BINARY
\[dst(x,y) = \fork{\texttt{maxValue}}{if \(src(x,y) > T(x,y)\)}{0}{otherwise}\]
THRESH_BINARY_INV
\[dst(x,y) = \fork{0}{if \(src(x,y) > T(x,y)\)}{\texttt{maxValue}}{otherwise}\]
其中\(T(x,y)\)是为每个像素单独计算的阈值（参见adaptiveMethod参数）。

该函数可以就地处理图像。

参数

src	源8位单通道图像。
dst	与src大小和类型相同的目标图像。
maxValue	分配给满足条件的像素的非零值
adaptiveMethod	要使用的自适应阈值算法，参见 AdaptiveThresholdTypes。使用 BORDER_REPLICATE \| BORDER_ISOLATED 处理边界。
thresholdType	阈值类型必须是 THRESH_BINARY 或 THRESH_BINARY_INV，参见 ThresholdTypes。
blockSize	用于计算像素阈值的像素邻域大小：3、5、7等。
C	从均值或加权均值中减去的常数（参见下面的详细信息）。通常为正数，但也可能为零或负数。

另请参见: threshold，blur，GaussianBlur

◆ blendLinear()

void cv::blendLinear	(	输入数组	src1,
		输入数组	src2,
		输入数组	weights1,
		输入数组	weights2,
		输出数组	dst )

Python
	cv.blendLinear(	src1, src2, weights1, weights2[, dst]	) ->	dst

#include <opencv2/imgproc.hpp>

执行两幅图像的线性混合

\[ \texttt{dst}(i,j) = \texttt{weights1}(i,j)*\texttt{src1}(i,j) + \texttt{weights2}(i,j)*\texttt{src2}(i,j) \]

参数

src1	其类型为 CV_8UC(n) 或 CV_32FC(n)，其中n为正整数。
src2	它与src1具有相同的类型和大小。
weights1	它具有CV_32FC1类型，并且与src1具有相同的大小。
weights2	它具有CV_32FC1类型，并且与src1具有相同的大小。
dst	如果它与src1的大小和类型不相同，则会创建它。

◆ distanceTransform() [1/2]

void cv::distanceTransform	(	输入数组	src,
		输出数组	dst,
		整数	distanceType,
		整数	maskSize,
		整数	dstType = CV_32F )

Python
	cv.distanceTransform(	src, distanceType, maskSize[, dst[, dstType]]	) ->	dst
	cv.distanceTransformWithLabels(	src, distanceType, maskSize[, dst[, labels[, labelType]]]	) ->	dst, labels

#include <opencv2/imgproc.hpp>

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

参数

src	8位单通道（二值）源图像。
dst	具有计算距离的输出图像。它是与src大小相同的8位或32位浮点单通道图像。
distanceType	距离类型，参见 DistanceTypes
maskSize	距离变换掩码的大小，参见 DistanceTransformMasks。在 DIST_L1 或 DIST_C 距离类型的情况下，参数强制为3，因为\(3\times 3\)掩码给出的结果与\(5\times 5\)或任何更大的孔径相同。
dstType	输出图像的类型。可以是CV_8U或CV_32F。CV_8U类型只能用于函数的第一个变体和distanceType == DIST_L1。

◆ distanceTransform() [2/2]

void cv::distanceTransform	(	输入数组	src,
		输出数组	dst,
		输出数组	labels,
		整数	distanceType,
		整数	maskSize,
		整数	labelType = DIST_LABEL_CCOMP )

Python
	cv.distanceTransform(	src, distanceType, maskSize[, dst[, dstType]]	) ->	dst
	cv.distanceTransformWithLabels(	src, distanceType, maskSize[, dst[, labels[, labelType]]]	) ->	dst, labels

#include <opencv2/imgproc.hpp>

计算源图像每个像素到最近的零像素的距离。

函数 cv::distanceTransform 计算从每个二值图像像素到最近的零像素的近似距离或精确距离。对于零图像像素，距离显然为零。

当maskSize == DIST_MASK_PRECISE 且 distanceType == DIST_L2 时，该函数运行在 [85] 中描述的算法。此算法使用TBB库进行并行化。

在其他情况下，使用算法[34]。这意味着对于一个像素，该函数查找其到最近的零像素的最短路径，该路径由基本位移组成：水平、垂直、对角线或马步（最后一个适用于\(5\times 5\)掩码）。总距离计算为这些基本距离的总和。由于距离函数应该是对称的，所有水平和垂直位移必须具有相同的成本（记为a），所有对角位移必须具有相同的成本（记为b），所有马步必须具有相同的成本（记为c）。对于DIST_C和DIST_L1类型，距离计算精确，而对于DIST_L2（欧几里得距离），距离只能用相对误差来计算（\(5\times 5\)掩码给出更精确的结果）。对于a、b和c，OpenCV使用原始论文中建议的值。

DIST_L1：a = 1, b = 2
DIST_L2
- 3 x 3：a=0.955, b=1.3693
- 5 x 5：a=1, b=1.4, c=2.1969
DIST_C：a = 1, b = 1

通常，对于快速、粗略的距离估计DIST_L2，使用\(3\times 3\)掩码。对于更精确的距离估计DIST_L2，使用\(5\times 5\)掩码或精确算法。请注意，精确算法和近似算法都对像素数量呈线性关系。

此函数的变体不仅计算每个像素\((x, y)\)的最小距离，而且还识别由零像素组成的最近连接组件(labelType==DIST_LABEL_CCOMP)或最近的零像素(labelType==DIST_LABEL_PIXEL)。组件/像素的索引存储在labels(x, y)中。当labelType==DIST_LABEL_CCOMP时，函数会自动查找输入图像中零像素的连通分量，并用不同的标签标记它们。当labelType==DIST_LABEL_PIXEL时，函数会扫描输入图像，并用不同的标签标记所有零像素。

在此模式下，复杂度仍然是线性的。也就是说，该函数提供了一种计算二值图像沃罗诺伊图的非常快速的方法。目前，第二种变体只能使用近似距离变换算法，即不支持maskSize=DIST_MASK_PRECISE。

参数

src	8位单通道（二值）源图像。
dst	具有计算距离的输出图像。它是一个与src大小相同的8位或32位浮点单通道图像。
labels	标签的输出二维数组（离散沃罗诺伊图）。它的类型为CV_32SC1，大小与src相同。
distanceType	距离类型，参见 DistanceTypes
maskSize	距离变换掩码的大小，参见DistanceTransformMasks。DIST_MASK_PRECISE不被此变体支持。对于DIST_L1或DIST_C距离类型，参数强制为3，因为\(3\times 3\)掩码的结果与\(5\times 5\)或任何更大的孔径相同。
labelType	要构建的标签数组的类型，参见DistanceTransformLabelTypes。

◆ floodFill() [1/2]

int cv::floodFill	(	InputOutputArray	image,
		InputOutputArray	mask,
		Point	seedPoint,
		Scalar	newVal,
		Rect *	rect = 0,
		Scalar	loDiff = Scalar(),
		Scalar	upDiff = Scalar(),
		整数	flags = 4 )

Python
	cv.floodFill(	image, mask, seedPoint, newVal[, loDiff[, upDiff[, flags]]]	) ->	retval, image, mask, rect

#include <opencv2/imgproc.hpp>

用给定的颜色填充连通区域。

函数cv::floodFill 使用指定颜色填充从种子点开始的连通分量。连通性由相邻像素的颜色/亮度接近程度决定。如果满足以下条件，则认为像素\((x,y)\)属于重新绘制的区域：

对于灰度图像和浮动范围
\[\texttt{src} (x',y')- \texttt{loDiff} \leq \texttt{src} (x,y) \leq \texttt{src} (x',y')+ \texttt{upDiff}\]
对于灰度图像和固定范围
\[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)- \texttt{loDiff} \leq \texttt{src} (x,y) \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)+ \texttt{upDiff}\]
对于彩色图像和浮动范围
\[\texttt{src} (x',y')_r- \texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq \texttt{src} (x',y')_r+ \texttt{upDiff} _r,\]

\[\texttt{src} (x',y')_g- \texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq \texttt{src} (x',y')_g+ \texttt{upDiff} _g\]
以及
\[\texttt{src} (x',y')_b- \texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq \texttt{src} (x',y')_b+ \texttt{upDiff} _b\]
对于彩色图像和固定范围
\[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_r- \texttt{loDiff} _r \leq \texttt{src} (x,y)_r \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_r+ \texttt{upDiff} _r,\]

\[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_g- \texttt{loDiff} _g \leq \texttt{src} (x,y)_g \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_g+ \texttt{upDiff} _g\]
以及
\[\texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_b- \texttt{loDiff} _b \leq \texttt{src} (x,y)_b \leq \texttt{src} ( \texttt{seedPoint} .x, \texttt{seedPoint} .y)_b+ \texttt{upDiff} _b\]

其中\(src(x',y')\)是已知属于该组件的一个像素邻居的值。也就是说，要添加到连通分量中，像素的颜色/亮度应该足够接近：

对于浮动范围，其已属于连通分量的其中一个邻居的颜色/亮度。
对于固定范围，种子点的颜色/亮度。

使用这些函数可以就地用指定颜色标记连通分量，或者构建掩码然后提取轮廓，或者将区域复制到另一幅图像等等。

参数

image	输入/输出 1 通道或 3 通道、8 位或浮点图像。除非在函数的第二个变体中设置了 FLOODFILL_MASK_ONLY 标志，否则函数会修改它。详情见下文。
mask	操作掩码，它应该是一个单通道 8 位图像，比图像宽 2 个像素，高 2 个像素。如果传入一个空的 Mat，它将自动创建。由于这是一个输入和输出参数，您必须负责初始化它。泛洪填充不能跨越输入掩码中的非零像素。例如，边缘检测器的输出可以用作掩码以停止在边缘处的填充。在输出中，对应于图像中填充像素的掩码中的像素被设置为 1 或设置为标志中指定的数值，如下所述。此外，该函数用 1 填充掩码的边界以简化内部处理。因此，可以在对函数的多次调用中使用相同的掩码，以确保填充区域不会重叠。
seedPoint	起始点。
newVal	重新绘制区域像素的新值。
loDiff	当前观察到的像素与其属于该分量的邻居之一或正在添加到该分量的种子像素之间的最大下亮度/颜色差。
upDiff	当前观察到的像素与其属于该分量的邻居之一或正在添加到该分量的种子像素之间的最大上亮度/颜色差。
rect	函数设置的可选输出参数，用于重新绘制区域的最小外接矩形。
flags	操作标志。前 8 位包含连接值。默认值为 4 表示仅考虑四个最近的邻居像素（共享一条边的像素）。连接值为 8 表示将考虑八个最近的邻居像素（共享一个角的像素）。接下来的 8 位（8-16）包含一个 1 到 255 之间的数值，用来填充掩码（默认值为 1）。例如，4 \| ( 255 << 8 ) 将考虑 4 个最近的邻居并用 255 的值填充掩码。以下附加选项占据更高的位，因此可以使用按位或 (\|) 与连接和掩码填充值进一步组合，参见 FloodFillFlags。

注意: 由于掩码大于填充图像，图像中的像素\((x, y)\)对应于掩码中的像素\((x+1, y+1)\)。

另请参见: findContours

◆ floodFill() [2/2]

int cv::floodFill	(	InputOutputArray	image,
		Point	seedPoint,
		Scalar	newVal,
		Rect *	rect = 0,
		Scalar	loDiff = Scalar(),
		Scalar	upDiff = Scalar(),
		整数	flags = 4 )

Python
	cv.floodFill(	image, mask, seedPoint, newVal[, loDiff[, upDiff[, flags]]]	) ->	retval, image, mask, rect

#include <opencv2/imgproc.hpp>

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

没有mask参数的变体

◆ integral() [1/3]

void cv::integral	(	输入数组	src,
		输出数组	sum,
		整数	sdepth = -1 )


cv.integral(	src[, sum[, sdepth]]	) ->	sum
cv.integral2(	src[, sum[, sqsum[, sdepth[, sqdepth]]]]	) ->	sum, sqsum
cv.integral3(	src[, sum[, sqsum[, tilted[, sdepth[, sqdepth]]]]]	) ->	sum, sqsum, tilted

#include <opencv2/imgproc.hpp>

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

◆ integral() [2/3]

void cv::integral	(	输入数组	src,
		输出数组	sum,
		输出数组	sqsum,
		整数	sdepth = -1,
		整数	sqdepth = -1 )


cv.integral(	src[, sum[, sdepth]]	) ->	sum
cv.integral2(	src[, sum[, sqsum[, sdepth[, sqdepth]]]]	) ->	sum, sqsum
cv.integral3(	src[, sum[, sqsum[, tilted[, sdepth[, sqdepth]]]]]	) ->	sum, sqsum, tilted

#include <opencv2/imgproc.hpp>

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

◆ integral() [3/3]

void cv::integral	(	输入数组	src,
		输出数组	sum,
		输出数组	sqsum,
		输出数组	tilted,
		整数	sdepth = -1,
		整数	sqdepth = -1 )


cv.integral(	src[, sum[, sdepth]]	) ->	sum
cv.integral2(	src[, sum[, sqsum[, sdepth[, sqdepth]]]]	) ->	sum, sqsum
cv.integral3(	src[, sum[, sqsum[, tilted[, sdepth[, sqdepth]]]]]	) ->	sum, sqsum, tilted

#include <opencv2/imgproc.hpp>

计算图像的积分。

该函数计算源图像的一个或多个积分图像，如下所示：

\[\texttt{sum} (X,Y) = \sum _{x<X,y<Y} \texttt{image} (x,y)\]

\[\texttt{sqsum} (X,Y) = \sum _{x<X,y<Y} \texttt{image} (x,y)^2\]

\[\texttt{tilted} (X,Y) = \sum _{y<Y,abs(x-X+1) \leq Y-y-1} \texttt{image} (x,y)\]

使用这些积分图像，您可以以恒定时间计算图像特定正向或旋转矩形区域上的总和、均值和标准差，例如：

\[\sum _{x_1 \leq x < x_2, \, y_1 \leq y < y_2} \texttt{image} (x,y) = \texttt{sum} (x_2,y_2)- \texttt{sum} (x_1,y_2)- \texttt{sum} (x_2,y_1)+ \texttt{sum} (x_1,y_1)\]

例如，它可以实现快速的模糊或具有可变窗口大小的快速块相关性。对于多通道图像，每个通道的总和将独立累积。

作为一个实际例子，下图显示了直角矩形 Rect(4,4,3,2) 和倾斜矩形 Rect(5,1,2,3) 的积分计算。显示了原始图像中选定的像素，以及积分图像 sum 和 tilted 中的相对像素。

积分计算示例

参数

src	输入图像为\(W \times H\), 8 位或浮点型 (32f 或 64f)。
sum	积分图像为\((W+1)\times (H+1)\), 32 位整数或浮点型 (32f 或 64f)。
sqsum	平方像素值的积分图像；它是\((W+1)\times (H+1)\)，双精度浮点型 (64f) 数组。
tilted	旋转 45 度的图像积分；它是\((W+1)\times (H+1)\) 数组，数据类型与 sum 相同。
sdepth	积分图像和倾斜积分图像的所需深度，CV_32S、CV_32F 或 CV_64F。
sqdepth	平方像素值积分图像的所需深度，CV_32F 或 CV_64F。

◆ threshold()

double cv::threshold	(	输入数组	src,
		输出数组	dst,
		双精度浮点数	thresh,
		双精度浮点数	maxval,
		整数	type )

Python
	cv.threshold(	src, thresh, maxval, type[, dst]	) ->	retval, dst

#include <opencv2/imgproc.hpp>

对每个数组元素应用固定级别的阈值。

该函数将固定级别的阈值应用于多通道数组。该函数通常用于从灰度图像中获取双层 (二进制) 图像（compare 也可用于此目的）或用于去除噪声，即过滤掉值过小或过大的像素。该函数支持几种类型的阈值处理。它们由 type 参数确定。

此外，特殊值 THRESH_OTSU 或 THRESH_TRIANGLE 可以与上述值之一组合。在这些情况下，函数使用 Otsu 或 Triangle 算法确定最佳阈值，并使用它代替指定的 thresh。

注意: 目前，Otsu 和 Triangle 方法仅适用于 8 位单通道图像。

参数

src	输入数组（多通道，8 位或 32 位浮点型）。
dst	与 src 大小、类型和通道数相同的输出数组。
thresh	阈值。
maxval	与 THRESH_BINARY 和 THRESH_BINARY_INV 阈值类型一起使用的最大值。
type	阈值类型（参见 ThresholdTypes）。

返回值: 如果使用 Otsu 或 Triangle 方法，则返回计算出的阈值。

另请参见: adaptiveThreshold，findContours，compare，min，max