Static Public Member Functions
static void	colorChange (Mat src, Mat mask, Mat dst)
	Given an original color image, two differently colored versions of this image can be mixed seamlessly.

static void	colorChange (Mat src, Mat mask, Mat dst, float red_mul)
	Given an original color image, two differently colored versions of this image can be mixed seamlessly.

static void	colorChange (Mat src, Mat mask, Mat dst, float red_mul, float green_mul)
	Given an original color image, two differently colored versions of this image can be mixed seamlessly.

static void	colorChange (Mat src, Mat mask, Mat dst, float red_mul, float green_mul, float blue_mul)
	Given an original color image, two differently colored versions of this image can be mixed seamlessly.

static AlignMTB	createAlignMTB ()
	Creates AlignMTB object.

static AlignMTB	createAlignMTB (int max_bits)
	Creates AlignMTB object.

static AlignMTB	createAlignMTB (int max_bits, int exclude_range)
	Creates AlignMTB object.

static AlignMTB	createAlignMTB (int max_bits, int exclude_range, bool cut)
	Creates AlignMTB object.

static CalibrateDebevec	createCalibrateDebevec ()
	Creates CalibrateDebevec object.

static CalibrateDebevec	createCalibrateDebevec (int samples)
	Creates CalibrateDebevec object.

static CalibrateDebevec	createCalibrateDebevec (int samples, float lambda)
	Creates CalibrateDebevec object.

static CalibrateDebevec	createCalibrateDebevec (int samples, float lambda, bool random)
	Creates CalibrateDebevec object.

static CalibrateRobertson	createCalibrateRobertson ()
	Creates CalibrateRobertson object.

static CalibrateRobertson	createCalibrateRobertson (int max_iter)
	Creates CalibrateRobertson object.

static CalibrateRobertson	createCalibrateRobertson (int max_iter, float threshold)
	Creates CalibrateRobertson object.

static MergeDebevec	createMergeDebevec ()
	Creates MergeDebevec object.

static MergeMertens	createMergeMertens ()
	Creates MergeMertens object.

static MergeMertens	createMergeMertens (float contrast_weight)
	Creates MergeMertens object.

static MergeMertens	createMergeMertens (float contrast_weight, float saturation_weight)
	Creates MergeMertens object.

static MergeMertens	createMergeMertens (float contrast_weight, float saturation_weight, float exposure_weight)
	Creates MergeMertens object.

static MergeRobertson	createMergeRobertson ()
	Creates MergeRobertson object.

static Tonemap	createTonemap ()
	Creates simple linear mapper with gamma correction.

static Tonemap	createTonemap (float gamma)
	Creates simple linear mapper with gamma correction.

static TonemapDrago	createTonemapDrago ()
	Creates TonemapDrago object.

static TonemapDrago	createTonemapDrago (float gamma)
	Creates TonemapDrago object.

static TonemapDrago	createTonemapDrago (float gamma, float saturation)
	Creates TonemapDrago object.

static TonemapDrago	createTonemapDrago (float gamma, float saturation, float bias)
	Creates TonemapDrago object.

static TonemapMantiuk	createTonemapMantiuk ()
	Creates TonemapMantiuk object.

static TonemapMantiuk	createTonemapMantiuk (float gamma)
	Creates TonemapMantiuk object.

static TonemapMantiuk	createTonemapMantiuk (float gamma, float scale)
	Creates TonemapMantiuk object.

static TonemapMantiuk	createTonemapMantiuk (float gamma, float scale, float saturation)
	Creates TonemapMantiuk object.

static TonemapReinhard	createTonemapReinhard ()
	Creates TonemapReinhard object.

static TonemapReinhard	createTonemapReinhard (float gamma)
	Creates TonemapReinhard object.

static TonemapReinhard	createTonemapReinhard (float gamma, float intensity)
	Creates TonemapReinhard object.

static TonemapReinhard	createTonemapReinhard (float gamma, float intensity, float light_adapt)
	Creates TonemapReinhard object.

static TonemapReinhard	createTonemapReinhard (float gamma, float intensity, float light_adapt, float color_adapt)
	Creates TonemapReinhard object.

static void	decolor (Mat src, Mat grayscale, Mat color_boost)
	Transforms a color image to a grayscale image. It is a basic tool in digital printing, stylized black-and-white photograph rendering, and in many single channel image processing applications [CL12] .

static void	denoise_TVL1 (List< Mat > observations, Mat result)
	Primal-dual algorithm is an algorithm for solving special types of variational problems (that is, finding a function to minimize some functional). As the image denoising, in particular, may be seen as the variational problem, primal-dual algorithm then can be used to perform denoising and this is exactly what is implemented.

static void	denoise_TVL1 (List< Mat > observations, Mat result, double lambda)
	Primal-dual algorithm is an algorithm for solving special types of variational problems (that is, finding a function to minimize some functional). As the image denoising, in particular, may be seen as the variational problem, primal-dual algorithm then can be used to perform denoising and this is exactly what is implemented.

static void	denoise_TVL1 (List< Mat > observations, Mat result, double lambda, int niters)
	Primal-dual algorithm is an algorithm for solving special types of variational problems (that is, finding a function to minimize some functional). As the image denoising, in particular, may be seen as the variational problem, primal-dual algorithm then can be used to perform denoising and this is exactly what is implemented.

static void	detailEnhance (Mat src, Mat dst)
	This filter enhances the details of a particular image.

static void	detailEnhance (Mat src, Mat dst, float sigma_s)
	This filter enhances the details of a particular image.

static void	detailEnhance (Mat src, Mat dst, float sigma_s, float sigma_r)
	This filter enhances the details of a particular image.

static void	edgePreservingFilter (Mat src, Mat dst)
	Filtering is the fundamental operation in image and video processing. Edge-preserving smoothing filters are used in many different applications [EM11] .

static void	edgePreservingFilter (Mat src, Mat dst, int flags)
	Filtering is the fundamental operation in image and video processing. Edge-preserving smoothing filters are used in many different applications [EM11] .

static void	edgePreservingFilter (Mat src, Mat dst, int flags, float sigma_s)
	Filtering is the fundamental operation in image and video processing. Edge-preserving smoothing filters are used in many different applications [EM11] .

static void	edgePreservingFilter (Mat src, Mat dst, int flags, float sigma_s, float sigma_r)
	Filtering is the fundamental operation in image and video processing. Edge-preserving smoothing filters are used in many different applications [EM11] .

static void	fastNlMeansDenoising (Mat src, Mat dst)
	Perform image denoising using Non-local Means Denoising algorithm <http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/> with several computational optimizations. Noise expected to be a gaussian white noise.

static void	fastNlMeansDenoising (Mat src, Mat dst, float h)
	Perform image denoising using Non-local Means Denoising algorithm <http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/> with several computational optimizations. Noise expected to be a gaussian white noise.

static void	fastNlMeansDenoising (Mat src, Mat dst, float h, int templateWindowSize)
	Perform image denoising using Non-local Means Denoising algorithm <http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/> with several computational optimizations. Noise expected to be a gaussian white noise.

static void	fastNlMeansDenoising (Mat src, Mat dst, float h, int templateWindowSize, int searchWindowSize)
	Perform image denoising using Non-local Means Denoising algorithm <http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/> with several computational optimizations. Noise expected to be a gaussian white noise.

static void	fastNlMeansDenoising (Mat src, Mat dst, MatOfFloat h)
	Perform image denoising using Non-local Means Denoising algorithm <http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/> with several computational optimizations. Noise expected to be a gaussian white noise.

static void	fastNlMeansDenoising (Mat src, Mat dst, MatOfFloat h, int templateWindowSize)
	Perform image denoising using Non-local Means Denoising algorithm <http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/> with several computational optimizations. Noise expected to be a gaussian white noise.

static void	fastNlMeansDenoising (Mat src, Mat dst, MatOfFloat h, int templateWindowSize, int searchWindowSize)
	Perform image denoising using Non-local Means Denoising algorithm <http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/> with several computational optimizations. Noise expected to be a gaussian white noise.

static void	fastNlMeansDenoising (Mat src, Mat dst, MatOfFloat h, int templateWindowSize, int searchWindowSize, int normType)
	Perform image denoising using Non-local Means Denoising algorithm <http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/> with several computational optimizations. Noise expected to be a gaussian white noise.

static void	fastNlMeansDenoisingColored (Mat src, Mat dst)
	Modification of fastNlMeansDenoising function for colored images.

static void	fastNlMeansDenoisingColored (Mat src, Mat dst, float h)
	Modification of fastNlMeansDenoising function for colored images.

static void	fastNlMeansDenoisingColored (Mat src, Mat dst, float h, float hColor)
	Modification of fastNlMeansDenoising function for colored images.

static void	fastNlMeansDenoisingColored (Mat src, Mat dst, float h, float hColor, int templateWindowSize)
	Modification of fastNlMeansDenoising function for colored images.

static void	fastNlMeansDenoisingColored (Mat src, Mat dst, float h, float hColor, int templateWindowSize, int searchWindowSize)
	Modification of fastNlMeansDenoising function for colored images.

static void	fastNlMeansDenoisingColoredMulti (List< Mat > srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize)
	Modification of fastNlMeansDenoisingMulti function for colored images sequences.

static void	fastNlMeansDenoisingColoredMulti (List< Mat > srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h)
	Modification of fastNlMeansDenoisingMulti function for colored images sequences.

static void	fastNlMeansDenoisingColoredMulti (List< Mat > srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor)
	Modification of fastNlMeansDenoisingMulti function for colored images sequences.

static void	fastNlMeansDenoisingColoredMulti (List< Mat > srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize)
	Modification of fastNlMeansDenoisingMulti function for colored images sequences.

static void	fastNlMeansDenoisingColoredMulti (List< Mat > srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize)
	Modification of fastNlMeansDenoisingMulti function for colored images sequences.

static void	fastNlMeansDenoisingMulti (List< Mat > srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize)
	Modification of fastNlMeansDenoising function for images sequence where consecutive images have been captured in small period of time. For example video. This version of the function is for grayscale images or for manual manipulation with colorspaces. See [Buades2005DenoisingIS] for more details (open access here).

static void	fastNlMeansDenoisingMulti (List< Mat > srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h)
	Modification of fastNlMeansDenoising function for images sequence where consecutive images have been captured in small period of time. For example video. This version of the function is for grayscale images or for manual manipulation with colorspaces. See [Buades2005DenoisingIS] for more details (open access here).

static void	fastNlMeansDenoisingMulti (List< Mat > srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize)
	Modification of fastNlMeansDenoising function for images sequence where consecutive images have been captured in small period of time. For example video. This version of the function is for grayscale images or for manual manipulation with colorspaces. See [Buades2005DenoisingIS] for more details (open access here).

static void	fastNlMeansDenoisingMulti (List< Mat > srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize)
	Modification of fastNlMeansDenoising function for images sequence where consecutive images have been captured in small period of time. For example video. This version of the function is for grayscale images or for manual manipulation with colorspaces. See [Buades2005DenoisingIS] for more details (open access here).

