Extended Image Processing

Modules
	Structured forests for fast edge detection
	EdgeBoxes
	Filters
	Superpixels
	Image segmentation
	Fast line detector
	EdgeDrawing
	Fourier descriptors
	Binary morphology on run-length encoded image

Functions
void	cv::ximgproc::anisotropicDiffusion (InputArray src, OutputArray dst, float alpha, float K, int niters)
	Performs anisotropic diffusion on an image. More...
void	cv::ximgproc::edgePreservingFilter (InputArray src, OutputArray dst, int d, double threshold)
	Smoothes an image using the Edge-Preserving filter. More...
void	cv::ximgproc::niBlackThreshold (InputArray _src, OutputArray _dst, double maxValue, int type, int blockSize, double k, int binarizationMethod=BINARIZATION_NIBLACK, double r=128)
	Performs thresholding on input images using Niblack's technique or some of the popular variations it inspired. More...
Matx23d	cv::ximgproc::PeiLinNormalization (InputArray I)
	Calculates an affine transformation that normalize given image using Pei&Lin Normalization. More...
void	cv::ximgproc::PeiLinNormalization (InputArray I, OutputArray T)
void	cv::ximgproc::thinning (InputArray src, OutputArray dst, int thinningType=THINNING_ZHANGSUEN)
	Applies a binary blob thinning operation, to achieve a skeletization of the input image. More...

Detailed Description

Function Documentation

anisotropicDiffusion()

void cv::ximgproc::anisotropicDiffusion	(	InputArray	src,
		OutputArray	dst,
		float	alpha,
		float	K,
		int	niters
	)

Python:
	dst	=	cv.ximgproc.anisotropicDiffusion(	src, alpha, K, niters[, dst]	)

#include <opencv2/ximgproc.hpp>

Performs anisotropic diffusion on an image.

The function applies Perona-Malik anisotropic diffusion to an image. This is the solution to the partial differential equation:

\[{\frac {\partial I}{\partial t}}={\mathrm {div}}\left(c(x,y,t)\nabla I\right)=\nabla c\cdot \nabla I+c(x,y,t)\Delta I\]

Suggested functions for c(x,y,t) are:

\[c\left(\|\nabla I\|\right)=e^{{-\left(\|\nabla I\|/K\right)^{2}}}\]

or

\[ c\left(\|\nabla I\|\right)={\frac {1}{1+\left({\frac {\|\nabla I\|}{K}}\right)^{2}}} \]

Parameters

