影像濾波

詳細描述

本節描述的函式和類用於對二維影像（表示為 Mat）執行各種線性或非線性濾波操作。這意味著對於源影像中的每個畫素位置 \((x,y)\)（通常是矩形），會考慮其鄰域並用於計算響應。線上性濾波器的情況下，響應是畫素值的加權和。在形態學操作的情況下，響應是最小值或最大值，等等。計算出的響應儲存在目標影像的相同位置 \((x,y)\) 處。這意味著輸出影像將與輸入影像具有相同的大小。通常，函式支援多通道陣列，在這種情況下，每個通道都獨立處理。因此，輸出影像也將具有與輸入影像相同的通道數。

本節描述的函式和類的另一個共同特點是，與簡單的算術函式不同，它們需要外推一些不存在的畫素的值。例如，如果您想使用高斯 \(3 \times 3\) 濾波器平滑影像，那麼在處理每行的最左側畫素時，您需要它們左側的畫素，即影像外部的畫素。您可以讓這些畫素與最左側的影像畫素相同（“複製邊界”外推法），或者假設所有不存在的畫素都為零（“常數邊界”外推法），等等。OpenCV 允許您指定外推法。有關詳細資訊，請參閱 BorderTypes

深度組合

輸入深度 (src.depth())	輸出深度 (ddepth)
Definition interface.h:74	-1/CV_16S/CV_32F/CV_64F
CV_16U/CV_16S	-1/CV_32F/CV_64F
CV_32F	-1/CV_32F
CV_64F	-1/CV_64F

注意

當 ddepth=-1 時，輸出影像將與源影像具有相同的深度。

如果您需要雙精度浮點精度並使用單精度浮點輸入資料（CV_32F 輸入和 CV_64F 輸出深度組合），您可以使用 Mat::convertTo 將輸入資料轉換為所需的精度。

列舉
列舉	cv::MorphShapes {   cv::MORPH_RECT = 0 ,   cv::MORPH_CROSS = 1 ,   cv::MORPH_ELLIPSE = 2 ,   cv::MORPH_DIAMOND = 3 }
	結構元素的形狀 更多...
列舉	cv::MorphTypes {   cv::MORPH_ERODE = 0 ,   cv::MORPH_DILATE = 1 ,   cv::MORPH_OPEN = 2 ,   cv::MORPH_CLOSE = 3 ,   cv::MORPH_GRADIENT = 4 ,   cv::MORPH_TOPHAT = 5 ,   cv::MORPH_BLACKHAT = 6 ,   cv::MORPH_HITMISS = 7 }
	形態學操作型別 更多...
列舉	cv::SpecialFilter { cv::FILTER_SCHARR = -1 }

函式
void	cv::bilateralFilter (InputArray src, OutputArray dst, int d, double sigmaColor, double sigmaSpace, int borderType=BORDER_DEFAULT)
	對影像應用雙邊濾波。
void	cv::blur (InputArray src, OutputArray dst, Size ksize, Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT)
	使用歸一化盒式濾波器模糊影像。
void	cv::boxFilter (InputArray src, OutputArray dst, int ddepth, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT)
	使用方框濾波器模糊影像。
void	cv::buildPyramid (InputArray src, OutputArrayOfArrays dst, int maxlevel, int borderType=BORDER_DEFAULT)
	為影像構建高斯金字塔。
void	cv::dilate (InputArray src, OutputArray dst, InputArray kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue())
	使用特定的結構元素對影像進行膨脹。
void	cv::erode (InputArray src, OutputArray dst, InputArray kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue())
	使用特定的結構元素對影像進行腐蝕。
void	cv::filter2D (InputArray src, OutputArray dst, int ddepth, InputArray kernel, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT)
	使用核函式對影像進行卷積。
void	cv::GaussianBlur (InputArray src, OutputArray dst, Size ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT, AlgorithmHint hint=cv::ALGO_HINT_DEFAULT)
	使用高斯濾波器模糊影像。
void	cv::getDerivKernels (OutputArray kx, OutputArray ky, int dx, int dy, int ksize, bool normalize=false, int ktype=CV_32F)
	返回用於計算空間影像導數的濾波器係數。
Mat	cv::getGaborKernel (Size ksize, double sigma, double theta, double lambd, double gamma, double psi=CV_PI *0.5, int ktype=CV_64F)
	返回 Gabor 濾波器係數。
Mat	cv::getGaussianKernel (int ksize, double sigma, int ktype=CV_64F)
	返回高斯濾波器係數。
Mat	cv::getStructuringElement (int shape, Size ksize, Point anchor=Point(-1,-1))
	返回用於形態學操作的指定大小和形狀的結構元素。
void	cv::Laplacian (InputArray src, OutputArray dst, int ddepth, int ksize=1, double scale=1, double delta=0, int borderType=BORDER_DEFAULT)
	計算影像的拉普拉斯運算元。
void	cv::medianBlur (InputArray src, OutputArray dst, int ksize)
	使用中值濾波器模糊影像。
static Scalar	cv::morphologyDefaultBorderValue ()
	返回侵蝕和膨脹的“魔術”邊界值。對於膨脹，它會自動轉換為 Scalar::all(-DBL_MAX)。
void	cv::morphologyEx (InputArray src, OutputArray dst, int op, InputArray kernel, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue())
	執行高階形態學變換。
void	cv::pyrDown (InputArray src, OutputArray dst, const Size &dstsize=Size(), int borderType=BORDER_DEFAULT)
	模糊影像並對其進行下采樣。
void	cv::pyrMeanShiftFiltering (InputArray src, OutputArray dst, double sp, double sr, int maxLevel=1, TermCriteria termcrit=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 5, 1))
	執行影像均值漂移分割的初始步驟。