static void	fastNlMeansDenoisingMulti (List< Mat > srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, MatOfFloat h)
	Modification of fastNlMeansDenoising function for images sequence where consecutive images have been captured in small period of time. For example video. This version of the function is for grayscale images or for manual manipulation with colorspaces. See [Buades2005DenoisingIS] for more details (open access here).

static void	fastNlMeansDenoisingMulti (List< Mat > srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, MatOfFloat h, int templateWindowSize)
	Modification of fastNlMeansDenoising function for images sequence where consecutive images have been captured in small period of time. For example video. This version of the function is for grayscale images or for manual manipulation with colorspaces. See [Buades2005DenoisingIS] for more details (open access here).

static void	fastNlMeansDenoisingMulti (List< Mat > srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, MatOfFloat h, int templateWindowSize, int searchWindowSize)
	Modification of fastNlMeansDenoising function for images sequence where consecutive images have been captured in small period of time. For example video. This version of the function is for grayscale images or for manual manipulation with colorspaces. See [Buades2005DenoisingIS] for more details (open access here).

static void	fastNlMeansDenoisingMulti (List< Mat > srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, MatOfFloat h, int templateWindowSize, int searchWindowSize, int normType)
	Modification of fastNlMeansDenoising function for images sequence where consecutive images have been captured in small period of time. For example video. This version of the function is for grayscale images or for manual manipulation with colorspaces. See [Buades2005DenoisingIS] for more details (open access here).

static void	illuminationChange (Mat src, Mat mask, Mat dst)
	Applying an appropriate non-linear transformation to the gradient field inside the selection and then integrating back with a Poisson solver, modifies locally the apparent illumination of an image.

static void	illuminationChange (Mat src, Mat mask, Mat dst, float alpha)
	Applying an appropriate non-linear transformation to the gradient field inside the selection and then integrating back with a Poisson solver, modifies locally the apparent illumination of an image.

static void	illuminationChange (Mat src, Mat mask, Mat dst, float alpha, float beta)
	Applying an appropriate non-linear transformation to the gradient field inside the selection and then integrating back with a Poisson solver, modifies locally the apparent illumination of an image.

static void	inpaint (Mat src, Mat inpaintMask, Mat dst, double inpaintRadius, int flags)
	Restores the selected region in an image using the region neighborhood.

static void	pencilSketch (Mat src, Mat dst1, Mat dst2)
	Pencil-like non-photorealistic line drawing.

static void	pencilSketch (Mat src, Mat dst1, Mat dst2, float sigma_s)
	Pencil-like non-photorealistic line drawing.

static void	pencilSketch (Mat src, Mat dst1, Mat dst2, float sigma_s, float sigma_r)
	Pencil-like non-photorealistic line drawing.

static void	pencilSketch (Mat src, Mat dst1, Mat dst2, float sigma_s, float sigma_r, float shade_factor)
	Pencil-like non-photorealistic line drawing.

static void	seamlessClone (Mat src, Mat dst, Mat mask, in Vec2d p, Mat blend, int flags)
	Image editing tasks concern either global changes (color/intensity corrections, filters, deformations) or local changes concerned to a selection. Here we are interested in achieving local changes, ones that are restricted to a region manually selected (ROI), in a seamless and effortless manner. The extent of the changes ranges from slight distortions to complete replacement by novel content [PM03] .

static void	seamlessClone (Mat src, Mat dst, Mat mask, in(double x, double y) p, Mat blend, int flags)
	Image editing tasks concern either global changes (color/intensity corrections, filters, deformations) or local changes concerned to a selection. Here we are interested in achieving local changes, ones that are restricted to a region manually selected (ROI), in a seamless and effortless manner. The extent of the changes ranges from slight distortions to complete replacement by novel content [PM03] .

static void	seamlessClone (Mat src, Mat dst, Mat mask, Point p, Mat blend, int flags)
	Image editing tasks concern either global changes (color/intensity corrections, filters, deformations) or local changes concerned to a selection. Here we are interested in achieving local changes, ones that are restricted to a region manually selected (ROI), in a seamless and effortless manner. The extent of the changes ranges from slight distortions to complete replacement by novel content [PM03] .

static void	stylization (Mat src, Mat dst)
	Stylization aims to produce digital imagery with a wide variety of effects not focused on photorealism. Edge-aware filters are ideal for stylization, as they can abstract regions of low contrast while preserving, or enhancing, high-contrast features.

static void	stylization (Mat src, Mat dst, float sigma_s)
	Stylization aims to produce digital imagery with a wide variety of effects not focused on photorealism. Edge-aware filters are ideal for stylization, as they can abstract regions of low contrast while preserving, or enhancing, high-contrast features.

static void	stylization (Mat src, Mat dst, float sigma_s, float sigma_r)
	Stylization aims to produce digital imagery with a wide variety of effects not focused on photorealism. Edge-aware filters are ideal for stylization, as they can abstract regions of low contrast while preserving, or enhancing, high-contrast features.

static void	textureFlattening (Mat src, Mat mask, Mat dst)
	By retaining only the gradients at edge locations, before integrating with the Poisson solver, one washes out the texture of the selected region, giving its contents a flat aspect. Here Canny Edge Detector is used.

static void	textureFlattening (Mat src, Mat mask, Mat dst, float low_threshold)
	By retaining only the gradients at edge locations, before integrating with the Poisson solver, one washes out the texture of the selected region, giving its contents a flat aspect. Here Canny Edge Detector is used.

static void	textureFlattening (Mat src, Mat mask, Mat dst, float low_threshold, float high_threshold)
	By retaining only the gradients at edge locations, before integrating with the Poisson solver, one washes out the texture of the selected region, giving its contents a flat aspect. Here Canny Edge Detector is used.

static void	textureFlattening (Mat src, Mat mask, Mat dst, float low_threshold, float high_threshold, int kernel_size)
	By retaining only the gradients at edge locations, before integrating with the Poisson solver, one washes out the texture of the selected region, giving its contents a flat aspect. Here Canny Edge Detector is used.

Static Public Attributes
const int	INPAINT_NS = 0

const int	INPAINT_TELEA = 1

const int	LDR_SIZE = 256

const int	MIXED_CLONE = 2

const int	MONOCHROME_TRANSFER = 3

const int	NORMAL_CLONE = 1

const int	NORMCONV_FILTER = 2

const int	RECURS_FILTER = 1

Member Function Documentation

◆ colorChange() [1/4]

static void OpenCVForUnity.PhotoModule.Photo.colorChange	(	Mat	src,
		Mat	mask,
		Mat	dst )

static

Given an original color image, two differently colored versions of this image can be mixed seamlessly.

Parameters

src	Input 8-bit 3-channel image.
mask	Input 8-bit 1 or 3-channel image.
dst	Output image with the same size and type as src .
red_mul	R-channel multiply factor.
green_mul	G-channel multiply factor.
blue_mul	B-channel multiply factor.

Multiplication factor is between .5 to 2.5.

◆ colorChange() [2/4]

static void OpenCVForUnity.PhotoModule.Photo.colorChange	(	Mat	src,
		Mat	mask,
		Mat	dst,
		float	red_mul )

static

Given an original color image, two differently colored versions of this image can be mixed seamlessly.

Parameters

src	Input 8-bit 3-channel image.
mask	Input 8-bit 1 or 3-channel image.
dst	Output image with the same size and type as src .
red_mul	R-channel multiply factor.
green_mul	G-channel multiply factor.
blue_mul	B-channel multiply factor.

Multiplication factor is between .5 to 2.5.

◆ colorChange() [3/4]

static void OpenCVForUnity.PhotoModule.Photo.colorChange	(	Mat	src,
		Mat	mask,
		Mat	dst,
		float	red_mul,
		float	green_mul )

static

Given an original color image, two differently colored versions of this image can be mixed seamlessly.

Parameters

src	Input 8-bit 3-channel image.
mask	Input 8-bit 1 or 3-channel image.
dst	Output image with the same size and type as src .
red_mul	R-channel multiply factor.
green_mul	G-channel multiply factor.
blue_mul	B-channel multiply factor.

Multiplication factor is between .5 to 2.5.

◆ colorChange() [4/4]

static void OpenCVForUnity.PhotoModule.Photo.colorChange	(	Mat	src,
		Mat	mask,
		Mat	dst,
		float	red_mul,
		float	green_mul,
		float	blue_mul )

static

Given an original color image, two differently colored versions of this image can be mixed seamlessly.

Parameters

src	Input 8-bit 3-channel image.
mask	Input 8-bit 1 or 3-channel image.
dst	Output image with the same size and type as src .
red_mul	R-channel multiply factor.
green_mul	G-channel multiply factor.
blue_mul	B-channel multiply factor.

Multiplication factor is between .5 to 2.5.

◆ createAlignMTB() [1/4]

static AlignMTB OpenCVForUnity.PhotoModule.Photo.createAlignMTB ( )

static

Creates AlignMTB object.

Parameters

max_bits	logarithm to the base 2 of maximal shift in each dimension. Values of 5 and 6 are usually good enough (31 and 63 pixels shift respectively).
exclude_range	range for exclusion bitmap that is constructed to suppress noise around the median value.
cut	if true cuts images, otherwise fills the new regions with zeros.

◆ createAlignMTB() [2/4]

static AlignMTB OpenCVForUnity.PhotoModule.Photo.createAlignMTB ( int max_bits )

static

Creates AlignMTB object.

Parameters

max_bits	logarithm to the base 2 of maximal shift in each dimension. Values of 5 and 6 are usually good enough (31 and 63 pixels shift respectively).
exclude_range	range for exclusion bitmap that is constructed to suppress noise around the median value.
cut	if true cuts images, otherwise fills the new regions with zeros.

◆ createAlignMTB() [3/4]

static AlignMTB OpenCVForUnity.PhotoModule.Photo.createAlignMTB	(	int	max_bits,
		int	exclude_range )

static

Creates AlignMTB object.

Parameters

max_bits	logarithm to the base 2 of maximal shift in each dimension. Values of 5 and 6 are usually good enough (31 and 63 pixels shift respectively).
exclude_range	range for exclusion bitmap that is constructed to suppress noise around the median value.
cut	if true cuts images, otherwise fills the new regions with zeros.

◆ createAlignMTB() [4/4]

static AlignMTB OpenCVForUnity.PhotoModule.Photo.createAlignMTB	(	int	max_bits,
		int	exclude_range,
		bool	cut )

static

Creates AlignMTB object.

Parameters

max_bits	logarithm to the base 2 of maximal shift in each dimension. Values of 5 and 6 are usually good enough (31 and 63 pixels shift respectively).
exclude_range	range for exclusion bitmap that is constructed to suppress noise around the median value.
cut	if true cuts images, otherwise fills the new regions with zeros.

◆ createCalibrateDebevec() [1/4]

static CalibrateDebevec OpenCVForUnity.PhotoModule.Photo.createCalibrateDebevec ( )

static

Creates CalibrateDebevec object.

Parameters

samples	number of pixel locations to use
lambda	smoothness term weight. Greater values produce smoother results, but can alter the response.
random	if true sample pixel locations are chosen at random, otherwise they form a rectangular grid.

