OpenCV: Filters

Enumerator
DTF_NC Python: cv.ximgproc.DTF_NC
DTF_IC Python: cv.ximgproc.DTF_IC
DTF_RF Python: cv.ximgproc.DTF_RF
GUIDED_FILTER Python: cv.ximgproc.GUIDED_FILTER
AM_FILTER Python: cv.ximgproc.AM_FILTER

Function Documentation

◆ amFilter()

void cv::ximgproc::amFilter	(	InputArray	joint,
		InputArray	src,
		OutputArray	dst,
		double	sigma_s,
		double	sigma_r,
		bool	adjust_outliers = `false`
	)

Python:
	cv.ximgproc.amFilter(	joint, src, sigma_s, sigma_r[, dst[, adjust_outliers]]	) ->	dst

Simple one-line Adaptive Manifold Filter call.

Parameters

joint	joint (also called as guided) image or array of images with any numbers of channels.
src	filtering image with any numbers of channels.
dst	output image.
sigma_s	spatial standard deviation.
sigma_r	color space standard deviation, it is similar to the sigma in the color space into bilateralFilter.
adjust_outliers	optional, specify perform outliers adjust operation or not, (Eq. 9) in the original paper.

Note: Joint images with CV_8U and CV_16U depth converted to images with CV_32F depth and [0; 1] color range before processing. Hence color space sigma sigma_r must be in [0; 1] range, unlike same sigmas in bilateralFilter and dtFilter functions.

See also: bilateralFilter, dtFilter, guidedFilter

◆ bilateralTextureFilter()

void cv::ximgproc::bilateralTextureFilter	(	InputArray	src,
		OutputArray	dst,
		int	fr = `3`,
		int	numIter = `1`,
		double	sigmaAlpha = `-1.`,
		double	sigmaAvg = `-1.`
	)

Python:
	cv.ximgproc.bilateralTextureFilter(	src[, dst[, fr[, numIter[, sigmaAlpha[, sigmaAvg]]]]]	) ->	dst

Applies the bilateral texture filter to an image. It performs structure-preserving texture filter. For more details about this filter see [54].

Parameters

src	Source image whose depth is 8-bit UINT or 32-bit FLOAT
dst	Destination image of the same size and type as src.
fr	Radius of kernel to be used for filtering. It should be positive integer
numIter	Number of iterations of algorithm, It should be positive integer
sigmaAlpha	Controls the sharpness of the weight transition from edges to smooth/texture regions, where a bigger value means sharper transition. When the value is negative, it is automatically calculated.
sigmaAvg	Range blur parameter for texture blurring. Larger value makes result to be more blurred. When the value is negative, it is automatically calculated as described in the paper.

See also: rollingGuidanceFilter, bilateralFilter

◆ colorMatchTemplate()

void cv::ximgproc::colorMatchTemplate	(	InputArray	img,
		InputArray	templ,
		OutputArray	result
	)

Python:
	cv.ximgproc.colorMatchTemplate(	img, templ[, result]	) ->	result

Compares a color template against overlapped color image regions.

Parameters

img	Image where the search is running. It must be 3 channels image
templ	Searched template. It must be not greater than the source image and have 3 channels
result	Map of comparison results. It must be single-channel 64-bit floating-point

◆ computeBadPixelPercent()

double cv::ximgproc::computeBadPixelPercent	(	InputArray	GT,
		InputArray	src,
		Rect	ROI,
		int	thresh = `24`
	)

Python:
	cv.ximgproc.computeBadPixelPercent(	GT, src, ROI[, thresh]	) ->	retval

Function for computing the percent of "bad" pixels in the disparity map (pixels where error is higher than a specified threshold)

Parameters

GT	ground truth disparity map
src	disparity map to evaluate
ROI	region of interest
thresh	threshold used to determine "bad" pixels

Returns: returns mean square error between GT and src

◆ computeMSE()

double cv::ximgproc::computeMSE	(	InputArray	GT,
		InputArray	src,
		Rect	ROI
	)

Python:
	cv.ximgproc.computeMSE(	GT, src, ROI	) ->	retval

Function for computing mean square error for disparity maps.

Parameters

GT	ground truth disparity map
src	disparity map to evaluate
ROI	region of interest

