图像滤波

详细描述

本节描述的函数和类用于对二维图像（表示为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将输入数据转换为所需的精度。

枚举
枚举	cv::MorphShapes {   cv::MORPH_RECT = 0 ,   cv::MORPH_CROSS = 1 ,   cv::MORPH_ELLIPSE = 2 }
	结构元素的形状 更多…
枚举	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

枚举 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二值图像。文档中提供了教程。

SpecialFilter

枚举 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	与 src 大小和类型相同的输出图像。
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	与 src 大小和类型相同的输出图像。
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	与 src 类型相同的 maxlevel+1 个图像的目标向量。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 创建内核。
锚点	元素内锚点的位置；默认值 (-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 创建内核。
锚点	元素内锚点的位置；默认值 (-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 函数将图像分割成单独的颜色平面，然后分别处理它们。
锚点	卷积核的锚点，指示滤波点在卷积核内的相对位置；锚点应位于卷积核内；默认值 (-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,
		算法提示	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。
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	形状,
		Size	ksize,
		Point	anchor = Point(-1,-1) )

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

#include <opencv2/imgproc.hpp>

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

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

参数

形状	元素形状，可以是 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 时，拉普拉斯算子通过使用以下 \(3 \times 3\) 孔径对图像进行滤波来计算

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

参数

src	源图像。
dst	与 src 大小和通道数相同的目标图像。
ddepth	目标图像的所需深度，请参阅 组合。
ksize	用于计算二阶导数滤波器的孔径大小。详情请参阅 getDerivKernels。大小必须为正奇数。
比例因子	计算的拉普拉斯值的可选项比例因子。默认情况下，不应用缩放。详情请参阅 getDerivKernels。
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 创建。
锚点	带有内核的锚点位置。负值表示锚点位于内核中心。
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层的Gaussian金字塔，并且上述过程首先在最小的层上运行。之后，结果将传播到较大的层，并且仅对那些层颜色与金字塔较低分辨率层相比差异大于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导数的阶数。
比例因子	计算的导数值的可选比例因子；默认情况下，不应用缩放(有关详细信息，请参见getDerivKernels)。
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的每一行都用1D核kernelX进行滤波。然后，结果的每一列都用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\) 核（即，不进行高斯平滑）。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。
比例因子	计算的导数值的可选比例因子；默认情况下，不应用缩放(有关详细信息，请参见getDerivKernels)。
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	像素外推方法，参见 边界类型。仅支持 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	核大小
锚点	核锚点。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 提出，可在 http://underdestruction.com/2004/02/25/stackblur-2004 找到。

参数

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