◆ createCalibrateDebevec() [2/4]

static CalibrateDebevec OpenCVForUnity.PhotoModule.Photo.createCalibrateDebevec ( int samples )

static

Creates CalibrateDebevec object.

Parameters

samples	number of pixel locations to use
lambda	smoothness term weight. Greater values produce smoother results, but can alter the response.
random	if true sample pixel locations are chosen at random, otherwise they form a rectangular grid.

◆ createCalibrateDebevec() [3/4]

static CalibrateDebevec OpenCVForUnity.PhotoModule.Photo.createCalibrateDebevec	(	int	samples,
		float	lambda )

static

Creates CalibrateDebevec object.

Parameters

samples	number of pixel locations to use
lambda	smoothness term weight. Greater values produce smoother results, but can alter the response.
random	if true sample pixel locations are chosen at random, otherwise they form a rectangular grid.

◆ createCalibrateDebevec() [4/4]

static CalibrateDebevec OpenCVForUnity.PhotoModule.Photo.createCalibrateDebevec	(	int	samples,
		float	lambda,
		bool	random )

static

Creates CalibrateDebevec object.

Parameters

samples	number of pixel locations to use
lambda	smoothness term weight. Greater values produce smoother results, but can alter the response.
random	if true sample pixel locations are chosen at random, otherwise they form a rectangular grid.

◆ createCalibrateRobertson() [1/3]

static CalibrateRobertson OpenCVForUnity.PhotoModule.Photo.createCalibrateRobertson ( )

static

Creates CalibrateRobertson object.

Parameters

max_iter	maximal number of Gauss-Seidel solver iterations.
threshold	target difference between results of two successive steps of the minimization.

◆ createCalibrateRobertson() [2/3]

static CalibrateRobertson OpenCVForUnity.PhotoModule.Photo.createCalibrateRobertson ( int max_iter )

static

Creates CalibrateRobertson object.

Parameters

max_iter	maximal number of Gauss-Seidel solver iterations.
threshold	target difference between results of two successive steps of the minimization.

◆ createCalibrateRobertson() [3/3]

static CalibrateRobertson OpenCVForUnity.PhotoModule.Photo.createCalibrateRobertson	(	int	max_iter,
		float	threshold )

static

Creates CalibrateRobertson object.

Parameters

max_iter	maximal number of Gauss-Seidel solver iterations.
threshold	target difference between results of two successive steps of the minimization.

◆ createMergeDebevec()

static MergeDebevec OpenCVForUnity.PhotoModule.Photo.createMergeDebevec ( )

static

Creates MergeDebevec object.

◆ createMergeMertens() [1/4]

static MergeMertens OpenCVForUnity.PhotoModule.Photo.createMergeMertens ( )

static

Creates MergeMertens object.

Parameters

contrast_weight	contrast measure weight. See MergeMertens.
saturation_weight	saturation measure weight
exposure_weight	well-exposedness measure weight

◆ createMergeMertens() [2/4]

static MergeMertens OpenCVForUnity.PhotoModule.Photo.createMergeMertens ( float contrast_weight )

static

Creates MergeMertens object.

Parameters

contrast_weight	contrast measure weight. See MergeMertens.
saturation_weight	saturation measure weight
exposure_weight	well-exposedness measure weight

◆ createMergeMertens() [3/4]

static MergeMertens OpenCVForUnity.PhotoModule.Photo.createMergeMertens	(	float	contrast_weight,
		float	saturation_weight )

static

Creates MergeMertens object.

Parameters

contrast_weight	contrast measure weight. See MergeMertens.
saturation_weight	saturation measure weight
exposure_weight	well-exposedness measure weight

◆ createMergeMertens() [4/4]

static MergeMertens OpenCVForUnity.PhotoModule.Photo.createMergeMertens	(	float	contrast_weight,
		float	saturation_weight,
		float	exposure_weight )

static

Creates MergeMertens object.

Parameters

contrast_weight	contrast measure weight. See MergeMertens.
saturation_weight	saturation measure weight
exposure_weight	well-exposedness measure weight

◆ createMergeRobertson()

static MergeRobertson OpenCVForUnity.PhotoModule.Photo.createMergeRobertson ( )

static

Creates MergeRobertson object.

◆ createTonemap() [1/2]

static Tonemap OpenCVForUnity.PhotoModule.Photo.createTonemap ( )

static

Creates simple linear mapper with gamma correction.

Parameters

gamma positive value for gamma correction. Gamma value of 1.0 implies no correction, gamma equal to 2.2f is suitable for most displays. Generally gamma > 1 brightens the image and gamma < 1 darkens it.

◆ createTonemap() [2/2]

static Tonemap OpenCVForUnity.PhotoModule.Photo.createTonemap ( float gamma )

static

Creates simple linear mapper with gamma correction.

Parameters

gamma positive value for gamma correction. Gamma value of 1.0 implies no correction, gamma equal to 2.2f is suitable for most displays. Generally gamma > 1 brightens the image and gamma < 1 darkens it.

◆ createTonemapDrago() [1/4]

static TonemapDrago OpenCVForUnity.PhotoModule.Photo.createTonemapDrago ( )

static

Creates TonemapDrago object.

Parameters

gamma	gamma value for gamma correction. See createTonemap
saturation	positive saturation enhancement value. 1.0 preserves saturation, values greater than 1 increase saturation and values less than 1 decrease it.
bias	value for bias function in [0, 1] range. Values from 0.7 to 0.9 usually give best results, default value is 0.85.

◆ createTonemapDrago() [2/4]

static TonemapDrago OpenCVForUnity.PhotoModule.Photo.createTonemapDrago ( float gamma )

static

Creates TonemapDrago object.

Parameters

gamma	gamma value for gamma correction. See createTonemap
saturation	positive saturation enhancement value. 1.0 preserves saturation, values greater than 1 increase saturation and values less than 1 decrease it.
bias	value for bias function in [0, 1] range. Values from 0.7 to 0.9 usually give best results, default value is 0.85.

◆ createTonemapDrago() [3/4]

static TonemapDrago OpenCVForUnity.PhotoModule.Photo.createTonemapDrago	(	float	gamma,
		float	saturation )

static

Creates TonemapDrago object.

Parameters

gamma	gamma value for gamma correction. See createTonemap
saturation	positive saturation enhancement value. 1.0 preserves saturation, values greater than 1 increase saturation and values less than 1 decrease it.
bias	value for bias function in [0, 1] range. Values from 0.7 to 0.9 usually give best results, default value is 0.85.

◆ createTonemapDrago() [4/4]

static TonemapDrago OpenCVForUnity.PhotoModule.Photo.createTonemapDrago	(	float	gamma,
		float	saturation,
		float	bias )

static

Creates TonemapDrago object.

Parameters

gamma	gamma value for gamma correction. See createTonemap
saturation	positive saturation enhancement value. 1.0 preserves saturation, values greater than 1 increase saturation and values less than 1 decrease it.
bias	value for bias function in [0, 1] range. Values from 0.7 to 0.9 usually give best results, default value is 0.85.

◆ createTonemapMantiuk() [1/4]

static TonemapMantiuk OpenCVForUnity.PhotoModule.Photo.createTonemapMantiuk ( )

static

Creates TonemapMantiuk object.

Parameters

gamma	gamma value for gamma correction. See createTonemap
scale	contrast scale factor. HVS response is multiplied by this parameter, thus compressing dynamic range. Values from 0.6 to 0.9 produce best results.
saturation	saturation enhancement value. See createTonemapDrago

◆ createTonemapMantiuk() [2/4]

static TonemapMantiuk OpenCVForUnity.PhotoModule.Photo.createTonemapMantiuk ( float gamma )

static

Creates TonemapMantiuk object.

Parameters

gamma	gamma value for gamma correction. See createTonemap
scale	contrast scale factor. HVS response is multiplied by this parameter, thus compressing dynamic range. Values from 0.6 to 0.9 produce best results.
saturation	saturation enhancement value. See createTonemapDrago

◆ createTonemapMantiuk() [3/4]

static TonemapMantiuk OpenCVForUnity.PhotoModule.Photo.createTonemapMantiuk	(	float	gamma,
		float	scale )

static

Creates TonemapMantiuk object.

Parameters

gamma	gamma value for gamma correction. See createTonemap
scale	contrast scale factor. HVS response is multiplied by this parameter, thus compressing dynamic range. Values from 0.6 to 0.9 produce best results.
saturation	saturation enhancement value. See createTonemapDrago

◆ createTonemapMantiuk() [4/4]

static TonemapMantiuk OpenCVForUnity.PhotoModule.Photo.createTonemapMantiuk	(	float	gamma,
		float	scale,
		float	saturation )

static

Creates TonemapMantiuk object.

Parameters

gamma	gamma value for gamma correction. See createTonemap
scale	contrast scale factor. HVS response is multiplied by this parameter, thus compressing dynamic range. Values from 0.6 to 0.9 produce best results.
saturation	saturation enhancement value. See createTonemapDrago

◆ createTonemapReinhard() [1/5]

static TonemapReinhard OpenCVForUnity.PhotoModule.Photo.createTonemapReinhard ( )

static

Creates TonemapReinhard object.

Parameters

gamma	gamma value for gamma correction. See createTonemap
intensity	result intensity in [-8, 8] range. Greater intensity produces brighter results.
light_adapt	light adaptation in [0, 1] range. If 1 adaptation is based only on pixel value, if 0 it's global, otherwise it's a weighted mean of this two cases.
color_adapt	chromatic adaptation in [0, 1] range. If 1 channels are treated independently, if 0 adaptation level is the same for each channel.

◆ createTonemapReinhard() [2/5]

static TonemapReinhard OpenCVForUnity.PhotoModule.Photo.createTonemapReinhard ( float gamma )

static

Creates TonemapReinhard object.

Parameters

gamma	gamma value for gamma correction. See createTonemap
intensity	result intensity in [-8, 8] range. Greater intensity produces brighter results.
light_adapt	light adaptation in [0, 1] range. If 1 adaptation is based only on pixel value, if 0 it's global, otherwise it's a weighted mean of this two cases.
color_adapt	chromatic adaptation in [0, 1] range. If 1 channels are treated independently, if 0 adaptation level is the same for each channel.

◆ createTonemapReinhard() [3/5]

static TonemapReinhard OpenCVForUnity.PhotoModule.Photo.createTonemapReinhard	(	float	gamma,
		float	intensity )

static

Creates TonemapReinhard object.

Parameters

gamma	gamma value for gamma correction. See createTonemap
intensity	result intensity in [-8, 8] range. Greater intensity produces brighter results.
light_adapt	light adaptation in [0, 1] range. If 1 adaptation is based only on pixel value, if 0 it's global, otherwise it's a weighted mean of this two cases.
color_adapt	chromatic adaptation in [0, 1] range. If 1 channels are treated independently, if 0 adaptation level is the same for each channel.

◆ createTonemapReinhard() [4/5]

static TonemapReinhard OpenCVForUnity.PhotoModule.Photo.createTonemapReinhard	(	float	gamma,
		float	intensity,
		float	light_adapt )

static