Returns: returns mean square error between GT and src

◆ createAMFilter()

Ptr<AdaptiveManifoldFilter> cv::ximgproc::createAMFilter	(	double	sigma_s,
		double	sigma_r,
		bool	adjust_outliers = `false`
	)

Python:
	cv.ximgproc.createAMFilter(	sigma_s, sigma_r[, adjust_outliers]	) ->	retval

Factory method, create instance of AdaptiveManifoldFilter and produce some initialization routines.

Parameters

sigma_s	spatial standard deviation.
sigma_r	color space standard deviation, it is similar to the sigma in the color space into bilateralFilter.
adjust_outliers	optional, specify perform outliers adjust operation or not, (Eq. 9) in the original paper.

For more details about Adaptive Manifold Filter parameters, see the original article [100] .

Note: Joint images with CV_8U and CV_16U depth converted to images with CV_32F depth and [0; 1] color range before processing. Hence color space sigma sigma_r must be in [0; 1] range, unlike same sigmas in bilateralFilter and dtFilter functions.

◆ createDisparityWLSFilter()

Ptr<DisparityWLSFilter> cv::ximgproc::createDisparityWLSFilter ( Ptr< StereoMatcher > matcher_left )

Python:
	cv.ximgproc.createDisparityWLSFilter(	matcher_left	) ->	retval

Convenience factory method that creates an instance of DisparityWLSFilter and sets up all the relevant filter parameters automatically based on the matcher instance. Currently supports only StereoBM and StereoSGBM.

Parameters

matcher_left stereo matcher instance that will be used with the filter

◆ createDisparityWLSFilterGeneric()

Ptr<DisparityWLSFilter> cv::ximgproc::createDisparityWLSFilterGeneric ( bool use_confidence )

Python:
	cv.ximgproc.createDisparityWLSFilterGeneric(	use_confidence	) ->	retval

More generic factory method, create instance of DisparityWLSFilter and execute basic initialization routines. When using this method you will need to set-up the ROI, matchers and other parameters by yourself.

Parameters

use_confidence filtering with confidence requires two disparity maps (for the left and right views) and is approximately two times slower. However, quality is typically significantly better.

◆ createDTFilter()

Ptr<DTFilter> cv::ximgproc::createDTFilter	(	InputArray	guide,
		double	sigmaSpatial,
		double	sigmaColor,
		int	mode = `DTF_NC`,
		int	numIters = `3`
	)

Python:
	cv.ximgproc.createDTFilter(	guide, sigmaSpatial, sigmaColor[, mode[, numIters]]	) ->	retval

Factory method, create instance of DTFilter and produce initialization routines.

Parameters

guide	guided image (used to build transformed distance, which describes edge structure of guided image).
sigmaSpatial	\({\sigma}_H\) parameter in the original article, it's similar to the sigma in the coordinate space into bilateralFilter.
sigmaColor	\({\sigma}_r\) parameter in the original article, it's similar to the sigma in the color space into bilateralFilter.
mode	one form three modes DTF_NC, DTF_RF and DTF_IC which corresponds to three modes for filtering 2D signals in the article.
numIters	optional number of iterations used for filtering, 3 is quite enough.

For more details about Domain Transform filter parameters, see the original article [99] and Domain Transform filter homepage.

◆ createEdgeAwareInterpolator()

Ptr<EdgeAwareInterpolator> cv::ximgproc::createEdgeAwareInterpolator ( )

Python:
	cv.ximgproc.createEdgeAwareInterpolator(		) ->	retval

#include <opencv2/ximgproc/sparse_match_interpolator.hpp>

Factory method that creates an instance of the EdgeAwareInterpolator.

◆ createFastBilateralSolverFilter()

Ptr<FastBilateralSolverFilter> cv::ximgproc::createFastBilateralSolverFilter	(	InputArray	guide,
		double	sigma_spatial,
		double	sigma_luma,
		double	sigma_chroma,
		double	lambda = `128.0`,
		int	num_iter = `25`,
		double	max_tol = `1e-5`
	)

Python:
	cv.ximgproc.createFastBilateralSolverFilter(	guide, sigma_spatial, sigma_luma, sigma_chroma[, lambda_[, num_iter[, max_tol]]]	) ->	retval