void	cv::pyrUp (InputArray src, OutputArray dst, const Size &dstsize=Size(), int borderType=BORDER_DEFAULT)
	對影像進行上取樣然後進行模糊。
void	cv::Scharr (InputArray src, OutputArray dst, int ddepth, int dx, int dy, double scale=1, double delta=0, int borderType=BORDER_DEFAULT)
	使用 Scharr 運算子計算影像的第一階 x 或 y 導數。
void	cv::sepFilter2D (InputArray src, OutputArray dst, int ddepth, InputArray kernelX, InputArray kernelY, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT)
	對影像應用可分離線性濾波器。
void	cv::Sobel (InputArray src, OutputArray dst, int ddepth, int dx, int dy, int ksize=3, double scale=1, double delta=0, int borderType=BORDER_DEFAULT)
	使用擴充套件的 Sobel 運算子計算影像的一階、二階、三階或混合導數。
void	cv::spatialGradient (InputArray src, OutputArray dx, OutputArray dy, int ksize=3, int borderType=BORDER_DEFAULT)
	使用 Sobel 運算子計算影像在 x 和 y 方向上的第一階導數。
void	cv::sqrBoxFilter (InputArray src, OutputArray dst, int ddepth, Size ksize, Point anchor=Point(-1, -1), bool normalize=true, int borderType=BORDER_DEFAULT)
	計算覆蓋濾波器的畫素值的歸一化平方和。
void	cv::stackBlur (InputArray src, OutputArray dst, Size ksize)
	使用stackBlur對影像進行模糊處理。

列舉型別文件

MorphShapes

enum cv::MorphShapes

#include <opencv2/imgproc.hpp>

結構元素的形狀

列舉器
MORPH_RECT  Python: cv.MORPH_RECT	矩形結構元素 \[E_{ij}=1\]
MORPH_CROSS  Python: cv.MORPH_CROSS	十字形結構元素 \[E_{ij} = \begin{cases} 1 & \texttt{if } {i=\texttt{anchor.y } {or } {j=\texttt{anchor.x}}} \\0 & \texttt{otherwise} \end{cases}\]
MORPH_ELLIPSE  Python: cv.MORPH_ELLIPSE	進入矩形 Rect(0, 0, esize.width, esize.height) 橢圓形結構元素，即內切的實心橢圓
MORPH_DIAMOND  Python: cv.MORPH_DIAMOND	由曼哈頓距離定義的菱形結構元素

MorphTypes

enum cv::MorphTypes

#include <opencv2/imgproc.hpp>

形態學操作型別

列舉器
MORPH_ERODE  Python: cv.MORPH_ERODE	參見 erode
MORPH_DILATE  Python: cv.MORPH_DILATE	參見 dilate
MORPH_OPEN  Python: cv.MORPH_OPEN	開運算 \[\texttt{dst} = \mathrm{open} ( \texttt{src} , \texttt{element} )= \mathrm{dilate} ( \mathrm{erode} ( \texttt{src} , \texttt{element} ))\]
MORPH_CLOSE  Python: cv.MORPH_CLOSE	閉運算 \[\texttt{dst} = \mathrm{close} ( \texttt{src} , \texttt{element} )= \mathrm{erode} ( \mathrm{dilate} ( \texttt{src} , \texttt{element} ))\]
MORPH_GRADIENT  Python: cv.MORPH_GRADIENT	形態學梯度 \[\texttt{dst} = \mathrm{morph\_grad} ( \texttt{src} , \texttt{element} )= \mathrm{dilate} ( \texttt{src} , \texttt{element} )- \mathrm{erode} ( \texttt{src} , \texttt{element} )\]
MORPH_TOPHAT  Python: cv.MORPH_TOPHAT	“頂帽” \[\texttt{dst} = \mathrm{tophat} ( \texttt{src} , \texttt{element} )= \texttt{src} - \mathrm{open} ( \texttt{src} , \texttt{element} )\]
MORPH_BLACKHAT  Python: cv.MORPH_BLACKHAT	“黑帽” \[\texttt{dst} = \mathrm{blackhat} ( \texttt{src} , \texttt{element} )= \mathrm{close} ( \texttt{src} , \texttt{element} )- \texttt{src}\]
MORPH_HITMISS  Python: cv.MORPH_HITMISS	“擊中或錯過” - 僅支援 CV_8UC1 二值影像。教程可在文件中找到

SpecialFilter

enum cv::SpecialFilter

#include <opencv2/imgproc.hpp>

列舉器
FILTER_SCHARR  Python: cv.FILTER_SCHARR

函式文件

bilateralFilter()

void cv::bilateralFilter	(	InputArray	src,
		OutputArray	dst,
		int	d,
		double	sigmaColor,
		double	sigmaSpace,
		int	borderType = BORDER_DEFAULT )

Python
	cv.bilateralFilter(	src, d, sigmaColor, sigmaSpace[, dst[, borderType]]	) ->	dst

#include <opencv2/imgproc.hpp>

對影像應用雙邊濾波。

該函式對輸入影像應用雙邊濾波，如 https://homepages.inf.ed.ac.uk/rbf/CVonline/LOCAL_COPIES/MANDUCHI1/Bilateral_Filtering.html 中所述。雙邊濾波可以很好地減少不必要的噪聲，同時保持邊緣相當銳利。然而，與大多數濾波器相比，它非常慢。

Sigma 值：為簡單起見，您可以將兩個 sigma 值設定為相同。如果它們很小（< 10），濾波器效果不明顯；如果它們很大（> 150），它們將產生非常強的效果，使影像看起來像“卡通”。

濾波器大小：大型濾波器 (d > 5) 非常慢，因此建議即時應用使用 d=5，而需要大量噪聲濾波的離線應用可能使用 d=9。

此濾波器不支援原地操作。

引數