Creates TonemapReinhard object.

Parameters

gamma	gamma value for gamma correction. See createTonemap
intensity	result intensity in [-8, 8] range. Greater intensity produces brighter results.
light_adapt	light adaptation in [0, 1] range. If 1 adaptation is based only on pixel value, if 0 it's global, otherwise it's a weighted mean of this two cases.
color_adapt	chromatic adaptation in [0, 1] range. If 1 channels are treated independently, if 0 adaptation level is the same for each channel.

◆ createTonemapReinhard() [5/5]

static TonemapReinhard OpenCVForUnity.PhotoModule.Photo.createTonemapReinhard	(	float	gamma,
		float	intensity,
		float	light_adapt,
		float	color_adapt )

static

Creates TonemapReinhard object.

Parameters

gamma	gamma value for gamma correction. See createTonemap
intensity	result intensity in [-8, 8] range. Greater intensity produces brighter results.
light_adapt	light adaptation in [0, 1] range. If 1 adaptation is based only on pixel value, if 0 it's global, otherwise it's a weighted mean of this two cases.
color_adapt	chromatic adaptation in [0, 1] range. If 1 channels are treated independently, if 0 adaptation level is the same for each channel.

◆ decolor()

static void OpenCVForUnity.PhotoModule.Photo.decolor	(	Mat	src,
		Mat	grayscale,
		Mat	color_boost )

static

Transforms a color image to a grayscale image. It is a basic tool in digital printing, stylized black-and-white photograph rendering, and in many single channel image processing applications [CL12] .

Parameters

src	Input 8-bit 3-channel image.
grayscale	Output 8-bit 1-channel image.
color_boost	Output 8-bit 3-channel image.

This function is to be applied on color images.

◆ denoise_TVL1() [1/3]

static void OpenCVForUnity.PhotoModule.Photo.denoise_TVL1	(	List< Mat >	observations,
		Mat	result )

static

Primal-dual algorithm is an algorithm for solving special types of variational problems (that is, finding a function to minimize some functional). As the image denoising, in particular, may be seen as the variational problem, primal-dual algorithm then can be used to perform denoising and this is exactly what is implemented.

It should be noted, that this implementation was taken from the July 2013 blog entry [MA13] , which also contained (slightly more general) ready-to-use source code on Python. Subsequently, that code was rewritten on C++ with the usage of openCV by Vadim Pisarevsky at the end of July 2013 and finally it was slightly adapted by later authors.

Although the thorough discussion and justification of the algorithm involved may be found in [ChambolleEtAl], it might make sense to skim over it here, following [MA13] . To begin with, we consider the 1-byte gray-level images as the functions from the rectangular domain of pixels (it may be seen as set \(\left\{(x,y)\in\mathbb{N}\times\mathbb{N}\mid 1\leq x\leq n,\;1\leq y\leq m\right\}\) for some \(m,\;n\in\mathbb{N}\)) into \(\{0,1,\dots,255\}\). We shall denote the noised images as \(f_i\) and with this view, given some image \(x\) of the same size, we may measure how bad it is by the formula

\(\|\|\cdot\|\|\) here denotes \(L_2\)-norm and as you see, the first addend states that we want our image to be smooth (ideally, having zero gradient, thus being constant) and the second states that we want our result to be close to the observations we've got. If we treat \(x\) as a function, this is exactly the functional what we seek to minimize and here the Primal-Dual algorithm comes into play.

Parameters

observations	This array should contain one or more noised versions of the image that is to be restored.
result	Here the denoised image will be stored. There is no need to do pre-allocation of storage space, as it will be automatically allocated, if necessary.
lambda	Corresponds to \(\lambda\) in the formulas above. As it is enlarged, the smooth (blurred) images are treated more favorably than detailed (but maybe more noised) ones. Roughly speaking, as it becomes smaller, the result will be more blur but more sever outliers will be removed.
niters	Number of iterations that the algorithm will run. Of course, as more iterations as better, but it is hard to quantitatively refine this statement, so just use the default and increase it if the results are poor.

◆ denoise_TVL1() [2/3]

static void OpenCVForUnity.PhotoModule.Photo.denoise_TVL1	(	List< Mat >	observations,
		Mat	result,
		double	lambda )

static

Primal-dual algorithm is an algorithm for solving special types of variational problems (that is, finding a function to minimize some functional). As the image denoising, in particular, may be seen as the variational problem, primal-dual algorithm then can be used to perform denoising and this is exactly what is implemented.

It should be noted, that this implementation was taken from the July 2013 blog entry [MA13] , which also contained (slightly more general) ready-to-use source code on Python. Subsequently, that code was rewritten on C++ with the usage of openCV by Vadim Pisarevsky at the end of July 2013 and finally it was slightly adapted by later authors.

Although the thorough discussion and justification of the algorithm involved may be found in [ChambolleEtAl], it might make sense to skim over it here, following [MA13] . To begin with, we consider the 1-byte gray-level images as the functions from the rectangular domain of pixels (it may be seen as set \(\left\{(x,y)\in\mathbb{N}\times\mathbb{N}\mid 1\leq x\leq n,\;1\leq y\leq m\right\}\) for some \(m,\;n\in\mathbb{N}\)) into \(\{0,1,\dots,255\}\). We shall denote the noised images as \(f_i\) and with this view, given some image \(x\) of the same size, we may measure how bad it is by the formula

\(\|\|\cdot\|\|\) here denotes \(L_2\)-norm and as you see, the first addend states that we want our image to be smooth (ideally, having zero gradient, thus being constant) and the second states that we want our result to be close to the observations we've got. If we treat \(x\) as a function, this is exactly the functional what we seek to minimize and here the Primal-Dual algorithm comes into play.

Parameters

observations	This array should contain one or more noised versions of the image that is to be restored.
result	Here the denoised image will be stored. There is no need to do pre-allocation of storage space, as it will be automatically allocated, if necessary.
lambda	Corresponds to \(\lambda\) in the formulas above. As it is enlarged, the smooth (blurred) images are treated more favorably than detailed (but maybe more noised) ones. Roughly speaking, as it becomes smaller, the result will be more blur but more sever outliers will be removed.
niters	Number of iterations that the algorithm will run. Of course, as more iterations as better, but it is hard to quantitatively refine this statement, so just use the default and increase it if the results are poor.

◆ denoise_TVL1() [3/3]

static void OpenCVForUnity.PhotoModule.Photo.denoise_TVL1	(	List< Mat >	observations,
		Mat	result,
		double	lambda,
		int	niters )

static

Primal-dual algorithm is an algorithm for solving special types of variational problems (that is, finding a function to minimize some functional). As the image denoising, in particular, may be seen as the variational problem, primal-dual algorithm then can be used to perform denoising and this is exactly what is implemented.

It should be noted, that this implementation was taken from the July 2013 blog entry [MA13] , which also contained (slightly more general) ready-to-use source code on Python. Subsequently, that code was rewritten on C++ with the usage of openCV by Vadim Pisarevsky at the end of July 2013 and finally it was slightly adapted by later authors.

Although the thorough discussion and justification of the algorithm involved may be found in [ChambolleEtAl], it might make sense to skim over it here, following [MA13] . To begin with, we consider the 1-byte gray-level images as the functions from the rectangular domain of pixels (it may be seen as set \(\left\{(x,y)\in\mathbb{N}\times\mathbb{N}\mid 1\leq x\leq n,\;1\leq y\leq m\right\}\) for some \(m,\;n\in\mathbb{N}\)) into \(\{0,1,\dots,255\}\). We shall denote the noised images as \(f_i\) and with this view, given some image \(x\) of the same size, we may measure how bad it is by the formula

\(\|\|\cdot\|\|\) here denotes \(L_2\)-norm and as you see, the first addend states that we want our image to be smooth (ideally, having zero gradient, thus being constant) and the second states that we want our result to be close to the observations we've got. If we treat \(x\) as a function, this is exactly the functional what we seek to minimize and here the Primal-Dual algorithm comes into play.

Parameters

observations	This array should contain one or more noised versions of the image that is to be restored.
result	Here the denoised image will be stored. There is no need to do pre-allocation of storage space, as it will be automatically allocated, if necessary.
lambda	Corresponds to \(\lambda\) in the formulas above. As it is enlarged, the smooth (blurred) images are treated more favorably than detailed (but maybe more noised) ones. Roughly speaking, as it becomes smaller, the result will be more blur but more sever outliers will be removed.
niters	Number of iterations that the algorithm will run. Of course, as more iterations as better, but it is hard to quantitatively refine this statement, so just use the default and increase it if the results are poor.

◆ detailEnhance() [1/3]

static void OpenCVForUnity.PhotoModule.Photo.detailEnhance	(	Mat	src,
		Mat	dst )

static

This filter enhances the details of a particular image.

Parameters

src	Input 8-bit 3-channel image.
dst	Output image with the same size and type as src.
sigma_s	Range between 0 to 200.
sigma_r	Range between 0 to 1.

◆ detailEnhance() [2/3]

static void OpenCVForUnity.PhotoModule.Photo.detailEnhance	(	Mat	src,
		Mat	dst,
		float	sigma_s )

static

This filter enhances the details of a particular image.

Parameters

src	Input 8-bit 3-channel image.
dst	Output image with the same size and type as src.
sigma_s	Range between 0 to 200.
sigma_r	Range between 0 to 1.

◆ detailEnhance() [3/3]

static void OpenCVForUnity.PhotoModule.Photo.detailEnhance	(	Mat	src,
		Mat	dst,
		float	sigma_s,
		float	sigma_r )

static

This filter enhances the details of a particular image.

Parameters

src	Input 8-bit 3-channel image.
dst	Output image with the same size and type as src.
sigma_s	Range between 0 to 200.
sigma_r	Range between 0 to 1.

◆ edgePreservingFilter() [1/4]

static void OpenCVForUnity.PhotoModule.Photo.edgePreservingFilter	(	Mat	src,
		Mat	dst )

static

Filtering is the fundamental operation in image and video processing. Edge-preserving smoothing filters are used in many different applications [EM11] .

Parameters

src	Input 8-bit 3-channel image.
dst	Output 8-bit 3-channel image.
flags	Edge preserving filters: cv::RECURS_FILTER or cv::NORMCONV_FILTER
sigma_s	Range between 0 to 200.
sigma_r	Range between 0 to 1.

◆ edgePreservingFilter() [2/4]

static void OpenCVForUnity.PhotoModule.Photo.edgePreservingFilter	(	Mat	src,
		Mat	dst,
		int	flags )

static

Filtering is the fundamental operation in image and video processing. Edge-preserving smoothing filters are used in many different applications [EM11] .

Parameters

src	Input 8-bit 3-channel image.
dst	Output 8-bit 3-channel image.
flags	Edge preserving filters: cv::RECURS_FILTER or cv::NORMCONV_FILTER
sigma_s	Range between 0 to 200.
sigma_r	Range between 0 to 1.

◆ edgePreservingFilter() [3/4]

static void OpenCVForUnity.PhotoModule.Photo.edgePreservingFilter	(	Mat	src,
		Mat	dst,
		int	flags,
		float	sigma_s )

static