Factory method, create instance of FastBilateralSolverFilter and execute the initialization routines.

Parameters

guide	image serving as guide for filtering. It should have 8-bit depth and either 1 or 3 channels.
sigma_spatial	parameter, that is similar to spatial space sigma (bandwidth) in bilateralFilter.
sigma_luma	parameter, that is similar to luma space sigma (bandwidth) in bilateralFilter.
sigma_chroma	parameter, that is similar to chroma space sigma (bandwidth) in bilateralFilter.
lambda	smoothness strength parameter for solver.
num_iter	number of iterations used for solver, 25 is usually enough.
max_tol	convergence tolerance used for solver.

For more details about the Fast Bilateral Solver parameters, see the original paper [19].

◆ createFastGlobalSmootherFilter()

Ptr<FastGlobalSmootherFilter> cv::ximgproc::createFastGlobalSmootherFilter	(	InputArray	guide,
		double	lambda,
		double	sigma_color,
		double	lambda_attenuation = `0.25`,
		int	num_iter = `3`
	)

Python:
	cv.ximgproc.createFastGlobalSmootherFilter(	guide, lambda_, sigma_color[, lambda_attenuation[, num_iter]]	) ->	retval

Factory method, create instance of FastGlobalSmootherFilter and execute the initialization routines.

Parameters

guide	image serving as guide for filtering. It should have 8-bit depth and either 1 or 3 channels.
lambda	parameter defining the amount of regularization
sigma_color	parameter, that is similar to color space sigma in bilateralFilter.
lambda_attenuation	internal parameter, defining how much lambda decreases after each iteration. Normally, it should be 0.25. Setting it to 1.0 may lead to streaking artifacts.
num_iter	number of iterations used for filtering, 3 is usually enough.

For more details about Fast Global Smoother parameters, see the original paper [189]. However, please note that there are several differences. Lambda attenuation described in the paper is implemented a bit differently so do not expect the results to be identical to those from the paper; sigma_color values from the paper should be multiplied by 255.0 to achieve the same effect. Also, in case of image filtering where source and guide image are the same, authors propose to dynamically update the guide image after each iteration. To maximize the performance this feature was not implemented here.

◆ createGuidedFilter()

Ptr<GuidedFilter> cv::ximgproc::createGuidedFilter	(	InputArray	guide,
		int	radius,
		double	eps
	)

Python:
	cv.ximgproc.createGuidedFilter(	guide, radius, eps	) ->	retval

Factory method, create instance of GuidedFilter and produce initialization routines.

Parameters

guide	guided image (or array of images) with up to 3 channels, if it have more then 3 channels then only first 3 channels will be used.
radius	radius of Guided Filter.
eps	regularization term of Guided Filter. \({eps}^2\) is similar to the sigma in the color space into bilateralFilter.

For more details about Guided Filter parameters, see the original article [118] .

◆ createQuaternionImage()

void cv::ximgproc::createQuaternionImage	(	InputArray	img,
		OutputArray	qimg
	)

Python:
	cv.ximgproc.createQuaternionImage(	img[, qimg]	) ->	qimg

creates a quaternion image.

Parameters

img	Source 8-bit, 32-bit or 64-bit image, with 3-channel image.
qimg	result CV_64FC4 a quaternion image( 4 chanels zero channel and B,G,R).

◆ createRICInterpolator()

Ptr<RICInterpolator> cv::ximgproc::createRICInterpolator ( )

Python:
	cv.ximgproc.createRICInterpolator(		) ->	retval

#include <opencv2/ximgproc/sparse_match_interpolator.hpp>

Factory method that creates an instance of the RICInterpolator.

◆ createRightMatcher()

Ptr<StereoMatcher> cv::ximgproc::createRightMatcher ( Ptr< StereoMatcher > matcher_left )

Python:
	cv.ximgproc.createRightMatcher(	matcher_left	) ->	retval

Convenience method to set up the matcher for computing the right-view disparity map that is required in case of filtering with confidence.

Parameters

matcher_left main stereo matcher instance that will be used with the filter

◆ dtFilter()

void cv::ximgproc::dtFilter	(	InputArray	guide,
		InputArray	src,
		OutputArray	dst,
		double	sigmaSpatial,
		double	sigmaColor,
		int	mode = `DTF_NC`,
		int	numIters = `3`
	)

