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