src	Source 8-bit or floating-point, 1-channel or 3-channel image.
dst	與 src 具有相同大小和型別的目標影像。
d	濾波期間使用的每個畫素鄰域的直徑。如果它非正，則從 sigmaSpace 計算。
sigmaColor	顏色空間中的濾波器 sigma。引數值越大，表示畫素鄰域內（參見 sigmaSpace）更遠的顏色將被混合在一起，從而導致更大面積的半等色區域。
sigmaSpace	座標空間中的濾波器 sigma。引數值越大，表示只要顏色足夠接近（參見 sigmaColor），更遠的畫素也會相互影響。當 d>0 時，它指定鄰域大小，而與 sigmaSpace 無關。否則，d 與 sigmaSpace 成比例。
borderType	用於外推影像外部畫素的邊界模式，參見 BorderTypes

blur()

void cv::blur	(	InputArray	src,
		OutputArray	dst,
		Size	ksize,
		Point	anchor = Point(-1,-1),
		int	borderType = BORDER_DEFAULT )

Python
	cv.blur(	src, ksize[, dst[, anchor[, borderType]]]	) ->	dst

#include <opencv2/imgproc.hpp>

使用歸一化盒式濾波器模糊影像。

該函式使用以下核平滑影像

\[\texttt{K} = \frac{1}{\texttt{ksize.width*ksize.height}} \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \end{bmatrix}\]

呼叫 blur(src, dst, ksize, anchor, borderType) 等效於 boxFilter(src, dst, src.type(), ksize, anchor, true, borderType)。

引數

src	輸入影像；它可以有任意數量的通道，這些通道獨立處理，但深度應為 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F。
dst	與 src 相同大小和型別的輸出影像。
ksize	模糊核心大小。
anchor	錨點；預設值 Point(-1,-1) 表示錨點位於核中心。
borderType	用於外推影像外部畫素的邊界模式，參見 BorderTypes。不支援 BORDER_WRAP。

另請參見

boxFilter, bilateralFilter, GaussianBlur, medianBlur

boxFilter()

void cv::boxFilter	(	InputArray	src,
		OutputArray	dst,
		int	ddepth,
		Size	ksize,
		Point	anchor = Point(-1,-1),
		bool	normalize = true,
		int	borderType = BORDER_DEFAULT )

Python
	cv.boxFilter(	src, ddepth, ksize[, dst[, anchor[, normalize[, borderType]]]]	) ->	dst

#include <opencv2/imgproc.hpp>

使用方框濾波器模糊影像。

該函式使用以下核平滑影像

\[\texttt{K} = \alpha \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \end{bmatrix}\]

其中

\[\alpha = \begin{cases} \frac{1}{\texttt{ksize.width*ksize.height}} & \texttt{when } \texttt{normalize=true} \\1 & \texttt{otherwise}\end{cases}\]

未歸一化的箱式濾波器對於計算每個畫素鄰域上的各種積分特性很有用，例如影像導數的協方差矩陣（用於稠密光流演算法等）。如果您需要計算可變大小視窗上的畫素和，請使用 integral。

引數

src	輸入影像。
dst	與 src 相同大小和型別的輸出影像。
ddepth	輸出影像深度（-1 表示使用 src.depth()）。
ksize	模糊核心大小。
anchor	錨點；預設值 Point(-1,-1) 表示錨點位於核中心。
normalize	標誌，指定核心是否按其面積歸一化。
borderType	用於外推影像外部畫素的邊界模式，參見 BorderTypes。不支援 BORDER_WRAP。

另請參見

blur, bilateralFilter, GaussianBlur, medianBlur, integral

buildPyramid()

void cv::buildPyramid	(	InputArray	src,
		OutputArrayOfArrays	dst,
		int	maxlevel,
		int	borderType = BORDER_DEFAULT )

#include <opencv2/imgproc.hpp>

為影像構建高斯金字塔。

該函式透過從 dst[0]==src 開始，遞迴地將 pyrDown 應用於先前構建的金字塔層，從而構造影像向量並構建高斯金字塔。

引數

src	源影像。支援的型別列表請檢視 pyrDown。
dst	maxlevel+1 個影像的目標向量，與 src 型別相同。dst[0] 將與 src 相同。dst[1] 是下一個金字塔層，是平滑並縮小尺寸的 src，依此類推。
maxlevel	最後一個（最小的）金字塔層的0-based索引。必須是非負數。
borderType	畫素外推法，參見 BorderTypes（不支援 BORDER_CONSTANT）

dilate()

void cv::dilate	(	InputArray	src,
		OutputArray	dst,
		InputArray	kernel,
		Point	anchor = Point(-1,-1),
		int	iterations = 1,
		int	borderType = BORDER_CONSTANT,
		const Scalar &	borderValue = morphologyDefaultBorderValue() )

Python
	cv.dilate(	src, kernel[, dst[, anchor[, iterations[, borderType[, borderValue]]]]]	) ->	dst

#include <opencv2/imgproc.hpp>

使用特定的結構元素對影像進行膨脹。

該函式使用指定的結構元素對源影像進行膨脹，該結構元素確定了最大值所在的畫素鄰域的形狀

\[\texttt{dst} (x,y) = \max _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\]

該函式支援原地模式。膨脹可以應用多次（iterations）。對於多通道影像，每個通道獨立處理。

引數

src	輸入影像；通道數可以是任意的，但深度應為 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F。
dst	與 src 相同大小和型別的輸出影像。
kernel	用於膨脹的結構元素；如果 element=Mat()，則使用 3 x 3 矩形結構元素。核可以使用 getStructuringElement 建立。
anchor	錨點在元素內的位置；預設值 (-1, -1) 表示錨點位於元素中心。
iterations	應用膨脹的次數。
borderType	畫素外推法，參見 BorderTypes。不支援 BORDER_WRAP。
borderValue	常量邊界情況下的邊界值

