其他图像变换

详细描述

枚举
枚举	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 }
	距离变换算法标志 更多...
枚举	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 }
	漫水填充算法标志 更多...
枚举	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 ,   cv::THRESH_DRYRUN = 128 }

函数
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)
	对每个数组元素应用固定级别的阈值。
double	cv::thresholdWithMask (InputArray src, InputOutputArray dst, InputArray mask, double thresh, double maxval, int type)
	与 threshold 相同，但带有可选掩码。

枚举类型文档

AdaptiveThresholdTypes

枚举 cv::AdaptiveThresholdTypes

#include <opencv2/imgproc.hpp>

自适应阈值算法

另请参见

adaptiveThreshold

枚举器
ADAPTIVE_THRESH_MEAN_C  Python: cv.ADAPTIVE_THRESH_MEAN_C	阈值 \(T(x,y)\) 是 \((x, y)\) 的 \(\texttt{blockSize} \times \texttt{blockSize}\) 邻域的平均值减去 C
ADAPTIVE_THRESH_GAUSSIAN_C  Python: cv.ADAPTIVE_THRESH_GAUSSIAN_C	阈值 \(T(x, y)\) 是 \((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	distance = |x1-x2| + |y1-y2|
DIST_L2  Python: cv.DIST_L2	the simple euclidean distance
DIST_C  Python: cv.DIST_C	distance = max(|x1-x2|,|y1-y2|)
DIST_L12  Python: cv.DIST_L12	L1-L2 度量: distance = 2(sqrt(1+x*x/2) - 1))
DIST_FAIR  Python: cv.DIST_FAIR	distance = c^2(|x|/c-log(1+|x|/c)), c = 1.3998
DIST_WELSCH  Python: cv.DIST_WELSCH	distance = c^2/2(1-exp(-(x/c)^2)), c = 2.9846
DIST_HUBER  Python: cv.DIST_HUBER	distance = |x|

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}}{如果 \(\texttt{src}(x,y) > \texttt{thresh}\)}{0}{否则}\]
THRESH_BINARY_INV  Python: cv.THRESH_BINARY_INV	\[\texttt{dst} (x,y) = \fork{0}{如果 \(\texttt{src}(x,y) > \texttt{thresh}\)}{\texttt{maxval}}{否则}\]
THRESH_TRUNC  Python: cv.THRESH_TRUNC	\[\texttt{dst} (x,y) = \fork{\texttt{threshold}}{如果 \(\texttt{src}(x,y) > \texttt{thresh}\)}{\texttt{src}(x,y)}{否则}\]
THRESH_TOZERO  Python: cv.THRESH_TOZERO	\[\texttt{dst} (x,y) = \fork{\texttt{src}(x,y)}{如果 \(\texttt{src}(x,y) > \texttt{thresh}\)}{0}{否则}\]
THRESH_TOZERO_INV  Python: cv.THRESH_TOZERO_INV	\[\texttt{dst} (x,y) = \fork{0}{如果 \(\texttt{src}(x,y) > \texttt{thresh}\)}{\texttt{src}(x,y)}{否则}\]
THRESH_MASK  Python: cv.THRESH_MASK
THRESH_OTSU  Python: cv.THRESH_OTSU	标志，使用 Otsu 算法选择最优阈值
THRESH_TRIANGLE  Python: cv.THRESH_TRIANGLE	标志，使用 Triangle 算法选择最优阈值
THRESH_DRYRUN  Python: cv.THRESH_DRYRUN	标志，仅计算阈值（对 OTSU/TRIANGLE 有用），但不实际运行阈值化

函数文档

adaptiveThreshold()

void cv::adaptiveThreshold	(	InputArray	src,
		OutputArray	dst,
		double	maxValue,
		int	adaptiveMethod,
		int	thresholdType,
		int	blockSize,
		double	C )

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

#include <opencv2/imgproc.hpp>

对数组应用自适应阈值。

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