src	Source image with 3 channels.
dst	Destination image of the same size and the same number of channels as src .
alpha	The amount of time to step forward by on each iteration (normally, it's between 0 and 1).
K	sensitivity to the edges
niters	The number of iterations

edgePreservingFilter()

void cv::ximgproc::edgePreservingFilter	(	InputArray	src,
		OutputArray	dst,
		int	d,
		double	threshold
	)

Python:
	dst	=	cv.ximgproc.edgePreservingFilter(	src, d, threshold[, dst]	)

#include <opencv2/ximgproc/edgepreserving_filter.hpp>

Smoothes an image using the Edge-Preserving filter.

The function smoothes Gaussian noise as well as salt & pepper noise. For more details about this implementation, please see [ReiWoe18] Reich, S. and Wörgötter, F. and Dellen, B. (2018). A Real-Time Edge-Preserving Denoising Filter. Proceedings of the 13th International Joint Conference on Computer Vision, Imaging and Computer Graphics Theory and Applications (VISIGRAPP): Visapp, 85-94, 4. DOI: 10.5220/0006509000850094.

Parameters

src	Source 8-bit 3-channel image.
dst	Destination image of the same size and type as src.
d	Diameter of each pixel neighborhood that is used during filtering. Must be greater or equal 3.
threshold	Threshold, which distinguishes between noise, outliers, and data.

niBlackThreshold()

void cv::ximgproc::niBlackThreshold	(	InputArray	_src,
		OutputArray	_dst,
		double	maxValue,
		int	type,
		int	blockSize,
		double	k,
		int	binarizationMethod = BINARIZATION_NIBLACK,
		double	r = 128
	)

Python:
	_dst	=	cv.ximgproc.niBlackThreshold(	_src, maxValue, type, blockSize, k[, _dst[, binarizationMethod[, r]]]	)

#include <opencv2/ximgproc.hpp>

Performs thresholding on input images using Niblack's technique or some of the popular variations it inspired.

The function transforms a grayscale image to a binary image according to the formulae:

• THRESH_BINARY

  \[dst(x,y) = \fork{\texttt{maxValue}}{if \(src(x,y) > T(x,y)\)}{0}{otherwise}\]

• THRESH_BINARY_INV

  \[dst(x,y) = \fork{0}{if \(src(x,y) > T(x,y)\)}{\texttt{maxValue}}{otherwise}\]

  where \(T(x,y)\) is a threshold calculated individually for each pixel.

The threshold value \(T(x, y)\) is determined based on the binarization method chosen. For classic Niblack, it is the mean minus \( k \) times standard deviation of \(\texttt{blockSize} \times\texttt{blockSize}\) neighborhood of \((x, y)\).

The function can't process the image in-place.

Parameters

_src	Source 8-bit single-channel image.
_dst	Destination image of the same size and the same type as src.
maxValue	Non-zero value assigned to the pixels for which the condition is satisfied, used with the THRESH_BINARY and THRESH_BINARY_INV thresholding types.
type	Thresholding type, see cv::ThresholdTypes.
blockSize	Size of a pixel neighborhood that is used to calculate a threshold value for the pixel: 3, 5, 7, and so on.
k	The user-adjustable parameter used by Niblack and inspired techniques. For Niblack, this is normally a value between 0 and 1 that is multiplied with the standard deviation and subtracted from the mean.
binarizationMethod	Binarization method to use. By default, Niblack's technique is used. Other techniques can be specified, see cv::ximgproc::LocalBinarizationMethods.
r	The user-adjustable parameter used by Sauvola's technique. This is the dynamic range of standard deviation.

See also

threshold, adaptiveThreshold

PeiLinNormalization() [1/2]

Matx23d cv::ximgproc::PeiLinNormalization

(

InputArray

I

)

Python:
	T	=	cv.ximgproc.PeiLinNormalization(	I[, T]	)

#include <opencv2/ximgproc/peilin.hpp>

Calculates an affine transformation that normalize given image using Pei&Lin Normalization.

Assume given image \(I=T(\bar{I})\) where \(\bar{I}\) is a normalized image and \(T\) is an affine transformation distorting this image by translation, rotation, scaling and skew. The function returns an affine transformation matrix corresponding to the transformation \(T^{-1}\) described in [PeiLin95]. For more details about this implementation, please see [PeiLin95] Soo-Chang Pei and Chao-Nan Lin. Image normalization for pattern recognition. Image and Vision Computing, Vol. 13, N.10, pp. 711-723, 1995.

Parameters

I	Given transformed image.

Returns

Transformation matrix corresponding to inversed image transformation

PeiLinNormalization() [2/2]

void cv::ximgproc::PeiLinNormalization	(	InputArray	I,
		OutputArray	T
	)

Python:
	T	=	cv.ximgproc.PeiLinNormalization(	I[, T]	)

#include <opencv2/ximgproc/peilin.hpp>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

thinning()

void cv::ximgproc::thinning	(	InputArray	src,
		OutputArray	dst,
		int	thinningType = THINNING_ZHANGSUEN
	)

Python:
	dst	=	cv.ximgproc.thinning(	src[, dst[, thinningType]]	)

#include <opencv2/ximgproc.hpp>

Applies a binary blob thinning operation, to achieve a skeletization of the input image.

The function transforms a binary blob image into a skeletized form using the technique of Zhang-Suen.

Parameters

src	Source 8-bit single-channel image, containing binary blobs, with blobs having 255 pixel values.
dst	Destination image of the same size and the same type as src. The function can work in-place.
thinningType	Value that defines which thinning algorithm should be used. See cv::ximgproc::ThinningTypes