另請參見

erode, morphologyEx, getStructuringElement

erode()

void cv::erode	(	InputArray	src,
		OutputArray	dst,
		InputArray	kernel,
		Point	anchor = Point(-1,-1),
		int	iterations = 1,
		int	borderType = BORDER_CONSTANT,
		const Scalar &	borderValue = morphologyDefaultBorderValue() )

Python
	cv.erode(	src, kernel[, dst[, anchor[, iterations[, borderType[, borderValue]]]]]	) ->	dst

#include <opencv2/imgproc.hpp>

使用特定的結構元素對影像進行腐蝕。

該函式使用指定的結構元素對源影像進行腐蝕，該結構元素確定了最小值所在的畫素鄰域的形狀

\[\texttt{dst} (x,y) = \min _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\]

該函式支援原地模式。腐蝕可以應用多次（iterations）。對於多通道影像，每個通道獨立處理。

引數

src	輸入影像；通道數可以是任意的，但深度應為 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F。
dst	與 src 相同大小和型別的輸出影像。
kernel	用於腐蝕的結構元素；如果 element=Mat()，則使用 3 x 3 矩形結構元素。核可以使用 getStructuringElement 建立。
anchor	錨點在元素內的位置；預設值 (-1, -1) 表示錨點位於元素中心。
iterations	應用腐蝕的次數。
borderType	畫素外推法，參見 BorderTypes。不支援 BORDER_WRAP。
borderValue	常量邊界情況下的邊界值

另請參見

dilate, morphologyEx, getStructuringElement

filter2D()

void cv::filter2D	(	InputArray	src,
		OutputArray	dst,
		int	ddepth,
		InputArray	kernel,
		Point	anchor = Point(-1,-1),
		double	delta = 0,
		int	borderType = BORDER_DEFAULT )

Python
	cv.filter2D(	src, ddepth, kernel[, dst[, anchor[, delta[, borderType]]]]	) ->	dst

#include <opencv2/imgproc.hpp>

使用核函式對影像進行卷積。

該函式對影像應用任意線性濾波器。支援原地操作。當孔徑部分在影像外部時，函式根據指定的邊界模式對外部畫素值進行插值。

該函式實際上計算的是相關性，而不是卷積

\[\texttt{dst} (x,y) = \sum _{ \substack{0\leq x' < \texttt{kernel.cols}\\{0\leq y' < \texttt{kernel.rows}}}} \texttt{kernel} (x',y')* \texttt{src} (x+x'- \texttt{anchor.x} ,y+y'- \texttt{anchor.y} )\]

也就是說，核心不會圍繞錨點進行映象。如果需要真正的卷積，請使用 flip 翻轉核心，並將新錨點設定為 (kernel.cols - anchor.x - 1, kernel.rows - anchor.y - 1)。

該函式在核心足夠大（約 11 x 11 或更大）時使用基於 DFT 的演算法，對於小核心則使用直接演算法。

引數

src	輸入影像。
dst	與 src 具有相同大小和通道數的輸出影像。
ddepth	目標影像所需的深度，參見 組合
kernel	卷積核（或者說是相關核），一個單通道浮點矩陣；如果您想對不同的通道應用不同的核，請使用 split 將影像分成單獨的顏色平面並分別處理它們。
anchor	核心的錨點，表示濾波點在核心中的相對位置；錨點應位於核心內；預設值 (-1,-1) 表示錨點位於核心中心。
delta	在將濾波後的畫素儲存到 dst 之前，新增到其中的可選值。
borderType	畫素外推法，參見 BorderTypes。不支援 BORDER_WRAP。

另請參見

sepFilter2D, dft, matchTemplate

GaussianBlur()

void cv::GaussianBlur	(	InputArray	src,
		OutputArray	dst,
		Size	ksize,
		double	sigmaX,
		double	sigmaY = 0,
		int	borderType = BORDER_DEFAULT,
		AlgorithmHint	hint = cv::ALGO_HINT_DEFAULT )

Python
	cv.GaussianBlur(	src, ksize, sigmaX[, dst[, sigmaY[, borderType[, hint]]]]	) ->	dst

#include <opencv2/imgproc.hpp>

使用高斯濾波器模糊影像。

該函式使用指定的 Gaussian 核對源影像進行卷積。支援原地濾波。

引數

src	輸入影像；影像可以有任意數量的通道，這些通道獨立處理，但深度應為 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F。
dst	與 src 相同大小和型別的輸出影像。
ksize	高斯核大小。ksize.width 和 ksize.height 可以不同，但它們都必須是正奇數。或者，它們可以為零，然後從 sigma 計算。
sigmaX	X 方向上的高斯核心標準差。
sigmaY	Y方向的高斯核標準差；如果 sigmaY 為零，則將其設定為等於 sigmaX；如果兩個 sigma 都為零，則分別從 ksize.width 和 ksize.height 計算（詳見 getGaussianKernel）；為了完全控制結果，無論未來對這些語義的可能修改如何，建議指定 ksize、sigmaX 和 sigmaY 的所有值。
borderType	畫素外推法，參見 BorderTypes。不支援 BORDER_WRAP。
hint	實現修改標誌。參見 AlgorithmHint

另請參見

sepFilter2D, filter2D, blur, boxFilter, bilateralFilter, medianBlur

getDerivKernels()

void cv::getDerivKernels	(	OutputArray	kx,
		OutputArray	ky,
		int	dx,
		int	dy,
		int	ksize,
		bool	normalize = false,
		int	ktype = CV_32F )

Python
	cv.getDerivKernels(	dx, dy, ksize[, kx[, ky[, normalize[, ktype]]]]	) ->	kx, ky

#include <opencv2/imgproc.hpp>

返回用於計算空間影像導數的濾波器係數。