• THRESH_BINARY

  \[dst(x,y) = \fork{\texttt{maxValue}}{如果 \(src(x,y) > T(x,y)\)}{0}{否则}\]

• THRESH_BINARY_INV

  \[dst(x,y) = \fork{0}{如果 \(src(x,y) > T(x,y)\)}{\texttt{maxValue}}{否则}\]

  其中 \(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	(	InputArray	src1,
		InputArray	src2,
		InputArray	weights1,
		InputArray	weights2,
		OutputArray	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	(	InputArray	src,
		OutputArray	dst,
		int	distanceType,
		int	maskSize,
		int	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	带有计算距离的输出图像。它是一个 8 位或 32 位浮点单通道图像，与 src 大小相同。
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	(	InputArray	src,
		OutputArray	dst,
		OutputArray	labels,
		int	distanceType,
		int	maskSize,
		int	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 时，函数运行 [87] 中描述的算法。此算法使用 TBB 库并行化。

在其他情况下，使用算法 [35]。这意味着对于一个像素，函数会找到到最近零像素的最短路径，该路径由基本位移组成：水平、垂直、对角线或骑士步（最后一种可用于 \(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 时，函数扫描输入图像并用不同的标签标记所有零像素。

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

参数

src	8 位，单通道（二进制）源图像。
dst	带有计算距离的输出图像。它是一个 8 位或 32 位浮点单通道图像，与 src 大小相同。
labels	标签的二维输出数组（离散 Voronoi 图）。它具有 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	用于涂抹斑点的视差值,
		Rect *	rect = 0,
		Scalar	loDiff = Scalar(),
		Scalar	upDiff = Scalar(),
		int	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 或设置为 flags 中指定的值，如下所述。此外，函数会将掩码的边界填充为 1，以简化内部处理。因此，可以在多次调用函数时使用相同的掩码，以确保填充区域不重叠。
seedPoint	起始点。
用于涂抹斑点的视差值	重绘域像素的新值。
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	用于涂抹斑点的视差值,
		Rect *	rect = 0,
		Scalar	loDiff = Scalar(),
		Scalar	upDiff = Scalar(),
		int	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	(	InputArray	src,
		OutputArray	sum,
		int	sdepth = -1 )

Python
	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	(	InputArray	src,
		OutputArray	sum,
		OutputArray	sqsum,
		int	sdepth = -1,
		int	sqdepth = -1 )

Python
	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	(	InputArray	src,
		OutputArray	sum,
		OutputArray	sqsum,
		OutputArray	tilted,
		int	sdepth = -1,
		int	sqdepth = -1 )

Python
	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	(	InputArray	src,
		OutputArray	dst,
		double	thresh,
		double	最大值,
		int	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 方法仅对 CV_8UC1 和 CV_16UC1 图像实现，而 Triangle 方法仅对 CV_8UC1 图像实现。

参数

src	输入数组（多通道，CV_8U、CV_16S、CV_16U、CV_32F 或 CV_64F）。
dst	与 src 具有相同大小、类型和通道数的输出数组。
thresh	阈值。
最大值	与 THRESH_BINARY 和 THRESH_BINARY_INV 阈值类型一起使用的最大值。
type	阈值类型（参见 ThresholdTypes）。

返回

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

另请参见

thresholdWithMask, adaptiveThreshold, findContours, compare, min, max

thresholdWithMask()

double cv::thresholdWithMask	(	InputArray	src,
		InputOutputArray	dst,
		InputArray	mask,
		double	thresh,
		double	最大值,
		int	type )

Python
	cv.thresholdWithMask(	src, dst, mask, thresh, maxval, type	) ->	retval, dst

#include <opencv2/imgproc.hpp>

与 threshold 相同，但带有可选掩码。

注意

如果掩码为空，thresholdWithMask 等效于 threshold。如果掩码不为空，dst 必须与 src 具有相同的大小和类型，以便离群像素保持不变

参数

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

返回

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

另请参见

threshold, adaptiveThreshold, findContours, compare, min, max