图像滤波

详细描述

本节描述的函数和类用于对二维图像（表示为 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 可以不同，但它们都必须是正奇数。