該函式計算並返回空間影像導數的濾波器係數。當 ksize=FILTER_SCHARR 時，生成 Scharr \(3 \times 3\) 核（參見 Scharr）。否則，生成 Sobel 核（參見 Sobel）。這些濾波器通常傳遞給 sepFilter2D 或

引數

kx	行濾波器係數的輸出矩陣。其型別為 ktype。
ky	列濾波器係數的輸出矩陣。其型別為 ktype。
dx	關於 x 的導數階數。
dy	關於 y 的導數階數。
ksize	孔徑大小。可以是 FILTER_SCHARR、1、3、5 或 7。
normalize	指示是否歸一化（縮小）濾波器係數的標誌。理論上，係數應具有分母 \(=2^{ksize*2-dx-dy-2}\)。如果您要對浮點影像進行濾波，則很可能會使用歸一化核心。但如果您計算 8 點陣圖像的導數，將結果儲存在 16 點陣圖像中，並希望保留所有小數位，您可能希望將 normalize=false 設定為 false。
ktype	濾波器係數型別。可以是 CV_32f 或 CV_64F。

getGaborKernel()

Mat cv::getGaborKernel	(	Size	ksize,
		double	sigma,
		double	theta,
		double	lambd,
		double	gamma,
		double	psi = CV_PI *0.5,
		int	ktype = CV_64F )

Python
	cv.getGaborKernel(	ksize, sigma, theta, lambd, gamma[, psi[, ktype]]	) ->	retval

#include <opencv2/imgproc.hpp>

返回 Gabor 濾波器係數。

有關 Gabor 濾波器方程和引數的更多詳細資訊，請參閱：Gabor Filter。

引數

ksize	返回的濾波器大小。
sigma	高斯包絡的標準差。
theta	Gabor 函式平行條紋法線的方向。
lambd	正弦因子的波長。
gamma	空間長寬比。
psi	相位偏移。
ktype	濾波器係數型別。可以是 CV_32F 或 CV_64F。

getGaussianKernel()

Mat cv::getGaussianKernel	(	int	ksize,
		double	sigma,
		int	ktype = CV_64F )

Python
	cv.getGaussianKernel(	ksize, sigma[, ktype]	) ->	retval

#include <opencv2/imgproc.hpp>

返回高斯濾波器係數。

該函式計算並返回高斯濾波器係數的 \(\texttt{ksize} \times 1\) 矩陣

\[G_i= \alpha *e^{-(i-( \texttt{ksize} -1)/2)^2/(2* \texttt{sigma}^2)},\]

其中 \(i=0..\texttt{ksize}-1\) 且 \(\alpha\) 是選擇的比例因子，使得 \(\sum_i G_i=1\)。

兩個這樣的生成核心可以傳遞給 sepFilter2D。這些函式會自動識別平滑核心（權重和為 1 的對稱核心）並相應地處理它們。您也可以使用更高級別的 GaussianBlur。

引數

ksize	孔徑大小。它應該為奇數（ \(\texttt{ksize} \mod 2 = 1\) ）且為正。
sigma	高斯標準差。如果非正，則從 ksize 計算為 sigma = 0.3*((ksize-1)*0.5 - 1) + 0.8。
ktype	濾波器係數型別。可以是 CV_32F 或 CV_64F。

另請參見

sepFilter2D, getDerivKernels, getStructuringElement, GaussianBlur

getStructuringElement()

Mat cv::getStructuringElement	(	int	shape,
		Size	ksize,
		Point	anchor = Point(-1,-1) )

Python
	cv.getStructuringElement(	shape, ksize[, anchor]	) ->	retval

#include <opencv2/imgproc.hpp>

返回用於形態學操作的指定大小和形狀的結構元素。

該函式構造並返回可進一步傳遞給 erode、dilate 或 morphologyEx 的結構元素。但您也可以自己構造任意二值掩碼並將其用作結構元素。

引數

shape	元素形狀，可以是 MorphShapes 之一
ksize	結構元素的大小。
anchor	錨點在元素中的位置。預設值 \((-1, -1)\) 表示錨點位於中心。請注意，只有十字形元素的形狀取決於錨點位置。在其他情況下，錨點僅調節形態學操作結果的偏移量。

Laplacian()

void cv::Laplacian	(	InputArray	src,
		OutputArray	dst,
		int	ddepth,
		int	ksize = 1,
		double	scale = 1,
		double	delta = 0,
		int	borderType = BORDER_DEFAULT )

Python
	cv.Laplacian(	src, ddepth[, dst[, ksize[, scale[, delta[, borderType]]]]]	) ->	dst

#include <opencv2/imgproc.hpp>

計算影像的拉普拉斯運算元。

該函式透過將使用 Sobel 運算子計算的二階 x 和 y 導數相加，計算源影像的拉普拉斯運算元

\[\texttt{dst} = \Delta \texttt{src} = \frac{\partial^2 \texttt{src}}{\partial x^2} + \frac{\partial^2 \texttt{src}}{\partial y^2}\]

當 ksize > 1 時執行此操作。當 ksize == 1 時，拉普拉斯運算元透過使用以下 \(3 \times 3\) 孔徑對影像進行濾波來計算

\[\vecthreethree {0}{1}{0}{1}{-4}{1}{0}{1}{0}\]

引數

src	源影像。
dst	與 src 具有相同大小和通道數的目標影像。
ddepth	目標影像所需的深度，參見 組合。
ksize	用於計算二階導數濾波器的孔徑大小。詳見 getDerivKernels。大小必須為正奇數。
scale	計算出的拉普拉斯值可選的比例因子。預設情況下不應用縮放。詳見 getDerivKernels。
delta	在將結果儲存到 dst 之前，新增到結果中的可選 delta 值。
borderType	畫素外推法，參見 BorderTypes。不支援 BORDER_WRAP。

另請參見

