图像滤波

详细说明

本节描述的函数和类用于对二维图像（以 Mat 表示）执行各种线性或非线性滤波操作。这意味着对于源图像（通常是矩形）中的每个像素位置 \((x,y)\)，都会考虑其邻域并用于计算响应。在线性滤波器的情况下，它是像素值的加权和。在形态学操作的情况下，它是最小值或最大值，依此类推。计算出的响应存储在目标图像的相同位置 \((x,y)\)。这意味着输出图像将与输入图像具有相同的大小。通常，这些函数支持多通道数组，在这种情况下，每个通道都是独立处理的。因此，输出图像也将具有与输入图像相同的通道数。

本节描述的函数和类的另一个共同特征是，与简单的算术函数不同，它们需要对外推一些不存在的像素值。例如，如果您想使用高斯 \(3 \times 3\) 滤波器平滑图像，那么在处理每行最左侧的像素时，您需要它们左侧的像素，即图像之外的像素。您可以让这些像素与图像最左侧的像素相同（“复制边界”外推方法），或者假设所有不存在的像素都是零（“常量边界”外推方法），依此类推。OpenCV 允许您指定外推方法。有关详细信息，请参阅 BorderTypes

深度组合

输入深度 (src.depth())	输出深度 (ddepth)
CV_8U	-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 将输入数据转换为所需的精度。

枚举
enum	cv::MorphShapes {   cv::MORPH_RECT = 0 ,   cv::MORPH_CROSS = 1 ,   cv::MORPH_ELLIPSE = 2 ,   cv::MORPH_DIAMOND = 3 }
	结构元素的形状 更多...
enum	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 }
	形态学操作类型 更多...
enum	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)
	使用归一化框式滤波（normalized box filter）模糊图像。
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 模糊图像。

枚举类型文档 (Enumeration Type Documentation)

MorphShapes

enum cv::MorphShapes

#include <opencv2/imgproc.hpp>

结构元素的形状

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

形态学操作类型

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

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

函数文档 (Function Documentation)

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 中所述。bilateralFilter 可以非常好地减少不必要的噪声，同时保持边缘相当清晰。但是，与大多数滤波器相比，它的速度非常慢。

Sigma 值：为简单起见，您可以将 2 个 sigma 值设置为相同。如果它们很小（< 10），滤波器将不会有太大效果；而如果它们很大（> 150），它们将产生非常强烈的效果，使图像看起来像“卡通画”。

滤波器大小：大型滤波器（d > 5）非常慢，因此建议实时应用使用 d=5，对于需要重度噪声过滤的离线应用，建议使用 d=9。

此滤波器不支持就地 (inplace) 操作。

参数

src	源 8 位或浮点型，1 通道或 3 通道图像。
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>

使用归一化框式滤波（normalized box filter）模糊图像。

该函数使用内核平滑图像

\[\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 开始的索引。它必须是非负数。
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>

使用高斯滤波器模糊图像。

该函数将源图像与指定的高斯内核进行卷积。支持就地滤波。

参数

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。
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 滤波器。

参数

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	可选的 delta 值，在将结果存储到 dst 之前添加到结果中。
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) 处的颜色分量向量（尽管该算法不依赖于所使用的颜色空间，因此可以使用任何三分量颜色空间）。在邻域上寻找平均空间值 (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	用于分割的金字塔最大层级。
termcrit	终止标准：何时停止均值漂移迭代。

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	可选的 delta 值，在将结果存储到 dst 之前添加到结果中。
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 的每一行都使用一维内核 kernelX 进行滤波。然后，结果的每一列都使用一维内核 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	可选的 delta 值，在将结果存储到 dst 之前添加到结果中。
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) \)，该函数计算那些与放置在像素 \( (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 可以不同，但它们必须都是正数且为奇数。