Python:
	cv.ximgproc.dtFilter(	guide, src, sigmaSpatial, sigmaColor[, dst[, mode[, numIters]]]	) ->	dst

Simple one-line Domain Transform filter call. If you have multiple images to filter with the same guided image then use DTFilter interface to avoid extra computations on initialization stage.

Parameters

guide	guided image (also called as joint image) with unsigned 8-bit or floating-point 32-bit depth and up to 4 channels.
src	filtering image with unsigned 8-bit or floating-point 32-bit depth and up to 4 channels.
dst	destination image
sigmaSpatial	\({\sigma}_H\) parameter in the original article, it's similar to the sigma in the coordinate space into bilateralFilter.
sigmaColor	\({\sigma}_r\) parameter in the original article, it's similar to the sigma in the color space into bilateralFilter.
mode	one form three modes DTF_NC, DTF_RF and DTF_IC which corresponds to three modes for filtering 2D signals in the article.
numIters	optional number of iterations used for filtering, 3 is quite enough.

See also: bilateralFilter, guidedFilter, amFilter

◆ fastBilateralSolverFilter()

void cv::ximgproc::fastBilateralSolverFilter	(	InputArray	guide,
		InputArray	src,
		InputArray	confidence,
		OutputArray	dst,
		double	sigma_spatial = `8`,
		double	sigma_luma = `8`,
		double	sigma_chroma = `8`,
		double	lambda = `128.0`,
		int	num_iter = `25`,
		double	max_tol = `1e-5`
	)

Python:
	cv.ximgproc.fastBilateralSolverFilter(	guide, src, confidence[, dst[, sigma_spatial[, sigma_luma[, sigma_chroma[, lambda_[, num_iter[, max_tol]]]]]]]	) ->	dst

Simple one-line Fast Bilateral Solver filter call. If you have multiple images to filter with the same guide then use FastBilateralSolverFilter interface to avoid extra computations.

Parameters

guide	image serving as guide for filtering. It should have 8-bit depth and either 1 or 3 channels.
src	source image for filtering with unsigned 8-bit or signed 16-bit or floating-point 32-bit depth and up to 4 channels.
confidence	confidence image with unsigned 8-bit or floating-point 32-bit confidence and 1 channel.
dst	destination image.
sigma_spatial	parameter, that is similar to spatial space sigma (bandwidth) in bilateralFilter.
sigma_luma	parameter, that is similar to luma space sigma (bandwidth) in bilateralFilter.
sigma_chroma	parameter, that is similar to chroma space sigma (bandwidth) in bilateralFilter.
lambda	smoothness strength parameter for solver.
num_iter	number of iterations used for solver, 25 is usually enough.
max_tol	convergence tolerance used for solver.

For more details about the Fast Bilateral Solver parameters, see the original paper [19].

Note: Confidence images with CV_8U depth are expected to in [0, 255] and CV_32F in [0, 1] range.

◆ fastGlobalSmootherFilter()

void cv::ximgproc::fastGlobalSmootherFilter	(	InputArray	guide,
		InputArray	src,
		OutputArray	dst,
		double	lambda,
		double	sigma_color,
		double	lambda_attenuation = `0.25`,
		int	num_iter = `3`
	)

Python:
	cv.ximgproc.fastGlobalSmootherFilter(	guide, src, lambda_, sigma_color[, dst[, lambda_attenuation[, num_iter]]]	) ->	dst

Simple one-line Fast Global Smoother filter call. If you have multiple images to filter with the same guide then use FastGlobalSmootherFilter interface to avoid extra computations.

Parameters

guide	image serving as guide for filtering. It should have 8-bit depth and either 1 or 3 channels.
src	source image for filtering with unsigned 8-bit or signed 16-bit or floating-point 32-bit depth and up to 4 channels.
dst	destination image.
lambda	parameter defining the amount of regularization
sigma_color	parameter, that is similar to color space sigma in bilateralFilter.
lambda_attenuation	internal parameter, defining how much lambda decreases after each iteration. Normally, it should be 0.25. Setting it to 1.0 may lead to streaking artifacts.
num_iter	number of iterations used for filtering, 3 is usually enough.

