OpenCV 4.13.0
开源计算机视觉库 (Open Source Computer Vision)
正在加载...
正在搜索...
未找到匹配项
枚举 | 函数
杂项图像变换
图像处理

详细说明

枚举

enum  cv::AdaptiveThresholdTypes {
  cv::ADAPTIVE_THRESH_MEAN_C = 0 ,
  cv::ADAPTIVE_THRESH_GAUSSIAN_C = 1
}
 
enum  cv::DistanceTransformLabelTypes {
  cv::DIST_LABEL_CCOMP = 0 ,
  cv::DIST_LABEL_PIXEL = 1
}
 距离变换算法标志 更多...
 
enum  cv::DistanceTransformMasks {
  cv::DIST_MASK_3 = 3 ,
  cv::DIST_MASK_5 = 5 ,
  cv::DIST_MASK_PRECISE = 0
}
 距离变换的掩码大小。 更多...
 
enum  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
}
 
enum  cv::FloodFillFlags {
  cv::FLOODFILL_FIXED_RANGE = 1 << 16 ,
  cv::FLOODFILL_MASK_ONLY = 1 << 17
}
 漫水填充算法标志 更多...
 
enum  cv::GrabCutClasses {
  cv::GC_BGD = 0 ,
  cv::GC_FGD = 1 ,
  cv::GC_PR_BGD = 2 ,
  cv::GC_PR_FGD = 3
}
 GrabCut 算法中像素的类别 更多...
 
enum  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 算法标志。 更多...
 
enum  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 相同，但带有一个可选掩码。
 

枚举类型文档 (Enumeration Type Documentation)

◆ AdaptiveThresholdTypes

枚举 cv::AdaptiveThresholdTypes

#include <opencv2/imgproc.hpp>

自适应阈值算法

另请参阅
adaptiveThreshold
枚举值 (Enumerator)
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>

距离变换算法标志

枚举值 (Enumerator)
DIST_LABEL_CCOMP 
Python: cv.DIST_LABEL_CCOMP

src 中每个零的连通分量（以及所有最接近该连通分量的非零像素）将被分配相同的标签

DIST_LABEL_PIXEL 
Python: cv.DIST_LABEL_PIXEL

每个零像素（以及所有最接近它的非零像素）都会获得自己的标签。

◆ DistanceTransformMasks

枚举 cv::DistanceTransformMasks

#include <opencv2/imgproc.hpp>

距离变换的掩码大小。

枚举值 (Enumerator)
DIST_MASK_3 
Python: cv.DIST_MASK_3

掩码=3

DIST_MASK_5 
Python: cv.DIST_MASK_5

掩码=5

DIST_MASK_PRECISE 
Python: cv.DIST_MASK_PRECISE

◆ DistanceTypes

枚举 cv::DistanceTypes

#include <opencv2/imgproc.hpp>

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

另请参阅
distanceTransform, fitLine
枚举值 (Enumerator)
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|

◆ FloodFillFlags

枚举 cv::FloodFillFlags

#include <opencv2/imgproc.hpp>

漫水填充算法标志

枚举值 (Enumerator)
FLOODFILL_FIXED_RANGE 
Python: cv.FLOODFILL_FIXED_RANGE

如果设置，则考虑当前像素与种子像素之间的差异。否则，考虑相邻像素之间的差异（即，范围是浮动的）。

FLOODFILL_MASK_ONLY 
Python: cv.FLOODFILL_MASK_ONLY

如果设置，函数不会改变图像（忽略 newVal），只用 flags 中位 8-16 中指定的值填充掩码，如上所述。此选项仅在具有掩码参数的函数变体中有意义。

◆ GrabCutClasses

枚举 cv::GrabCutClasses

#include <opencv2/imgproc.hpp>

GrabCut 算法中像素的类别

枚举值 (Enumerator)
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 算法标志。

枚举值 (Enumerator)
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>

阈值操作的类型

枚举值 (Enumerator)
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 算法选择最佳阈值

THRESH_DRYRUN 
Python: cv.THRESH_DRYRUN

标志，只计算阈值（对 OTSU/TRIANGLE 有用），但不实际执行阈值处理

函数文档 (Function Documentation)

◆ 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}}{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 ( 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如果 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>

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

参数
src8 位，单通道（二值）源图像。
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 ( 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 时，函数运行 [89] 中描述的算法。该算法使用 TBB 库进行并行化。

在其他情况下，使用算法 [36]。这意味着对于一个像素，函数找到到最近零像素的最短路径，该路径由基本移动组成：水平、垂直、对角线或骑士跳跃（后者适用于 \(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。

参数
src8 位，单通道（二值）源图像。
dst输出图像，包含计算出的距离。它是与 src 大小相同的 8 位或 32 位浮点型单通道图像。
labels输出标签的 2D 数组（离散 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 图像,
InputOutputArray mask,
点 (Point) seedPoint,
Scalar newVal,
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')\) 是已知属于该分量的一个像素邻居的值。也就是说，要添加到连通分量中，像素的颜色/亮度应足够接近

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

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

参数
图像输入/输出 1 或 3 通道、8 位或浮点图像。除非在函数的第二个变体中设置了 FLOODFILL_MASK_ONLY 标志，否则此图像将被函数修改。请参阅下面的详细信息。
mask操作掩码，应为单通道 8 位图像，比图像宽 2 像素，高 2 像素。如果传入空 Mat，它将自动创建。由于这是一个输入和输出参数，您必须负责对其进行初始化。漫水填充不能穿过输入掩码中的非零像素。例如，边缘检测器输出可以用作掩码，以在边缘处停止填充。在输出时，掩码中与图像中填充像素对应的像素被设置为 1 或设置为 flags 中指定的（如上所述）值。此外，函数用 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 图像,
点 (Point) seedPoint,
Scalar newVal,
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 最大值 (maxval),
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阈值。
最大值 (maxval)用于 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 最大值 (maxval),
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阈值。
最大值 (maxval)用于 THRESH_BINARY 和 THRESH_BINARY_INV 阈值类型的最大值。
type阈值类型（参见 ThresholdTypes）。
返回
如果使用了 Otsu 或 Triangle 方法，则为计算出的阈值。
另请参阅
threshold, adaptiveThreshold, findContours, compare, min, max
生成日期：2025年12月31日 星期三 07:26:22，基于 OpenCV，使用 doxygen 1.12.0