Sobel, Scharr

medianBlur()

void cv::medianBlur	(	InputArray	src,
		OutputArray	dst,
		int	ksize )

Python
	cv.medianBlur(	src, ksize[, dst]	) ->	dst

#include <opencv2/imgproc.hpp>

使用中值濾波器模糊影像。

該函式使用中值濾波器和 \(\texttt{ksize} \times \texttt{ksize}\) 孔徑平滑影像。多通道影像的每個通道獨立處理。支援原地操作。

注意

中值濾波器內部使用 BORDER_REPLICATE 來處理邊界畫素，參見 BorderTypes

引數

src	輸入 1、3 或 4 通道影像；當 ksize 為 3 或 5 時，影像深度應為 CV_8U、CV_16U 或 CV_32F，對於更大的孔徑大小，只能是 CV_8U。
dst	大小和型別與 src 相同的目標陣列。
ksize	孔徑線性大小；它必須是奇數且大於 1，例如：3、5、7 ...

另請參見

bilateralFilter, blur, boxFilter, GaussianBlur

morphologyDefaultBorderValue()

static Scalar cv::morphologyDefaultBorderValue ( )

inlinestatic

#include <opencv2/imgproc.hpp>

返回侵蝕和膨脹的“魔術”邊界值。對於膨脹，它會自動轉換為 Scalar::all(-DBL_MAX)。

此函式的呼叫圖如下

morphologyEx()

void cv::morphologyEx	(	InputArray	src,
		OutputArray	dst,
		int	op,
		InputArray	kernel,
		Point	anchor = Point(-1,-1),
		int	iterations = 1,
		int	borderType = BORDER_CONSTANT,
		const Scalar &	borderValue = morphologyDefaultBorderValue() )

Python
	cv.morphologyEx(	src, op, kernel[, dst[, anchor[, iterations[, borderType[, borderValue]]]]]	) ->	dst

#include <opencv2/imgproc.hpp>

執行高階形態學變換。

函式 cv::morphologyEx 可以使用腐蝕和膨脹作為基本操作來執行高階形態學變換。

任何操作都可以原地執行。對於多通道影像，每個通道獨立處理。

引數

src	源影像。通道數可以是任意的。深度應為 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F。
dst	與源影像大小和型別相同的結果影像。
op	形態學操作的型別，參見 MorphTypes
kernel	結構元素。可以使用 getStructuringElement 建立。
anchor	錨點在核中的位置。負值表示錨點位於核中心。
iterations	腐蝕和膨脹操作應用的次數。
borderType	畫素外推法，參見 BorderTypes。不支援 BORDER_WRAP。
borderValue	常量邊界情況下的邊界值。預設值具有特殊含義。

另請參見

dilate, erode, getStructuringElement

注意

迭代次數是腐蝕或膨脹操作將應用的次數。例如，兩次迭代的開運算（MORPH_OPEN）等效於連續應用：腐蝕 -> 腐蝕 -> 膨脹 -> 膨脹（而不是腐蝕 -> 膨脹 -> 腐蝕 -> 膨脹）。

pyrDown()

void cv::pyrDown	(	InputArray	src,
		OutputArray	dst,
		const Size &	dstsize = Size(),
		int	borderType = BORDER_DEFAULT )

Python
	cv.pyrDown(	src[, dst[, dstsize[, borderType]]]	) ->	dst

#include <opencv2/imgproc.hpp>

模糊影像並對其進行下采樣。

預設情況下，輸出影像的大小計算為 Size((src.cols+1)/2, (src.rows+1)/2)，但在任何情況下，都應滿足以下條件

\[\begin{array}{l} | \texttt{dstsize.width} *2-src.cols| \leq 2 \\ | \texttt{dstsize.height} *2-src.rows| \leq 2 \end{array}\]

該函式執行高斯金字塔構建的下采樣步驟。首先，它使用以下核對源影像進行卷積

\[\frac{1}{256} \begin{bmatrix} 1 & 4 & 6 & 4 & 1 \\ 4 & 16 & 24 & 16 & 4 \\ 6 & 24 & 36 & 24 & 6 \\ 4 & 16 & 24 & 16 & 4 \\ 1 & 4 & 6 & 4 & 1 \end{bmatrix}\]

然後，透過拒絕偶數行和列來下采樣影像。

引數

src	輸入影像。
dst	輸出影像；它具有指定的尺寸，並與 src 具有相同的型別。
dstsize	輸出影像的尺寸。
borderType	畫素外推法，參見 BorderTypes（不支援 BORDER_CONSTANT）

pyrMeanShiftFiltering()

void cv::pyrMeanShiftFiltering	(	InputArray	src,
		OutputArray	dst,
		double	sp,
		double	sr,
		int	maxLevel = 1,
		TermCriteria	termcrit = TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 5, 1) )

Python
	cv.pyrMeanShiftFiltering(	src, sp, sr[, dst[, maxLevel[, termcrit]]]	) ->	dst

#include <opencv2/imgproc.hpp>

執行影像均值漂移分割的初始步驟。

該函式實現了均值漂移分割的濾波階段，也就是說，函式的輸出是被濾波的“海報化”影像，其中顏色梯度和細粒度紋理被平滑。在輸入影像的每個畫素 (X,Y)（或縮小尺寸的輸入影像，見下文）處，函式執行均值漂移迭代，即考慮聯合空間-顏色超空間中的畫素 (X,Y) 鄰域

\[(x,y): X- \texttt{sp} \le x \le X+ \texttt{sp} , Y- \texttt{sp} \le y \le Y+ \texttt{sp} , ||(R,G,B)-(r,g,b)|| \le \texttt{sr}\]