◆ getDisparityVis()

void cv::ximgproc::getDisparityVis	(	InputArray	src,
		OutputArray	dst,
		double	scale = `1.0`
	)

Python:
	cv.ximgproc.getDisparityVis(	src[, dst[, scale]]	) ->	dst

Function for creating a disparity map visualization (clamped CV_8U image)

Parameters

src	input disparity map (CV_16S depth)
dst	output visualization
scale	disparity map will be multiplied by this value for visualization

◆ GradientDericheX()

void cv::ximgproc::GradientDericheX	(	InputArray	op,
		OutputArray	dst,
		double	alpha,
		double	omega
	)

Python:
	cv.ximgproc.GradientDericheX(	op, alpha, omega[, dst]	) ->	dst

#include <opencv2/ximgproc/deriche_filter.hpp>

Applies X Deriche filter to an image.

For more details about this implementation, please see http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.476.5736&rep=rep1&type=pdf

Parameters

op	Source 8-bit or 16bit image, 1-channel or 3-channel image.
dst	result CV_32FC image with same number of channel than _op.
alpha	double see paper
omega	double see paper

◆ GradientDericheY()

void cv::ximgproc::GradientDericheY	(	InputArray	op,
		OutputArray	dst,
		double	alpha,
		double	omega
	)

Python:
	cv.ximgproc.GradientDericheY(	op, alpha, omega[, dst]	) ->	dst

#include <opencv2/ximgproc/deriche_filter.hpp>

Applies Y Deriche filter to an image.

For more details about this implementation, please see http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.476.5736&rep=rep1&type=pdf

Parameters

op	Source 8-bit or 16bit image, 1-channel or 3-channel image.
dst	result CV_32FC image with same number of channel than _op.
alpha	double see paper
omega	double see paper

◆ GradientPaillouX()

void cv::ximgproc::GradientPaillouX	(	InputArray	op,
		OutputArray	_dst,
		double	alpha,
		double	omega
	)

#include <opencv2/ximgproc/paillou_filter.hpp>

◆ GradientPaillouY()

void cv::ximgproc::GradientPaillouY	(	InputArray	op,
		OutputArray	_dst,
		double	alpha,
		double	omega
	)

#include <opencv2/ximgproc/paillou_filter.hpp>

Applies Paillou filter to an image.

For more details about this implementation, please see [207]

Parameters

op	Source CV_8U(S) or CV_16U(S), 1-channel or 3-channels image.
_dst	result CV_32F image with same number of channel than op.
omega	double see paper
alpha	double see paper

See also: GradientPaillouX, GradientPaillouY

◆ guidedFilter()

void cv::ximgproc::guidedFilter	(	InputArray	guide,
		InputArray	src,
		OutputArray	dst,
		int	radius,
		double	eps,
		int	dDepth = `-1`
	)

Python:
	cv.ximgproc.guidedFilter(	guide, src, radius, eps[, dst[, dDepth]]	) ->	dst

Simple one-line Guided Filter call.

If you have multiple images to filter with the same guided image then use GuidedFilter interface to avoid extra computations on initialization stage.

Parameters

guide	guided image (or array of images) with up to 3 channels, if it have more then 3 channels then only first 3 channels will be used.
src	filtering image with any numbers of channels.
dst	output image.
radius	radius of Guided Filter.
eps	regularization term of Guided Filter. \({eps}^2\) is similar to the sigma in the color space into bilateralFilter.
dDepth	optional depth of the output image.

See also: bilateralFilter, dtFilter, amFilter

◆ jointBilateralFilter()

void cv::ximgproc::jointBilateralFilter	(	InputArray	joint,
		InputArray	src,
		OutputArray	dst,
		int	d,
		double	sigmaColor,
		double	sigmaSpace,
		int	borderType = `BORDER_DEFAULT`
	)

Python:
	cv.ximgproc.jointBilateralFilter(	joint, src, d, sigmaColor, sigmaSpace[, dst[, borderType]]	) ->	dst

Applies the joint bilateral filter to an image.

Parameters