Filtering is the fundamental operation in image and video processing. Edge-preserving smoothing filters are used in many different applications [EM11] .

Parameters

src	Input 8-bit 3-channel image.
dst	Output 8-bit 3-channel image.
flags	Edge preserving filters: cv::RECURS_FILTER or cv::NORMCONV_FILTER
sigma_s	Range between 0 to 200.
sigma_r	Range between 0 to 1.

◆ edgePreservingFilter() [4/4]

static void OpenCVForUnity.PhotoModule.Photo.edgePreservingFilter	(	Mat	src,
		Mat	dst,
		int	flags,
		float	sigma_s,
		float	sigma_r )

static

Filtering is the fundamental operation in image and video processing. Edge-preserving smoothing filters are used in many different applications [EM11] .

Parameters

src	Input 8-bit 3-channel image.
dst	Output 8-bit 3-channel image.
flags	Edge preserving filters: cv::RECURS_FILTER or cv::NORMCONV_FILTER
sigma_s	Range between 0 to 200.
sigma_r	Range between 0 to 1.

◆ fastNlMeansDenoising() [1/8]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoising	(	Mat	src,
		Mat	dst )

static

Perform image denoising using Non-local Means Denoising algorithm <http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/> with several computational optimizations. Noise expected to be a gaussian white noise.

Parameters

src	Input 8-bit 1-channel, 2-channel, 3-channel or 4-channel image.
dst	Output image with the same size and type as src .
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Parameter regulating filter strength. Big h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise

This function expected to be applied to grayscale images. For colored images look at fastNlMeansDenoisingColored. Advanced usage of this functions can be manual denoising of colored image in different colorspaces. Such approach is used in fastNlMeansDenoisingColored by converting image to CIELAB colorspace and then separately denoise L and AB components with different h parameter.

◆ fastNlMeansDenoising() [2/8]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoising	(	Mat	src,
		Mat	dst,
		float	h )

static

Perform image denoising using Non-local Means Denoising algorithm <http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/> with several computational optimizations. Noise expected to be a gaussian white noise.

Parameters

src	Input 8-bit 1-channel, 2-channel, 3-channel or 4-channel image.
dst	Output image with the same size and type as src .
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Parameter regulating filter strength. Big h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise

This function expected to be applied to grayscale images. For colored images look at fastNlMeansDenoisingColored. Advanced usage of this functions can be manual denoising of colored image in different colorspaces. Such approach is used in fastNlMeansDenoisingColored by converting image to CIELAB colorspace and then separately denoise L and AB components with different h parameter.

◆ fastNlMeansDenoising() [3/8]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoising	(	Mat	src,
		Mat	dst,
		float	h,
		int	templateWindowSize )

static

Perform image denoising using Non-local Means Denoising algorithm <http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/> with several computational optimizations. Noise expected to be a gaussian white noise.

Parameters

src	Input 8-bit 1-channel, 2-channel, 3-channel or 4-channel image.
dst	Output image with the same size and type as src .
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Parameter regulating filter strength. Big h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise

This function expected to be applied to grayscale images. For colored images look at fastNlMeansDenoisingColored. Advanced usage of this functions can be manual denoising of colored image in different colorspaces. Such approach is used in fastNlMeansDenoisingColored by converting image to CIELAB colorspace and then separately denoise L and AB components with different h parameter.

◆ fastNlMeansDenoising() [4/8]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoising	(	Mat	src,
		Mat	dst,
		float	h,
		int	templateWindowSize,
		int	searchWindowSize )

static

Perform image denoising using Non-local Means Denoising algorithm <http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/> with several computational optimizations. Noise expected to be a gaussian white noise.

Parameters

src	Input 8-bit 1-channel, 2-channel, 3-channel or 4-channel image.
dst	Output image with the same size and type as src .
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Parameter regulating filter strength. Big h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise

This function expected to be applied to grayscale images. For colored images look at fastNlMeansDenoisingColored. Advanced usage of this functions can be manual denoising of colored image in different colorspaces. Such approach is used in fastNlMeansDenoisingColored by converting image to CIELAB colorspace and then separately denoise L and AB components with different h parameter.

◆ fastNlMeansDenoising() [5/8]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoising	(	Mat	src,
		Mat	dst,
		MatOfFloat	h )

static

Perform image denoising using Non-local Means Denoising algorithm <http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/> with several computational optimizations. Noise expected to be a gaussian white noise.

Parameters

src	Input 8-bit or 16-bit (only with NORM_L1) 1-channel, 2-channel, 3-channel or 4-channel image.
dst	Output image with the same size and type as src .
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Array of parameters regulating filter strength, either one parameter applied to all channels or one per channel in dst. Big h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise
normType	Type of norm used for weight calculation. Can be either NORM_L2 or NORM_L1

This function expected to be applied to grayscale images. For colored images look at fastNlMeansDenoisingColored. Advanced usage of this functions can be manual denoising of colored image in different colorspaces. Such approach is used in fastNlMeansDenoisingColored by converting image to CIELAB colorspace and then separately denoise L and AB components with different h parameter.

◆ fastNlMeansDenoising() [6/8]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoising	(	Mat	src,
		Mat	dst,
		MatOfFloat	h,
		int	templateWindowSize )

static

Perform image denoising using Non-local Means Denoising algorithm <http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/> with several computational optimizations. Noise expected to be a gaussian white noise.

Parameters

src	Input 8-bit or 16-bit (only with NORM_L1) 1-channel, 2-channel, 3-channel or 4-channel image.
dst	Output image with the same size and type as src .
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Array of parameters regulating filter strength, either one parameter applied to all channels or one per channel in dst. Big h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise
normType	Type of norm used for weight calculation. Can be either NORM_L2 or NORM_L1

This function expected to be applied to grayscale images. For colored images look at fastNlMeansDenoisingColored. Advanced usage of this functions can be manual denoising of colored image in different colorspaces. Such approach is used in fastNlMeansDenoisingColored by converting image to CIELAB colorspace and then separately denoise L and AB components with different h parameter.

◆ fastNlMeansDenoising() [7/8]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoising	(	Mat	src,
		Mat	dst,
		MatOfFloat	h,
		int	templateWindowSize,
		int	searchWindowSize )

static

Perform image denoising using Non-local Means Denoising algorithm <http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/> with several computational optimizations. Noise expected to be a gaussian white noise.

Parameters

src	Input 8-bit or 16-bit (only with NORM_L1) 1-channel, 2-channel, 3-channel or 4-channel image.
dst	Output image with the same size and type as src .
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Array of parameters regulating filter strength, either one parameter applied to all channels or one per channel in dst. Big h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise
normType	Type of norm used for weight calculation. Can be either NORM_L2 or NORM_L1

This function expected to be applied to grayscale images. For colored images look at fastNlMeansDenoisingColored. Advanced usage of this functions can be manual denoising of colored image in different colorspaces. Such approach is used in fastNlMeansDenoisingColored by converting image to CIELAB colorspace and then separately denoise L and AB components with different h parameter.

◆ fastNlMeansDenoising() [8/8]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoising	(	Mat	src,
		Mat	dst,
		MatOfFloat	h,
		int	templateWindowSize,
		int	searchWindowSize,
		int	normType )

static

Perform image denoising using Non-local Means Denoising algorithm <http://www.ipol.im/pub/algo/bcm_non_local_means_denoising/> with several computational optimizations. Noise expected to be a gaussian white noise.

Parameters

src	Input 8-bit or 16-bit (only with NORM_L1) 1-channel, 2-channel, 3-channel or 4-channel image.
dst	Output image with the same size and type as src .
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Array of parameters regulating filter strength, either one parameter applied to all channels or one per channel in dst. Big h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise
normType	Type of norm used for weight calculation. Can be either NORM_L2 or NORM_L1

This function expected to be applied to grayscale images. For colored images look at fastNlMeansDenoisingColored. Advanced usage of this functions can be manual denoising of colored image in different colorspaces. Such approach is used in fastNlMeansDenoisingColored by converting image to CIELAB colorspace and then separately denoise L and AB components with different h parameter.

◆ fastNlMeansDenoisingColored() [1/5]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoisingColored	(	Mat	src,
		Mat	dst )

static

Modification of fastNlMeansDenoising function for colored images.

Parameters

src	Input 8-bit 3-channel image.
dst	Output image with the same size and type as src .
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Parameter regulating filter strength for luminance component. Bigger h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise
hColor	The same as h but for color components. For most images value equals 10 will be enough to remove colored noise and do not distort colors

The function converts image to CIELAB colorspace and then separately denoise L and AB components with given h parameters using fastNlMeansDenoising function.

◆ fastNlMeansDenoisingColored() [2/5]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoisingColored	(	Mat	src,
		Mat	dst,
		float	h )

static

Modification of fastNlMeansDenoising function for colored images.

Parameters

src	Input 8-bit 3-channel image.
dst	Output image with the same size and type as src .
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Parameter regulating filter strength for luminance component. Bigger h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise
hColor	The same as h but for color components. For most images value equals 10 will be enough to remove colored noise and do not distort colors

The function converts image to CIELAB colorspace and then separately denoise L and AB components with given h parameters using fastNlMeansDenoising function.

◆ fastNlMeansDenoisingColored() [3/5]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoisingColored	(	Mat	src,
		Mat	dst,
		float	h,
		float	hColor )

static

Modification of fastNlMeansDenoising function for colored images.

Parameters

src	Input 8-bit 3-channel image.
dst	Output image with the same size and type as src .
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Parameter regulating filter strength for luminance component. Bigger h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise
hColor	The same as h but for color components. For most images value equals 10 will be enough to remove colored noise and do not distort colors

The function converts image to CIELAB colorspace and then separately denoise L and AB components with given h parameters using fastNlMeansDenoising function.

◆ fastNlMeansDenoisingColored() [4/5]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoisingColored	(	Mat	src,
		Mat	dst,
		float	h,
		float	hColor,
		int	templateWindowSize )

static

Modification of fastNlMeansDenoising function for colored images.

Parameters

src	Input 8-bit 3-channel image.
dst	Output image with the same size and type as src .
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Parameter regulating filter strength for luminance component. Bigger h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise
hColor	The same as h but for color components. For most images value equals 10 will be enough to remove colored noise and do not distort colors

The function converts image to CIELAB colorspace and then separately denoise L and AB components with given h parameters using fastNlMeansDenoising function.

◆ fastNlMeansDenoisingColored() [5/5]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoisingColored	(	Mat	src,
		Mat	dst,
		float	h,
		float	hColor,
		int	templateWindowSize,
		int	searchWindowSize )

static

Modification of fastNlMeansDenoising function for colored images.

Parameters

src	Input 8-bit 3-channel image.
dst	Output image with the same size and type as src .
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Parameter regulating filter strength for luminance component. Bigger h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise
hColor	The same as h but for color components. For most images value equals 10 will be enough to remove colored noise and do not distort colors

The function converts image to CIELAB colorspace and then separately denoise L and AB components with given h parameters using fastNlMeansDenoising function.

