画像フィルタリング

詳細説明

このセクションで説明する関数およびクラスは、2次元画像(Matで表現される)に対して各種の線形または非線形フィルタリング処理を行うために使用する。これは、入力画像内の各ピクセル位置 \((x,y)\) (通常は矩形)について、その近傍を考慮して応答を計算することを意味する。線形フィルタの場合、これはピクセル値の重み付き和となる。モルフォロジー処理の場合は最小値または最大値などとなる。計算された応答は、出力画像の同じ位置 \((x,y)\) に格納される。つまり、出力画像は入力画像と同じサイズになる。通常、これらの関数はマルチチャンネル配列をサポートしており、その場合は各チャンネルが独立して処理される。したがって、出力画像も入力画像と同じチャンネル数を持つ。

このセクションで説明する関数およびクラスのもう1つの共通する特徴は、単純な算術関数とは異なり、存在しない一部のピクセルの値を外挿する必要があるという点である。例えば、ガウシアン \(3 \times 3\) フィルタで画像を平滑化したい場合、各行の左端のピクセルを処理する際には、それらの左側、つまり画像の外側のピクセルが必要になる。これらのピクセルを左端の画像ピクセルと同じ値にする("replicated border" 外挿法)ことも、存在しないピクセルをすべてゼロと仮定する("constant border" 外挿法)こともでき、その他の方法もある。OpenCV では外挿法を指定できる。詳細は BorderTypes を参照

ビット深度の組み合わせ

Input depth (src.depth())	Output 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)
	正規化ボックスフィルタを使って画像を平滑化する。
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)
	ガボールフィルタの係数を返す。
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))
	画像の平均値シフト(meanshift)セグメンテーションの初期ステップを実行する。
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方向の1次画像微分を計算する。
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演算子を使って1次、2次、3次、または混合の画像微分を計算する。
void	cv::spatialGradient (InputArray src, OutputArray dx, OutputArray dy, int ksize=3, int borderType=BORDER_DEFAULT)
	Sobel演算子を使ってx方向とy方向の両方の1次画像微分を計算する。
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 で説明されているように、入力画像にバイラテラルフィルタリングを適用する。bilateralFilter はエッジを比較的シャープに保ちつつ、不要なノイズを非常によく低減できる。ただし、ほとんどのフィルタに比べて非常に低速である。

シグマ値: 簡単のため、2つのシグマ値を同じに設定してよい。値が小さい場合（< 10）はフィルタの効果はあまりなく、逆に大きい場合（> 150）は非常に強い効果が現れ、画像が「漫画調 (cartoonish)」に見えるようになる。

フィルタサイズ: 大きなフィルタ（d > 5）は非常に低速であるため、リアルタイムアプリケーションでは d=5 を、強いノイズ除去が必要なオフラインアプリケーションではおそらく d=9 を使うことが推奨される。

このフィルタはインプレース処理では動作しない。

引数

src	入力となる8ビットまたは浮動小数点型の、1チャンネルまたは3チャンネルの画像。
dst	src と同じサイズ・型の出力画像。
d	フィルタ処理中に使用される各ピクセル近傍の直径。0以下の場合は sigmaSpace から計算される。
sigmaColor	色空間におけるフィルタのシグマ。この引数の値が大きいほど、ピクセル近傍内（sigmaSpace を参照）のより遠い色どうしが混ざり合い、ほぼ同色の領域が大きくなる。
sigmaSpace	座標空間におけるフィルタのシグマ。この引数の値が大きいほど、色が十分に近い限り、より遠いピクセルどうしが互いに影響し合う（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	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 を使って作成できる
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 は異なっていてもよいが、いずれも正の奇数でなければならない。あるいは両方を0とすることもでき、その場合は sigma から計算される。
sigmaX	X方向のガウシアンカーネルの標準偏差。
sigmaY	Y方向のガウシアンカーネルの標準偏差。sigmaY が0の場合は sigmaX と等しい値に設定される。両方のシグマが0の場合は、それぞれ 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\) となるように選ばれるスケール係数である。

このようにして生成された2つのカーネルを 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の2次微分を加算することで、入力画像のラプラシアンを計算する:

\[\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	出力画像の希望するビット深度。combinations を参照。
ksize	2階微分フィルタの計算に用いるアパーチャサイズ。詳細は getDerivKernels を参照。サイズは正かつ奇数でなければならない。
scale	計算されたラプラシアン値に対する省略可能なスケール係数。デフォルトではスケーリングは適用されない。詳細は 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 を用いて作成できる。
anchor	カーネルに対するアンカー位置。負の値はアンカーがカーネル中心にあることを意味する。
iterations	収縮と膨張を適用する回数。
borderType	ピクセル外挿方法。BorderTypes を参照。BORDER_WRAP はサポートされていない。
borderValue	定数境界の場合の境界値。デフォルト値は特別な意味を持つ。

参照

dilate, erode, getStructuringElement

覚え書き

反復回数は、収縮または膨張操作が適用される回数である。例えば、2回の反復を伴うオープニング操作 (MORPH_OPEN) は、erode -> erode -> dilate -> dilate を順に適用するのと等価である(erode -> dilate -> erode -> dilate ではない)。

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	セグメンテーションに用いるピラミッドの最大レベル。
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の1次微分を計算する。

この関数は、Scharr演算子を用いて画像のxまたはyの1次空間微分を計算する。次の呼び出し

\[\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	出力画像のビット深度。combinations を参照。
dx	x方向の微分の階数。
dy	y方向の微分の階数。
scale	計算された微分値に対する省略可能なスケール係数。デフォルトではスケーリングは適用されない（詳細は 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の各行を1次元カーネルkernelXでフィルタリングする。次に、その結果の各列を1次元カーネルkernelYでフィルタリングする。deltaだけシフトされた最終結果がdstに格納される。

引数

src	入力画像。
dst	src と同じサイズかつ同じチャンネル数の出力画像。
ddepth	出力画像のビット深度。combinations を参照。
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演算子を用いて、1次、2次、3次、または混合の画像微分を計算する。

1つの場合を除くすべての場合で、微分の計算には \(\texttt{ksize} \times \texttt{ksize}\) の分離可能なカーネルが使用される。\(\texttt{ksize = 1}\) の場合は、\(3 \times 1\) または \(1 \times 3\) のカーネルが使用される(すなわち、ガウシアン平滑化は行われない)。ksize = 1 はxまたはyの1次または2次微分にのみ使用できる。

また、特別な値 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演算子はガウシアン平滑化と微分を組み合わせるため、結果はノイズに対して多少なりとも耐性がある。最も一般的には、xまたはyの1次画像微分を計算するために、この関数は ( xorder = 1, yorder = 0, ksize = 3) または ( xorder = 0, yorder = 1, ksize = 3) で呼び出される。前者の場合は次のカーネルに対応する:

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

後者の場合は次のカーネルに対応する:

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

引数

src	入力画像。
dst	src と同じサイズかつ同じチャンネル数の出力画像。
ddepth	出力画像のビット深度。combinations を参照。8ビット入力画像の場合、微分結果が切り捨てられる。
dx	x方向の微分の階数。
dy	y方向の微分の階数。
ksize	拡張Sobelカーネルのサイズ。1、3、5、または7でなければならない。
scale	計算された微分値に対する省略可能なスケール係数。デフォルトではスケーリングは適用されない（詳細は 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の両方向の1次画像微分を計算する。

次の呼び出しと等価である:

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

引数

src	入力画像。
dx	x方向の1階微分を格納する出力画像。
dy	y方向の1階微分を格納する出力画像。
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	出力画像のビット深度（src.depth() を使用する場合は -1）
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はガウシアンぼかしと同様の結果を生成でき、処理時間はカーネルサイズの増加に伴って増加しない。画像をスキャンしながら、一種の移動する色のスタックを作成する。これにより、スタックの右側に新しい色のブロックを1つ追加し、最も左の色を取り除くだけでよい。スタックの最上層に残った色は、スタックの右側にあるか左側にあるかに応じて、加算されるか1つ減らされる。サポートされる唯一の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 は異なっていてもよいが、いずれも正の奇数である必要がある。