joint	Joint 8-bit or floating-point, 1-channel or 3-channel image.
src	Source 8-bit or floating-point, 1-channel or 3-channel image with the same depth as joint image.
dst	Destination image of the same size and type as src .
d	Diameter of each pixel neighborhood that is used during filtering. If it is non-positive, it is computed from sigmaSpace .
sigmaColor	Filter sigma in the color space. A larger value of the parameter means that farther colors within the pixel neighborhood (see sigmaSpace ) will be mixed together, resulting in larger areas of semi-equal color.
sigmaSpace	Filter sigma in the coordinate space. A larger value of the parameter means that farther pixels will influence each other as long as their colors are close enough (see sigmaColor ). When d>0 , it specifies the neighborhood size regardless of sigmaSpace . Otherwise, d is proportional to sigmaSpace .
borderType

Note: bilateralFilter and jointBilateralFilter use L1 norm to compute difference between colors.

See also: bilateralFilter, amFilter

◆ l0Smooth()

void cv::ximgproc::l0Smooth	(	InputArray	src,
		OutputArray	dst,
		double	lambda = `0.02`,
		double	kappa = `2.0`
	)

Python:
	cv.ximgproc.l0Smooth(	src[, dst[, lambda_[, kappa]]]	) ->	dst

Global image smoothing via L0 gradient minimization.

Parameters

src	source image for filtering with unsigned 8-bit or signed 16-bit or floating-point depth.
dst	destination image.
lambda	parameter defining the smooth term weight.
kappa	parameter defining the increasing factor of the weight of the gradient data term.

For more details about L0 Smoother, see the original paper [301].

◆ qconj()

void cv::ximgproc::qconj	(	InputArray	qimg,
		OutputArray	qcimg
	)

Python:
	cv.ximgproc.qconj(	qimg[, qcimg]	) ->	qcimg

calculates conjugate of a quaternion image.

Parameters

qimg	quaternion image.
qcimg	conjugate of qimg

◆ qdft()

void cv::ximgproc::qdft	(	InputArray	img,
		OutputArray	qimg,
		int	flags,
		bool	sideLeft
	)

Python:
	cv.ximgproc.qdft(	img, flags, sideLeft[, qimg]	) ->	qimg

Performs a forward or inverse Discrete quaternion Fourier transform of a 2D quaternion array.

Parameters

img	quaternion image.
qimg	quaternion image in dual space.
flags	quaternion image in dual space. only DFT_INVERSE flags is supported
sideLeft	true the hypercomplex exponential is to be multiplied on the left (false on the right ).

◆ qmultiply()

void cv::ximgproc::qmultiply	(	InputArray	src1,
		InputArray	src2,
		OutputArray	dst
	)

Python:
	cv.ximgproc.qmultiply(	src1, src2[, dst]	) ->	dst

Calculates the per-element quaternion product of two arrays.

Parameters

src1	quaternion image.
src2	quaternion image.
dst	product dst(I)=src1(I) . src2(I)

◆ qunitary()

void cv::ximgproc::qunitary	(	InputArray	qimg,
		OutputArray	qnimg
	)

Python:
	cv.ximgproc.qunitary(	qimg[, qnimg]	) ->	qnimg

divides each element by its modulus.

Parameters

qimg	quaternion image.
qnimg	conjugate of qimg

◆ readGT()

int cv::ximgproc::readGT	(	String	src_path,
		OutputArray	dst
	)

Python:
	cv.ximgproc.readGT(	src_path[, dst]	) ->	retval, dst

Function for reading ground truth disparity maps. Supports basic Middlebury and MPI-Sintel formats. Note that the resulting disparity map is scaled by 16.

Parameters

src_path	path to the image, containing ground-truth disparity map
dst	output disparity map, CV_16S depth

Returns: returns zero if successfully read the ground truth

◆ rollingGuidanceFilter()

void cv::ximgproc::rollingGuidanceFilter	(	InputArray	src,
		OutputArray	dst,
		int	d = `-1`,
		double	sigmaColor = `25`,
		double	sigmaSpace = `3`,
		int	numOfIter = `4`,
		int	borderType = `BORDER_DEFAULT`
	)

Python:
	cv.ximgproc.rollingGuidanceFilter(	src[, dst[, d[, sigmaColor[, sigmaSpace[, numOfIter[, borderType]]]]]]	) ->	dst