图像滤波

详细描述

本节描述的函数和类用于对二维图像（表示为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 }
	结构元素的形状 更多信息...
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)
	使用归一化矩形滤波器模糊图像。
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)
	使用高斯滤波器对图像进行模糊。
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

枚举 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)内填充的椭圆

MorphTypes

枚举 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 二值图像。文档中可以找到教程

特殊滤波器

枚举 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>

将双边滤波器应用于图像。

该函数对输入图像应用双边滤波，如http://www.dai.ed.ac.uk/CVonline/LOCAL_COPIES/MANDUCHI1/Bilateral_Filtering.html所述，双边滤波能很好地减少不想要的噪声，同时保持边缘相对清晰。然而，与其他大多数滤波器相比，它非常慢。

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

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

此滤波器不按原位工作。

参数

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>

使用归一化矩形滤波器模糊图像。

该函数使用系数

\[\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	输出图像与源图像具有相同大小和类型。
ksize	模糊核大小。
定位点。	定位点；默认值 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	输出图像与源图像具有相同大小和类型。
ddepth	输出图像深度（-1 以使用 src(depth)）。
ksize	模糊核大小。
定位点。	定位点；默认值 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>

为图像构造高斯金字塔。

该函数构建一个图像向量，并通过递归应用 pyrDown 到先前构建的层，从 dst[0]==src 开始来构建高斯金字塔。

参数

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 标量 &	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')\]

函数支持原地模式。膨胀可以应用多次。对于多通道图像，每个通道都是独立处理的。

参数

src	输入图像；通道数可以是任意的，但深度应该是 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F 其中之一。
dst	输出图像与源图像具有相同大小和类型。
kernel	用于膨胀的结构元素；如果 element=Mat()，将使用 3 x 3 矩形结构元素。可以使用 getStructuringElement 创建内核。
定位点。	锚点在结构元素内的位置；默认值 (-1, -1) 意味着锚点在元素中心。
iterations	`dilate()` 应用次数。
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 标量 &	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')\]

函数支持原地模式。腐蚀可以应用多次。对于多通道图像，每个通道都是独立处理的。

参数

src	输入图像；通道数可以是任意的，但深度应该是 CV_8U、CV_16U、CV_16S、CV_32F 或 CV_64F 其中之一。
dst	输出图像与源图像具有相同大小和类型。
kernel	用于腐蚀的结构元素；如果element=Mat()，将使用码3 x 3矩形结构元素。可以使用getStructuringElement 创建内核。
定位点。	锚点在结构元素内的位置；默认值 (-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	输出图像的大小与输入图像相同，并且拥有相同的通道数。
ddepth	目标图像的期望深度，请参见组合
kernel	卷积核（或者说是相关核），一个单一通道的浮点矩阵；如果想要对不同的通道应用不同的核，请使用split函数将图像分为单独的颜色平面并分别处理。
定位点。	内核的锚点表示卷积点在内核内的相对位置；锚点应该在内核内部；默认值(-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
	)

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

#include <opencv2/imgproc.hpp>

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

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

参数

src	输入图像；图像可以有任意数量的通道，它们将独立处理，但深度应该是CV_8U, CV_16U, CV_16S, CV_32F或CV_64F。
dst	输出图像与源图像具有相同大小和类型。
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。

另请参阅

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	锚点 = Point(-1,-1)
	)

Python
	cv.getStructuringElement(	形状, ksize[, 锚点]	) ->	retval

#include <opencv2/imgproc.hpp>

返回指定尺寸和形状的结构元素，用于形态学运算。

此函数构建并返回一个结构元素，可以进一步传递给erode、dilate或morphologyEx。但是您也可以构建任意二进制掩码并将其用作结构元素。

参数

shape	可能的元素形状之一 MorphShapes
ksize	结构元素的大小。
定位点。	元素内的锚点位置。默认值 \((-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时，通过以下\(3x3\)卷积核计算拉普拉斯算子

\[\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()

静态 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 标量 &	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 创建。
定位点。	结构元素中心的锚定位置。负值表示锚定在核中心。
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	输出图像；具有指定大小和与源相同的类型。
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	分割的金字塔的最大级别。
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	输出图像的大小与输入图像相同，并且拥有相同的通道数。
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>

将可分离线性滤波器应用于图像。

该函数将可分离线性滤波器应用于图像。也就是说，首先，使用1D核核kernelX对src的每一行进行滤波。然后，使用1D核核kernelY对结果中的每一列进行滤波。将delta移位后的最终结果存储在dst中。

参数

src	源图像。
dst	大小和通道数与src相同的输出图像。
ddepth	目标图像深度，请参阅组合
kernelX	滤波每行的系数。
kernelY	滤波每列的系数。
定位点。	内核中的锚点位置。默认值\((-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\)核（即不进行高斯平滑）。\(\texttt{ksize = 1}\)只能用于第一或第二x-或y-导数。

还有一个特殊的值 ksize = #FILTER_SCHARR (-1)，它对应于可能比\(3\times3\)Sobel给出更精确结果的\(3\times3\)Scharr滤波器。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}}\]

索贝尔算子结合高斯平滑和微分，因此结果对噪声的抵抗性或多或少。通常，该函数用（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	扩展索贝尔核的大小；它必须是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	索贝尔核的大小。它必须是3。
borderType	像素外推方法，请参阅边界类型。仅支持

另请参阅

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	核大小
定位点。	核锚点。默认值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可以生成类似于高斯模糊的效果，其时间消耗不会随着核大小增加而增加。它在扫描图像时创建一种颜色移动的堆栈。因此，它只需要将一个新的颜色块添加到堆栈的右侧，并移除最左侧的颜色。堆栈顶层的剩余颜色要么增加一个，要么减少一个，具体取决于它们是在堆栈的右侧还是左侧。唯一支持的外边框类型是BORDER_REPLICATE。原始论文由Mario Klingemann提出，可以在http://underdestruction.com/2004/02/25/stackblur-2004找到。

参数

src	输入图像。通道数可以是任意的，但深度应该是CV_8U、CV_16U、CV_16S或CV_32F之一。
dst	输出图像与源图像具有相同大小和类型。
ksize	堆叠模糊核大小。ksize.width和ksize.height可以不同，但它们都必须是正数且为奇数。