◆ fastNlMeansDenoisingColoredMulti() [1/5]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoisingColoredMulti	(	List< Mat >	srcImgs,
		Mat	dst,
		int	imgToDenoiseIndex,
		int	temporalWindowSize )

static

Modification of fastNlMeansDenoisingMulti function for colored images sequences.

Parameters

srcImgs	Input 8-bit 3-channel images sequence. All images should have the same type and size.
imgToDenoiseIndex	Target image to denoise index in srcImgs sequence
temporalWindowSize	Number of surrounding images to use for target image denoising. Should be odd. Images from imgToDenoiseIndex - temporalWindowSize / 2 to imgToDenoiseIndex - temporalWindowSize / 2 from srcImgs will be used to denoise srcImgs[imgToDenoiseIndex] image.
dst	Output image with the same size and type as srcImgs images.
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Parameter regulating filter strength for luminance component. Bigger h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise.
hColor	The same as h but for color components.

The function converts images to CIELAB colorspace and then separately denoise L and AB components with given h parameters using fastNlMeansDenoisingMulti function.

◆ fastNlMeansDenoisingColoredMulti() [2/5]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoisingColoredMulti	(	List< Mat >	srcImgs,
		Mat	dst,
		int	imgToDenoiseIndex,
		int	temporalWindowSize,
		float	h )

static

Modification of fastNlMeansDenoisingMulti function for colored images sequences.

Parameters

srcImgs	Input 8-bit 3-channel images sequence. All images should have the same type and size.
imgToDenoiseIndex	Target image to denoise index in srcImgs sequence
temporalWindowSize	Number of surrounding images to use for target image denoising. Should be odd. Images from imgToDenoiseIndex - temporalWindowSize / 2 to imgToDenoiseIndex - temporalWindowSize / 2 from srcImgs will be used to denoise srcImgs[imgToDenoiseIndex] image.
dst	Output image with the same size and type as srcImgs images.
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Parameter regulating filter strength for luminance component. Bigger h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise.
hColor	The same as h but for color components.

The function converts images to CIELAB colorspace and then separately denoise L and AB components with given h parameters using fastNlMeansDenoisingMulti function.

◆ fastNlMeansDenoisingColoredMulti() [3/5]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoisingColoredMulti	(	List< Mat >	srcImgs,
		Mat	dst,
		int	imgToDenoiseIndex,
		int	temporalWindowSize,
		float	h,
		float	hColor )

static

Modification of fastNlMeansDenoisingMulti function for colored images sequences.

Parameters

srcImgs	Input 8-bit 3-channel images sequence. All images should have the same type and size.
imgToDenoiseIndex	Target image to denoise index in srcImgs sequence
temporalWindowSize	Number of surrounding images to use for target image denoising. Should be odd. Images from imgToDenoiseIndex - temporalWindowSize / 2 to imgToDenoiseIndex - temporalWindowSize / 2 from srcImgs will be used to denoise srcImgs[imgToDenoiseIndex] image.
dst	Output image with the same size and type as srcImgs images.
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Parameter regulating filter strength for luminance component. Bigger h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise.
hColor	The same as h but for color components.

The function converts images to CIELAB colorspace and then separately denoise L and AB components with given h parameters using fastNlMeansDenoisingMulti function.

◆ fastNlMeansDenoisingColoredMulti() [4/5]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoisingColoredMulti	(	List< Mat >	srcImgs,
		Mat	dst,
		int	imgToDenoiseIndex,
		int	temporalWindowSize,
		float	h,
		float	hColor,
		int	templateWindowSize )

static

Modification of fastNlMeansDenoisingMulti function for colored images sequences.

Parameters

srcImgs	Input 8-bit 3-channel images sequence. All images should have the same type and size.
imgToDenoiseIndex	Target image to denoise index in srcImgs sequence
temporalWindowSize	Number of surrounding images to use for target image denoising. Should be odd. Images from imgToDenoiseIndex - temporalWindowSize / 2 to imgToDenoiseIndex - temporalWindowSize / 2 from srcImgs will be used to denoise srcImgs[imgToDenoiseIndex] image.
dst	Output image with the same size and type as srcImgs images.
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Parameter regulating filter strength for luminance component. Bigger h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise.
hColor	The same as h but for color components.

The function converts images to CIELAB colorspace and then separately denoise L and AB components with given h parameters using fastNlMeansDenoisingMulti function.

◆ fastNlMeansDenoisingColoredMulti() [5/5]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoisingColoredMulti	(	List< Mat >	srcImgs,
		Mat	dst,
		int	imgToDenoiseIndex,
		int	temporalWindowSize,
		float	h,
		float	hColor,
		int	templateWindowSize,
		int	searchWindowSize )

static

Modification of fastNlMeansDenoisingMulti function for colored images sequences.

Parameters

srcImgs	Input 8-bit 3-channel images sequence. All images should have the same type and size.
imgToDenoiseIndex	Target image to denoise index in srcImgs sequence
temporalWindowSize	Number of surrounding images to use for target image denoising. Should be odd. Images from imgToDenoiseIndex - temporalWindowSize / 2 to imgToDenoiseIndex - temporalWindowSize / 2 from srcImgs will be used to denoise srcImgs[imgToDenoiseIndex] image.
dst	Output image with the same size and type as srcImgs images.
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Parameter regulating filter strength for luminance component. Bigger h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise.
hColor	The same as h but for color components.

The function converts images to CIELAB colorspace and then separately denoise L and AB components with given h parameters using fastNlMeansDenoisingMulti function.

◆ fastNlMeansDenoisingMulti() [1/8]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoisingMulti	(	List< Mat >	srcImgs,
		Mat	dst,
		int	imgToDenoiseIndex,
		int	temporalWindowSize )

static

Modification of fastNlMeansDenoising function for images sequence where consecutive images have been captured in small period of time. For example video. This version of the function is for grayscale images or for manual manipulation with colorspaces. See [Buades2005DenoisingIS] for more details (open access here).

Parameters

srcImgs	Input 8-bit 1-channel, 2-channel, 3-channel or 4-channel images sequence. All images should have the same type and size.
imgToDenoiseIndex	Target image to denoise index in srcImgs sequence
temporalWindowSize	Number of surrounding images to use for target image denoising. Should be odd. Images from imgToDenoiseIndex - temporalWindowSize / 2 to imgToDenoiseIndex - temporalWindowSize / 2 from srcImgs will be used to denoise srcImgs[imgToDenoiseIndex] image.
dst	Output image with the same size and type as srcImgs images.
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Parameter regulating filter strength. Bigger h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise

◆ fastNlMeansDenoisingMulti() [2/8]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoisingMulti	(	List< Mat >	srcImgs,
		Mat	dst,
		int	imgToDenoiseIndex,
		int	temporalWindowSize,
		float	h )

static

Modification of fastNlMeansDenoising function for images sequence where consecutive images have been captured in small period of time. For example video. This version of the function is for grayscale images or for manual manipulation with colorspaces. See [Buades2005DenoisingIS] for more details (open access here).

Parameters

srcImgs	Input 8-bit 1-channel, 2-channel, 3-channel or 4-channel images sequence. All images should have the same type and size.
imgToDenoiseIndex	Target image to denoise index in srcImgs sequence
temporalWindowSize	Number of surrounding images to use for target image denoising. Should be odd. Images from imgToDenoiseIndex - temporalWindowSize / 2 to imgToDenoiseIndex - temporalWindowSize / 2 from srcImgs will be used to denoise srcImgs[imgToDenoiseIndex] image.
dst	Output image with the same size and type as srcImgs images.
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Parameter regulating filter strength. Bigger h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise

◆ fastNlMeansDenoisingMulti() [3/8]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoisingMulti	(	List< Mat >	srcImgs,
		Mat	dst,
		int	imgToDenoiseIndex,
		int	temporalWindowSize,
		float	h,
		int	templateWindowSize )

static

Modification of fastNlMeansDenoising function for images sequence where consecutive images have been captured in small period of time. For example video. This version of the function is for grayscale images or for manual manipulation with colorspaces. See [Buades2005DenoisingIS] for more details (open access here).

Parameters

srcImgs	Input 8-bit 1-channel, 2-channel, 3-channel or 4-channel images sequence. All images should have the same type and size.
imgToDenoiseIndex	Target image to denoise index in srcImgs sequence
temporalWindowSize	Number of surrounding images to use for target image denoising. Should be odd. Images from imgToDenoiseIndex - temporalWindowSize / 2 to imgToDenoiseIndex - temporalWindowSize / 2 from srcImgs will be used to denoise srcImgs[imgToDenoiseIndex] image.
dst	Output image with the same size and type as srcImgs images.
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Parameter regulating filter strength. Bigger h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise

◆ fastNlMeansDenoisingMulti() [4/8]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoisingMulti	(	List< Mat >	srcImgs,
		Mat	dst,
		int	imgToDenoiseIndex,
		int	temporalWindowSize,
		float	h,
		int	templateWindowSize,
		int	searchWindowSize )

static

Modification of fastNlMeansDenoising function for images sequence where consecutive images have been captured in small period of time. For example video. This version of the function is for grayscale images or for manual manipulation with colorspaces. See [Buades2005DenoisingIS] for more details (open access here).

Parameters

srcImgs	Input 8-bit 1-channel, 2-channel, 3-channel or 4-channel images sequence. All images should have the same type and size.
imgToDenoiseIndex	Target image to denoise index in srcImgs sequence
temporalWindowSize	Number of surrounding images to use for target image denoising. Should be odd. Images from imgToDenoiseIndex - temporalWindowSize / 2 to imgToDenoiseIndex - temporalWindowSize / 2 from srcImgs will be used to denoise srcImgs[imgToDenoiseIndex] image.
dst	Output image with the same size and type as srcImgs images.
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Parameter regulating filter strength. Bigger h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise

◆ fastNlMeansDenoisingMulti() [5/8]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoisingMulti	(	List< Mat >	srcImgs,
		Mat	dst,
		int	imgToDenoiseIndex,
		int	temporalWindowSize,
		MatOfFloat	h )

static

Modification of fastNlMeansDenoising function for images sequence where consecutive images have been captured in small period of time. For example video. This version of the function is for grayscale images or for manual manipulation with colorspaces. See [Buades2005DenoisingIS] for more details (open access here).

Parameters

srcImgs	Input 8-bit or 16-bit (only with NORM_L1) 1-channel, 2-channel, 3-channel or 4-channel images sequence. All images should have the same type and size.
imgToDenoiseIndex	Target image to denoise index in srcImgs sequence
temporalWindowSize	Number of surrounding images to use for target image denoising. Should be odd. Images from imgToDenoiseIndex - temporalWindowSize / 2 to imgToDenoiseIndex - temporalWindowSize / 2 from srcImgs will be used to denoise srcImgs[imgToDenoiseIndex] image.
dst	Output image with the same size and type as srcImgs images.
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Array of parameters regulating filter strength, either one parameter applied to all channels or one per channel in dst. Big h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise
normType	Type of norm used for weight calculation. Can be either NORM_L2 or NORM_L1