其中 (R,G,B) 和 (r,g,b) 分別是 (X,Y) 和 (x,y) 處的顏色分量向量（儘管該演算法不依賴於所使用的顏色空間，因此可以使用任何 3 分量顏色空間）。在鄰域上找到平均空間值 (X',Y') 和平均顏色向量 (R',G',B')，它們充當下一次迭代的鄰域中心

\[(X,Y)~(X',Y'), (R,G,B)~(R',G',B').\]

迭代完成後，初始畫素（即迭代開始的畫素）的顏色分量被設定為最終值（最後一次迭代的平均顏色）

\[I(X,Y) <- (R*,G*,B*)\]

當 maxLevel > 0 時，構建 maxLevel+1 級的高斯金字塔，並首先在最小層上執行上述過程。之後，結果傳播到更大的層，並且僅在層顏色與金字塔較低解析度層相差超過 sr 的畫素上再次執行迭代。這使得顏色區域的邊界更清晰。請注意，結果將與在整個原始影像上執行均值漂移過程（即當 maxLevel==0 時）獲得的結果實際不同。

引數

src	源 8 位、3 通道影像。
dst	與源影像格式和大小相同的結果影像。
sp	空間視窗半徑。
sr	顏色視窗半徑。
maxLevel	用於分割的金字塔最大層數。
終止條件	終止條件：何時停止均值漂移迭代。

pyrUp()

void cv::pyrUp	(	InputArray	src,
		OutputArray	dst,
		const Size &	dstsize = Size(),
		int	borderType = BORDER_DEFAULT )

Python
	cv.pyrUp(	src[, dst[, dstsize[, borderType]]]	) ->	dst

#include <opencv2/imgproc.hpp>

對影像進行上取樣然後進行模糊。

預設情況下，輸出影像的大小計算為 Size(src.cols\*2, (src.rows\*2)，但在任何情況下，都應滿足以下條件

\[\begin{array}{l} | \texttt{dstsize.width} -src.cols*2| \leq ( \texttt{dstsize.width} \mod 2) \\ | \texttt{dstsize.height} -src.rows*2| \leq ( \texttt{dstsize.height} \mod 2) \end{array}\]

該函式執行高斯金字塔構建的上取樣步驟，儘管它實際上可以用於構建拉普拉斯金字塔。首先，它透過插入偶數零行和列對源影像進行上取樣，然後將結果與 pyrDown 中相同的核乘以 4 進行卷積。

引數

src	輸入影像。
dst	輸出影像。它具有指定的尺寸，並與 src 具有相同的型別。
dstsize	輸出影像的尺寸。
borderType	畫素外推法，參見 BorderTypes（僅支援 BORDER_DEFAULT）

Scharr()

void cv::Scharr	(	InputArray	src,
		OutputArray	dst,
		int	ddepth,
		int	dx,
		int	dy,
		double	scale = 1,
		double	delta = 0,
		int	borderType = BORDER_DEFAULT )

Python
	cv.Scharr(	src, ddepth, dx, dy[, dst[, scale[, delta[, borderType]]]]	) ->	dst

#include <opencv2/imgproc.hpp>

使用 Scharr 運算子計算影像的第一階 x 或 y 導數。

該函式使用 Scharr 運算元計算影像的第一階 x 或 y 空間導數。呼叫

\[\texttt{Scharr(src, dst, ddepth, dx, dy, scale, delta, borderType)}\]

等效於

\[\texttt{Sobel(src, dst, ddepth, dx, dy, FILTER_SCHARR, scale, delta, borderType)} .\]

引數

src	輸入影像。
dst	與 src 具有相同大小和通道數的輸出影像。
ddepth	輸出影像深度，參見 組合
dx	導數 x 的階數。
dy	導數 y 的階數。
scale	計算出的導數值可選的比例因子；預設情況下不應用縮放（詳見 getDerivKernels）。
delta	在將結果儲存到 dst 之前，新增到結果中的可選 delta 值。
borderType	畫素外推法，參見 BorderTypes。不支援 BORDER_WRAP。

另請參見

cartToPolar

sepFilter2D()

void cv::sepFilter2D	(	InputArray	src,
		OutputArray	dst,
		int	ddepth,
		InputArray	kernelX,
		InputArray	kernelY,
		Point	anchor = Point(-1,-1),
		double	delta = 0,
		int	borderType = BORDER_DEFAULT )

Python
	cv.sepFilter2D(	src, ddepth, kernelX, kernelY[, dst[, anchor[, delta[, borderType]]]]	) ->	dst

#include <opencv2/imgproc.hpp>

對影像應用可分離線性濾波器。

該函式對影像應用可分離線性濾波器。也就是說，首先，src 的每一行都用 1D 核 kernelX 過濾。然後，結果的每一列都用 1D 核 kernelY 過濾。最終結果偏移 delta 後儲存在 dst 中。

引數

src	源影像。
dst	與 src 具有相同大小和通道數的目標影像。
ddepth	目標影像深度，參見 組合
kernelX	用於過濾每一行的係數。
kernelY	用於過濾每一列的係數。
anchor	錨點在核中的位置。預設值 \((-1,-1)\) 表示錨點位於核中心。
delta	在儲存到結果中之前新增到濾波結果中的值。
borderType	畫素外推法，參見 BorderTypes。不支援 BORDER_WRAP。

另請參見

filter2D, Sobel, GaussianBlur, boxFilter, blur

Sobel()

void cv::Sobel	(	InputArray	src,
		OutputArray	dst,
		int	ddepth,
		int	dx,
		int	dy,
		int	ksize = 3,
		double	scale = 1,
		double	delta = 0,
		int	borderType = BORDER_DEFAULT )

Python
	cv.Sobel(	src, ddepth, dx, dy[, dst[, ksize[, scale[, delta[, borderType]]]]]	) ->	dst

#include <opencv2/imgproc.hpp>

使用擴充套件的 Sobel 運算子計算影像的一階、二階、三階或混合導數。

除一種情況外，在所有情況下，都使用 \(\texttt{ksize} \times \texttt{ksize}\) 可分離核來計算導數。當 \(\texttt{ksize = 1}\) 時，使用 \(3 \times 1\) 或 \(1 \times 3\) 核（即不進行高斯平滑）。ksize = 1 只能用於第一階或第二階 x 或 y 導數。

還有一個特殊值 ksize = #FILTER_SCHARR (-1)，它對應於 \(3\times3\) 的 Scharr 濾波器，其結果可能比 \(3\times3\) 的 Sobel 更精確。Scharr 孔徑為

\[\vecthreethree{-3}{0}{3}{-10}{0}{10}{-3}{0}{3}\]

用於 x 導數，或轉置用於 y 導數。

該函式透過將影像與適當的核進行卷積來計算影像導數

\[\texttt{dst} = \frac{\partial^{xorder+yorder} \texttt{src}}{\partial x^{xorder} \partial y^{yorder}}\]

Sobel 運算子結合了高斯平滑和微分，因此結果或多或少地抵抗噪聲。最常見的是，該函式以 ( xorder = 1, yorder = 0, ksize = 3) 或 ( xorder = 0, yorder = 1, ksize = 3) 呼叫，以計算第一階 x 或 y 影像導數。第一種情況對應於以下核

\[\vecthreethree{-1}{0}{1}{-2}{0}{2}{-1}{0}{1}\]

第二種情況對應於以下核

\[\vecthreethree{-1}{-2}{-1}{0}{0}{0}{1}{2}{1}\]

引數

src	輸入影像。
dst	與 src 具有相同大小和通道數的輸出影像。
ddepth	輸出影像深度，參見 組合；對於 8 位輸入影像，這將導致導數截斷。
dx	導數 x 的階數。
dy	導數 y 的階數。
ksize	擴充套件 Sobel 核的大小；它必須是 1、3、5 或 7。
scale	計算出的導數值可選的比例因子；預設情況下不應用縮放（詳見 getDerivKernels）。
delta	在將結果儲存到 dst 之前，新增到結果中的可選 delta 值。
borderType	畫素外推法，參見 BorderTypes。不支援 BORDER_WRAP。

另請參見

Scharr, Laplacian, sepFilter2D, filter2D, GaussianBlur, cartToPolar

spatialGradient()

void cv::spatialGradient	(	InputArray	src,
		OutputArray	dx,
		OutputArray	dy,
		int	ksize = 3,
		int	borderType = BORDER_DEFAULT )

Python
	cv.spatialGradient(	src[, dx[, dy[, ksize[, borderType]]]]	) ->	dx, dy

#include <opencv2/imgproc.hpp>

使用 Sobel 運算子計算影像在 x 和 y 方向上的第一階導數。

等效於呼叫

Sobel( src, dx, CV_16SC1, 1, 0, 3 );
Sobel( src, dy, CV_16SC1, 0, 1, 3 );

引數

src	輸入影像。
dx	x 方向上的一階導數輸出影像。
dy	y 方向上的一階導數輸出影像。
ksize	Sobel 核的大小。必須為 3。
borderType	畫素外推法，參見 BorderTypes。僅支援 BORDER_DEFAULT=BORDER_REFLECT_101 和 BORDER_REPLICATE。

另請參見

Sobel

sqrBoxFilter()

void cv::sqrBoxFilter	(	InputArray	src,
		OutputArray	dst,
		int	ddepth,
		Size	ksize,
		Point	anchor = Point(-1, -1),
		bool	normalize = true,
		int	borderType = BORDER_DEFAULT )

Python
	cv.sqrBoxFilter(	src, ddepth, ksize[, dst[, anchor[, normalize[, borderType]]]]	) ->	dst

#include <opencv2/imgproc.hpp>

計算覆蓋濾波器的畫素值的歸一化平方和。

對於源影像中的每個畫素 \( (x, y) \)，該函式計算覆蓋該畫素的濾波器所重疊的相鄰畫素值的平方和。

未歸一化的平方箱式濾波器對於計算區域性影像統計資料（例如畫素鄰域周圍的區域性方差和標準差）很有用。

引數

src	輸入影像
dst	與 src 相同大小和型別的輸出影像
ddepth	輸出影像深度（-1 表示使用 src.depth()）
ksize	核大小
anchor	核錨點。預設值 Point(-1, -1) 表示錨點位於核中心。
normalize	標誌，指定核心是否按其面積歸一化。
borderType	用於外推影像外部畫素的邊界模式，參見 BorderTypes。不支援 BORDER_WRAP。

另請參見

boxFilter

stackBlur()

void cv::stackBlur	(	InputArray	src,
		OutputArray	dst,
		Size	ksize )

Python
	cv.stackBlur(	src, ksize[, dst]	) ->	dst

#include <opencv2/imgproc.hpp>

使用stackBlur對影像進行模糊處理。

該函式對影像應用 stackBlur。stackBlur 可以生成與高斯模糊類似的結果，並且時間消耗不會隨著核大小的增加而增加。它在掃描影像時建立一種移動的顏色堆疊。因此，它只需要向堆疊的右側新增一個新的顏色塊並移除最左側的顏色。堆疊頂層剩餘的顏色會根據它們在堆疊的右側還是左側而增加或減少一個。唯一支援的 borderType 是 BORDER_REPLICATE。原始論文由 Mario Klingemann 提出，可在 https://underdestruction.com/2004/02/25/stackblur-2004 中找到。

引數

src	輸入影像。通道數可以是任意的，但深度應為 CV_8U、CV_16U、CV_16S 或 CV_32F 之一。
dst	與 src 相同大小和型別的輸出影像。
ksize	堆疊模糊核大小。ksize.width 和 ksize.height 可以不同，但它們都必須是正奇數。