◆ fastNlMeansDenoisingMulti() [6/8]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoisingMulti	(	List< Mat >	srcImgs,
		Mat	dst,
		int	imgToDenoiseIndex,
		int	temporalWindowSize,
		MatOfFloat	h,
		int	templateWindowSize )

static

Modification of fastNlMeansDenoising function for images sequence where consecutive images have been captured in small period of time. For example video. This version of the function is for grayscale images or for manual manipulation with colorspaces. See [Buades2005DenoisingIS] for more details (open access here).

Parameters

srcImgs	Input 8-bit or 16-bit (only with NORM_L1) 1-channel, 2-channel, 3-channel or 4-channel images sequence. All images should have the same type and size.
imgToDenoiseIndex	Target image to denoise index in srcImgs sequence
temporalWindowSize	Number of surrounding images to use for target image denoising. Should be odd. Images from imgToDenoiseIndex - temporalWindowSize / 2 to imgToDenoiseIndex - temporalWindowSize / 2 from srcImgs will be used to denoise srcImgs[imgToDenoiseIndex] image.
dst	Output image with the same size and type as srcImgs images.
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Array of parameters regulating filter strength, either one parameter applied to all channels or one per channel in dst. Big h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise
normType	Type of norm used for weight calculation. Can be either NORM_L2 or NORM_L1

◆ fastNlMeansDenoisingMulti() [7/8]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoisingMulti	(	List< Mat >	srcImgs,
		Mat	dst,
		int	imgToDenoiseIndex,
		int	temporalWindowSize,
		MatOfFloat	h,
		int	templateWindowSize,
		int	searchWindowSize )

static

Modification of fastNlMeansDenoising function for images sequence where consecutive images have been captured in small period of time. For example video. This version of the function is for grayscale images or for manual manipulation with colorspaces. See [Buades2005DenoisingIS] for more details (open access here).

Parameters

srcImgs	Input 8-bit or 16-bit (only with NORM_L1) 1-channel, 2-channel, 3-channel or 4-channel images sequence. All images should have the same type and size.
imgToDenoiseIndex	Target image to denoise index in srcImgs sequence
temporalWindowSize	Number of surrounding images to use for target image denoising. Should be odd. Images from imgToDenoiseIndex - temporalWindowSize / 2 to imgToDenoiseIndex - temporalWindowSize / 2 from srcImgs will be used to denoise srcImgs[imgToDenoiseIndex] image.
dst	Output image with the same size and type as srcImgs images.
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Array of parameters regulating filter strength, either one parameter applied to all channels or one per channel in dst. Big h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise
normType	Type of norm used for weight calculation. Can be either NORM_L2 or NORM_L1

◆ fastNlMeansDenoisingMulti() [8/8]

static void OpenCVForUnity.PhotoModule.Photo.fastNlMeansDenoisingMulti	(	List< Mat >	srcImgs,
		Mat	dst,
		int	imgToDenoiseIndex,
		int	temporalWindowSize,
		MatOfFloat	h,
		int	templateWindowSize,
		int	searchWindowSize,
		int	normType )

static

Modification of fastNlMeansDenoising function for images sequence where consecutive images have been captured in small period of time. For example video. This version of the function is for grayscale images or for manual manipulation with colorspaces. See [Buades2005DenoisingIS] for more details (open access here).

Parameters

srcImgs	Input 8-bit or 16-bit (only with NORM_L1) 1-channel, 2-channel, 3-channel or 4-channel images sequence. All images should have the same type and size.
imgToDenoiseIndex	Target image to denoise index in srcImgs sequence
temporalWindowSize	Number of surrounding images to use for target image denoising. Should be odd. Images from imgToDenoiseIndex - temporalWindowSize / 2 to imgToDenoiseIndex - temporalWindowSize / 2 from srcImgs will be used to denoise srcImgs[imgToDenoiseIndex] image.
dst	Output image with the same size and type as srcImgs images.
templateWindowSize	Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels
searchWindowSize	Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h	Array of parameters regulating filter strength, either one parameter applied to all channels or one per channel in dst. Big h value perfectly removes noise but also removes image details, smaller h value preserves details but also preserves some noise
normType	Type of norm used for weight calculation. Can be either NORM_L2 or NORM_L1

◆ illuminationChange() [1/3]

static void OpenCVForUnity.PhotoModule.Photo.illuminationChange	(	Mat	src,
		Mat	mask,
		Mat	dst )

static

Applying an appropriate non-linear transformation to the gradient field inside the selection and then integrating back with a Poisson solver, modifies locally the apparent illumination of an image.

Parameters

src	Input 8-bit 3-channel image.
mask	Input 8-bit 1 or 3-channel image.
dst	Output image with the same size and type as src.
alpha	Value ranges between 0-2.
beta	Value ranges between 0-2.

This is useful to highlight under-exposed foreground objects or to reduce specular reflections.

◆ illuminationChange() [2/3]

static void OpenCVForUnity.PhotoModule.Photo.illuminationChange	(	Mat	src,
		Mat	mask,
		Mat	dst,
		float	alpha )

static

Applying an appropriate non-linear transformation to the gradient field inside the selection and then integrating back with a Poisson solver, modifies locally the apparent illumination of an image.

Parameters

src	Input 8-bit 3-channel image.
mask	Input 8-bit 1 or 3-channel image.
dst	Output image with the same size and type as src.
alpha	Value ranges between 0-2.
beta	Value ranges between 0-2.

This is useful to highlight under-exposed foreground objects or to reduce specular reflections.

◆ illuminationChange() [3/3]

static void OpenCVForUnity.PhotoModule.Photo.illuminationChange	(	Mat	src,
		Mat	mask,
		Mat	dst,
		float	alpha,
		float	beta )

static

Applying an appropriate non-linear transformation to the gradient field inside the selection and then integrating back with a Poisson solver, modifies locally the apparent illumination of an image.

Parameters

src	Input 8-bit 3-channel image.
mask	Input 8-bit 1 or 3-channel image.
dst	Output image with the same size and type as src.
alpha	Value ranges between 0-2.
beta	Value ranges between 0-2.

This is useful to highlight under-exposed foreground objects or to reduce specular reflections.

◆ inpaint()

static void OpenCVForUnity.PhotoModule.Photo.inpaint	(	Mat	src,
		Mat	inpaintMask,
		Mat	dst,
		double	inpaintRadius,
		int	flags )

static

Restores the selected region in an image using the region neighborhood.

Parameters

src	Input 8-bit, 16-bit unsigned or 32-bit float 1-channel or 8-bit 3-channel image.
inpaintMask	Inpainting mask, 8-bit 1-channel image. Non-zero pixels indicate the area that needs to be inpainted.
dst	Output image with the same size and type as src .
inpaintRadius	Radius of a circular neighborhood of each point inpainted that is considered by the algorithm.
flags	Inpainting method that could be cv::INPAINT_NS or cv::INPAINT_TELEA

The function reconstructs the selected image area from the pixel near the area boundary. The function may be used to remove dust and scratches from a scanned photo, or to remove undesirable objects from still images or video. See <http://en.wikipedia.org/wiki/Inpainting> for more details.

Note

An example using the inpainting technique can be found at opencv_source_code/samples/cpp/inpaint.cpp
(Python) An example using the inpainting technique can be found at opencv_source_code/samples/python/inpaint.py

◆ pencilSketch() [1/4]

static void OpenCVForUnity.PhotoModule.Photo.pencilSketch	(	Mat	src,
		Mat	dst1,
		Mat	dst2 )

static

Pencil-like non-photorealistic line drawing.

Parameters

src	Input 8-bit 3-channel image.
dst1	Output 8-bit 1-channel image.
dst2	Output image with the same size and type as src.
sigma_s	Range between 0 to 200.
sigma_r	Range between 0 to 1.
shade_factor	Range between 0 to 0.1.

◆ pencilSketch() [2/4]

static void OpenCVForUnity.PhotoModule.Photo.pencilSketch	(	Mat	src,
		Mat	dst1,
		Mat	dst2,
		float	sigma_s )

static

Pencil-like non-photorealistic line drawing.

Parameters

src	Input 8-bit 3-channel image.
dst1	Output 8-bit 1-channel image.
dst2	Output image with the same size and type as src.
sigma_s	Range between 0 to 200.
sigma_r	Range between 0 to 1.
shade_factor	Range between 0 to 0.1.

◆ pencilSketch() [3/4]

static void OpenCVForUnity.PhotoModule.Photo.pencilSketch	(	Mat	src,
		Mat	dst1,
		Mat	dst2,
		float	sigma_s,
		float	sigma_r )

static

Pencil-like non-photorealistic line drawing.

Parameters

src	Input 8-bit 3-channel image.
dst1	Output 8-bit 1-channel image.
dst2	Output image with the same size and type as src.
sigma_s	Range between 0 to 200.
sigma_r	Range between 0 to 1.
shade_factor	Range between 0 to 0.1.

◆ pencilSketch() [4/4]

static void OpenCVForUnity.PhotoModule.Photo.pencilSketch	(	Mat	src,
		Mat	dst1,
		Mat	dst2,
		float	sigma_s,
		float	sigma_r,
		float	shade_factor )

static

Pencil-like non-photorealistic line drawing.

Parameters

src	Input 8-bit 3-channel image.
dst1	Output 8-bit 1-channel image.
dst2	Output image with the same size and type as src.
sigma_s	Range between 0 to 200.
sigma_r	Range between 0 to 1.
shade_factor	Range between 0 to 0.1.

◆ seamlessClone() [1/3]

static void OpenCVForUnity.PhotoModule.Photo.seamlessClone	(	Mat	src,
		Mat	dst,
		Mat	mask,
		in Vec2d	p,
		Mat	blend,
		int	flags )

static

Image editing tasks concern either global changes (color/intensity corrections, filters, deformations) or local changes concerned to a selection. Here we are interested in achieving local changes, ones that are restricted to a region manually selected (ROI), in a seamless and effortless manner. The extent of the changes ranges from slight distortions to complete replacement by novel content [PM03] .

Parameters

src	Input 8-bit 3-channel image.
dst	Input 8-bit 3-channel image.
mask	Input 8-bit 1 or 3-channel image.
p	Point in dst image where object is placed.
blend	Output image with the same size and type as dst.
flags	Cloning method that could be cv::NORMAL_CLONE, cv::MIXED_CLONE or cv::MONOCHROME_TRANSFER

◆ seamlessClone() [2/3]

static void OpenCVForUnity.PhotoModule.Photo.seamlessClone	(	Mat	src,
		Mat	dst,
		Mat	mask,
		in(double x, double y)	p,
		Mat	blend,
		int	flags )

static

Image editing tasks concern either global changes (color/intensity corrections, filters, deformations) or local changes concerned to a selection. Here we are interested in achieving local changes, ones that are restricted to a region manually selected (ROI), in a seamless and effortless manner. The extent of the changes ranges from slight distortions to complete replacement by novel content [PM03] .

Parameters

src	Input 8-bit 3-channel image.
dst	Input 8-bit 3-channel image.
mask	Input 8-bit 1 or 3-channel image.
p	Point in dst image where object is placed.
blend	Output image with the same size and type as dst.
flags	Cloning method that could be cv::NORMAL_CLONE, cv::MIXED_CLONE or cv::MONOCHROME_TRANSFER

◆ seamlessClone() [3/3]

static void OpenCVForUnity.PhotoModule.Photo.seamlessClone	(	Mat	src,
		Mat	dst,
		Mat	mask,
		Point	p,
		Mat	blend,
		int	flags )

static

Image editing tasks concern either global changes (color/intensity corrections, filters, deformations) or local changes concerned to a selection. Here we are interested in achieving local changes, ones that are restricted to a region manually selected (ROI), in a seamless and effortless manner. The extent of the changes ranges from slight distortions to complete replacement by novel content [PM03] .

Parameters

src	Input 8-bit 3-channel image.
dst	Input 8-bit 3-channel image.
mask	Input 8-bit 1 or 3-channel image.
p	Point in dst image where object is placed.
blend	Output image with the same size and type as dst.
flags	Cloning method that could be cv::NORMAL_CLONE, cv::MIXED_CLONE or cv::MONOCHROME_TRANSFER

◆ stylization() [1/3]

static void OpenCVForUnity.PhotoModule.Photo.stylization	(	Mat	src,
		Mat	dst )

static

Stylization aims to produce digital imagery with a wide variety of effects not focused on photorealism. Edge-aware filters are ideal for stylization, as they can abstract regions of low contrast while preserving, or enhancing, high-contrast features.

Parameters

src	Input 8-bit 3-channel image.
dst	Output image with the same size and type as src.
sigma_s	Range between 0 to 200.
sigma_r	Range between 0 to 1.

◆ stylization() [2/3]

static void OpenCVForUnity.PhotoModule.Photo.stylization	(	Mat	src,
		Mat	dst,
		float	sigma_s )

static

Stylization aims to produce digital imagery with a wide variety of effects not focused on photorealism. Edge-aware filters are ideal for stylization, as they can abstract regions of low contrast while preserving, or enhancing, high-contrast features.

Parameters

src	Input 8-bit 3-channel image.
dst	Output image with the same size and type as src.
sigma_s	Range between 0 to 200.
sigma_r	Range between 0 to 1.

◆ stylization() [3/3]

static void OpenCVForUnity.PhotoModule.Photo.stylization	(	Mat	src,
		Mat	dst,
		float	sigma_s,
		float	sigma_r )

static

Stylization aims to produce digital imagery with a wide variety of effects not focused on photorealism. Edge-aware filters are ideal for stylization, as they can abstract regions of low contrast while preserving, or enhancing, high-contrast features.

Parameters

src	Input 8-bit 3-channel image.
dst	Output image with the same size and type as src.
sigma_s	Range between 0 to 200.
sigma_r	Range between 0 to 1.

◆ textureFlattening() [1/4]

static void OpenCVForUnity.PhotoModule.Photo.textureFlattening	(	Mat	src,
		Mat	mask,
		Mat	dst )

static

By retaining only the gradients at edge locations, before integrating with the Poisson solver, one washes out the texture of the selected region, giving its contents a flat aspect. Here Canny Edge Detector is used.

Parameters

src	Input 8-bit 3-channel image.
mask	Input 8-bit 1 or 3-channel image.
dst	Output image with the same size and type as src.
low_threshold	Range from 0 to 100.
high_threshold	Value > 100.
kernel_size	The size of the Sobel kernel to be used.

Note: The algorithm assumes that the color of the source image is close to that of the destination. This assumption means that when the colors don't match, the source image color gets tinted toward the color of the destination image.

◆ textureFlattening() [2/4]

static void OpenCVForUnity.PhotoModule.Photo.textureFlattening	(	Mat	src,
		Mat	mask,
		Mat	dst,
		float	low_threshold )

static

By retaining only the gradients at edge locations, before integrating with the Poisson solver, one washes out the texture of the selected region, giving its contents a flat aspect. Here Canny Edge Detector is used.

Parameters

src	Input 8-bit 3-channel image.
mask	Input 8-bit 1 or 3-channel image.
dst	Output image with the same size and type as src.
low_threshold	Range from 0 to 100.
high_threshold	Value > 100.
kernel_size	The size of the Sobel kernel to be used.

Note: The algorithm assumes that the color of the source image is close to that of the destination. This assumption means that when the colors don't match, the source image color gets tinted toward the color of the destination image.

◆ textureFlattening() [3/4]

static void OpenCVForUnity.PhotoModule.Photo.textureFlattening	(	Mat	src,
		Mat	mask,
		Mat	dst,
		float	low_threshold,
		float	high_threshold )

static

By retaining only the gradients at edge locations, before integrating with the Poisson solver, one washes out the texture of the selected region, giving its contents a flat aspect. Here Canny Edge Detector is used.

Parameters

src	Input 8-bit 3-channel image.
mask	Input 8-bit 1 or 3-channel image.
dst	Output image with the same size and type as src.
low_threshold	Range from 0 to 100.
high_threshold	Value > 100.
kernel_size	The size of the Sobel kernel to be used.

Note: The algorithm assumes that the color of the source image is close to that of the destination. This assumption means that when the colors don't match, the source image color gets tinted toward the color of the destination image.

◆ textureFlattening() [4/4]

static void OpenCVForUnity.PhotoModule.Photo.textureFlattening	(	Mat	src,
		Mat	mask,
		Mat	dst,
		float	low_threshold,
		float	high_threshold,
		int	kernel_size )

static

By retaining only the gradients at edge locations, before integrating with the Poisson solver, one washes out the texture of the selected region, giving its contents a flat aspect. Here Canny Edge Detector is used.

Parameters

src	Input 8-bit 3-channel image.
mask	Input 8-bit 1 or 3-channel image.
dst	Output image with the same size and type as src.
low_threshold	Range from 0 to 100.
high_threshold	Value > 100.
kernel_size	The size of the Sobel kernel to be used.

Note: The algorithm assumes that the color of the source image is close to that of the destination. This assumption means that when the colors don't match, the source image color gets tinted toward the color of the destination image.

Member Data Documentation

◆ INPAINT_NS

const int OpenCVForUnity.PhotoModule.Photo.INPAINT_NS = 0

static

◆ INPAINT_TELEA

const int OpenCVForUnity.PhotoModule.Photo.INPAINT_TELEA = 1

static

◆ LDR_SIZE

const int OpenCVForUnity.PhotoModule.Photo.LDR_SIZE = 256

static

◆ MIXED_CLONE

const int OpenCVForUnity.PhotoModule.Photo.MIXED_CLONE = 2

static

◆ MONOCHROME_TRANSFER

const int OpenCVForUnity.PhotoModule.Photo.MONOCHROME_TRANSFER = 3

static

◆ NORMAL_CLONE

const int OpenCVForUnity.PhotoModule.Photo.NORMAL_CLONE = 1

static

◆ NORMCONV_FILTER

const int OpenCVForUnity.PhotoModule.Photo.NORMCONV_FILTER = 2

static

◆ RECURS_FILTER

const int OpenCVForUnity.PhotoModule.Photo.RECURS_FILTER = 1

static

The documentation for this class was generated from the following files:

OpenCVForUnity/Assets/OpenCVForUnity/org/opencv/photo/Photo.cs
OpenCVForUnity/Assets/OpenCVForUnity/org/opencv/photo/Photo_Struct.cs
OpenCVForUnity/Assets/OpenCVForUnity/org/opencv/photo/Photo_ValueTuple.cs

Static Public Member Functions

Static Public Attributes

Member Function Documentation

◆ colorChange() [1/4]

◆ colorChange() [2/4]

◆ colorChange() [3/4]

◆ colorChange() [4/4]

◆ createAlignMTB() [1/4]

◆ createAlignMTB() [2/4]

◆ createAlignMTB() [3/4]

◆ createAlignMTB() [4/4]

◆ createCalibrateDebevec() [1/4]

◆ createCalibrateDebevec() [2/4]

◆ createCalibrateDebevec() [3/4]

◆ createCalibrateDebevec() [4/4]

◆ createCalibrateRobertson() [1/3]

◆ createCalibrateRobertson() [2/3]

◆ createCalibrateRobertson() [3/3]

◆ createMergeDebevec()

◆ createMergeMertens() [1/4]

◆ createMergeMertens() [2/4]

◆ createMergeMertens() [3/4]

◆ createMergeMertens() [4/4]

◆ createMergeRobertson()

◆ createTonemap() [1/2]

◆ createTonemap() [2/2]

◆ createTonemapDrago() [1/4]

◆ createTonemapDrago() [2/4]

◆ createTonemapDrago() [3/4]

◆ createTonemapDrago() [4/4]

◆ createTonemapMantiuk() [1/4]

◆ createTonemapMantiuk() [2/4]

◆ createTonemapMantiuk() [3/4]

◆ createTonemapMantiuk() [4/4]

◆ createTonemapReinhard() [1/5]

◆ createTonemapReinhard() [2/5]

◆ createTonemapReinhard() [3/5]

◆ createTonemapReinhard() [4/5]

◆ createTonemapReinhard() [5/5]

◆ decolor()

◆ denoise_TVL1() [1/3]

◆ denoise_TVL1() [2/3]

◆ denoise_TVL1() [3/3]

◆ detailEnhance() [1/3]

◆ detailEnhance() [2/3]

◆ detailEnhance() [3/3]

◆ edgePreservingFilter() [1/4]

◆ edgePreservingFilter() [2/4]

◆ edgePreservingFilter() [3/4]

◆ edgePreservingFilter() [4/4]

◆ fastNlMeansDenoising() [1/8]

◆ fastNlMeansDenoising() [2/8]

◆ fastNlMeansDenoising() [3/8]

◆ fastNlMeansDenoising() [4/8]

◆ fastNlMeansDenoising() [5/8]

◆ fastNlMeansDenoising() [6/8]

◆ fastNlMeansDenoising() [7/8]

◆ fastNlMeansDenoising() [8/8]

◆ fastNlMeansDenoisingColored() [1/5]

◆ fastNlMeansDenoisingColored() [2/5]

◆ fastNlMeansDenoisingColored() [3/5]

◆ fastNlMeansDenoisingColored() [4/5]

◆ fastNlMeansDenoisingColored() [5/5]

◆ fastNlMeansDenoisingColoredMulti() [1/5]

◆ fastNlMeansDenoisingColoredMulti() [2/5]

◆ fastNlMeansDenoisingColoredMulti() [3/5]

◆ fastNlMeansDenoisingColoredMulti() [4/5]

◆ fastNlMeansDenoisingColoredMulti() [5/5]

◆ fastNlMeansDenoisingMulti() [1/8]

◆ fastNlMeansDenoisingMulti() [2/8]

◆ fastNlMeansDenoisingMulti() [3/8]

◆ fastNlMeansDenoisingMulti() [4/8]

◆ fastNlMeansDenoisingMulti() [5/8]

◆ fastNlMeansDenoisingMulti() [6/8]

◆ fastNlMeansDenoisingMulti() [7/8]

◆ fastNlMeansDenoisingMulti() [8/8]

◆ illuminationChange() [1/3]

◆ illuminationChange() [2/3]

◆ illuminationChange() [3/3]

◆ inpaint()