opencv_photo (JavaCPP Presets for OpenCV 3.4.3-1.4.3 API)

java.lang.Object
- org.bytedeco.javacpp.presets.opencv_photo
- - org.bytedeco.javacpp.opencv_photo

All Implemented Interfaces:

org.bytedeco.javacpp.tools.InfoMapper
```
public class opencv_photo
extends opencv_photo
```

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`opencv_photo.AlignExposures` \brief The base class for algorithms that align images of the same scene with different exposures
`static class`	`opencv_photo.AlignMTB` \brief This algorithm converts images to median threshold bitmaps (1 for pixels brighter than median luminance and 0 otherwise) and than aligns the resulting bitmaps using bit operations.
`static class`	`opencv_photo.CalibrateCRF` \brief The base class for camera response calibration algorithms.
`static class`	`opencv_photo.CalibrateDebevec` \brief Inverse camera response function is extracted for each brightness value by minimizing an objective function as linear system.
`static class`	`opencv_photo.CalibrateRobertson` \brief Inverse camera response function is extracted for each brightness value by minimizing an objective function as linear system.
`static class`	`opencv_photo.MergeDebevec` \brief The resulting HDR image is calculated as weighted average of the exposures considering exposure values and camera response.
`static class`	`opencv_photo.MergeExposures` \brief The base class algorithms that can merge exposure sequence to a single image.
`static class`	`opencv_photo.MergeMertens` \brief Pixels are weighted using contrast, saturation and well-exposedness measures, than images are combined using laplacian pyramids.
`static class`	`opencv_photo.MergeRobertson` \brief The resulting HDR image is calculated as weighted average of the exposures considering exposure values and camera response.
`static class`	`opencv_photo.Tonemap` \brief Base class for tonemapping algorithms - tools that are used to map HDR image to 8-bit range.
`static class`	`opencv_photo.TonemapDrago` \brief Adaptive logarithmic mapping is a fast global tonemapping algorithm that scales the image in logarithmic domain.
`static class`	`opencv_photo.TonemapDurand` \brief This algorithm decomposes image into two layers: base layer and detail layer using bilateral filter and compresses contrast of the base layer thus preserving all the details.
`static class`	`opencv_photo.TonemapMantiuk` \brief This algorithm transforms image to contrast using gradients on all levels of gaussian pyramid, transforms contrast values to HVS response and scales the response.
`static class`	`opencv_photo.TonemapReinhard` \brief This is a global tonemapping operator that models human visual system.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`CV_INPAINT_NS` enum InpaintingModes
`static int`	`CV_INPAINT_TELEA` enum InpaintingModes
`static int`	`INPAINT_NS` enum cv::
`static int`	`INPAINT_TELEA` enum cv::
`static int`	`LDR_SIZE` enum cv::
`static int`	`MIXED_CLONE` enum cv::
`static int`	`MONOCHROME_TRANSFER` enum cv::
`static int`	`NORMAL_CLONE` enum cv::
`static int`	`NORMCONV_FILTER` enum cv::
`static int`	`RECURS_FILTER` enum cv::

Constructor Summary

Constructors
Constructor and Description

opencv_photo()

Constructors
Constructor and Description
`opencv_photo()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`colorChange(opencv_core.GpuMat src, opencv_core.GpuMat mask, opencv_core.GpuMat dst)`
`static void`	`colorChange(opencv_core.GpuMat src, opencv_core.GpuMat mask, opencv_core.GpuMat dst, float red_mul, float green_mul, float blue_mul)`
`static void`	`colorChange(opencv_core.Mat src, opencv_core.Mat mask, opencv_core.Mat dst)`
`static void`	`colorChange(opencv_core.Mat src, opencv_core.Mat mask, opencv_core.Mat dst, float red_mul, float green_mul, float blue_mul)` \brief Given an original color image, two differently colored versions of this image can be mixed seamlessly.
`static void`	`colorChange(opencv_core.UMat src, opencv_core.UMat mask, opencv_core.UMat dst)`
`static void`	`colorChange(opencv_core.UMat src, opencv_core.UMat mask, opencv_core.UMat dst, float red_mul, float green_mul, float blue_mul)`
`static opencv_photo.AlignMTB`	`createAlignMTB()`
`static opencv_photo.AlignMTB`	`createAlignMTB(int max_bits, int exclude_range, boolean cut)` \brief Creates AlignMTB object
`static opencv_photo.CalibrateDebevec`	`createCalibrateDebevec()`
`static opencv_photo.CalibrateDebevec`	`createCalibrateDebevec(int samples, float lambda, boolean random)` \brief Creates CalibrateDebevec object
`static opencv_photo.CalibrateRobertson`	`createCalibrateRobertson()`
`static opencv_photo.CalibrateRobertson`	`createCalibrateRobertson(int max_iter, float threshold)` \brief Creates CalibrateRobertson object
`static opencv_photo.MergeDebevec`	`createMergeDebevec()` \brief Creates MergeDebevec object
`static opencv_photo.MergeMertens`	`createMergeMertens()`
`static opencv_photo.MergeMertens`	`createMergeMertens(float contrast_weight, float saturation_weight, float exposure_weight)` \brief Creates MergeMertens object
`static opencv_photo.MergeRobertson`	`createMergeRobertson()` \brief Creates MergeRobertson object
`static opencv_photo.Tonemap`	`createTonemap()`
`static opencv_photo.Tonemap`	`createTonemap(float gamma)` \brief Creates simple linear mapper with gamma correction
`static opencv_photo.TonemapDrago`	`createTonemapDrago()`
`static opencv_photo.TonemapDrago`	`createTonemapDrago(float gamma, float saturation, float bias)` \brief Creates TonemapDrago object
`static opencv_photo.TonemapDurand`	`createTonemapDurand()`
`static opencv_photo.TonemapDurand`	`createTonemapDurand(float gamma, float contrast, float saturation, float sigma_space, float sigma_color)` \brief Creates TonemapDurand object
`static opencv_photo.TonemapMantiuk`	`createTonemapMantiuk()`
`static opencv_photo.TonemapMantiuk`	`createTonemapMantiuk(float gamma, float scale, float saturation)` \brief Creates TonemapMantiuk object
`static opencv_photo.TonemapReinhard`	`createTonemapReinhard()`
`static opencv_photo.TonemapReinhard`	`createTonemapReinhard(float gamma, float intensity, float light_adapt, float color_adapt)` \brief Creates TonemapReinhard object
`static void`	`cvInpaint(opencv_core.CvArr src, opencv_core.CvArr inpaint_mask, opencv_core.CvArr dst, double inpaintRange, int flags)`
`static void`	`decolor(opencv_core.GpuMat src, opencv_core.GpuMat grayscale, opencv_core.GpuMat color_boost)`
`static void`	`decolor(opencv_core.Mat src, opencv_core.Mat grayscale, opencv_core.Mat color_boost)` \} photo_hdr
`static void`	`decolor(opencv_core.UMat src, opencv_core.UMat grayscale, opencv_core.UMat color_boost)`
`static void`	`denoise_TVL1(opencv_core.MatVector observations, opencv_core.Mat result)`
`static void`	`denoise_TVL1(opencv_core.MatVector observations, opencv_core.Mat result, double lambda, int niters)` \brief Primal-dual algorithm is an algorithm for solving special types of variational problems (that is, finding a function to minimize some functional).
`static void`	`detailEnhance(opencv_core.GpuMat src, opencv_core.GpuMat dst)`
`static void`	`detailEnhance(opencv_core.GpuMat src, opencv_core.GpuMat dst, float sigma_s, float sigma_r)`
`static void`	`detailEnhance(opencv_core.Mat src, opencv_core.Mat dst)`
`static void`	`detailEnhance(opencv_core.Mat src, opencv_core.Mat dst, float sigma_s, float sigma_r)` \brief This filter enhances the details of a particular image.
`static void`	`detailEnhance(opencv_core.UMat src, opencv_core.UMat dst)`
`static void`	`detailEnhance(opencv_core.UMat src, opencv_core.UMat dst, float sigma_s, float sigma_r)`
`static void`	`edgePreservingFilter(opencv_core.GpuMat src, opencv_core.GpuMat dst)`
`static void`	`edgePreservingFilter(opencv_core.GpuMat src, opencv_core.GpuMat dst, int flags, float sigma_s, float sigma_r)`
`static void`	`edgePreservingFilter(opencv_core.Mat src, opencv_core.Mat dst)`
`static void`	`edgePreservingFilter(opencv_core.Mat src, opencv_core.Mat dst, int flags, float sigma_s, float sigma_r)` \} photo_clone
`static void`	`edgePreservingFilter(opencv_core.UMat src, opencv_core.UMat dst)`
`static void`	`edgePreservingFilter(opencv_core.UMat src, opencv_core.UMat dst, int flags, float sigma_s, float sigma_r)`
`static void`	`fastNlMeansDenoising(opencv_core.GpuMat src, opencv_core.GpuMat dst)`
`static void`	`fastNlMeansDenoising(opencv_core.GpuMat src, opencv_core.GpuMat dst, float h)`
`static void`	`fastNlMeansDenoising(opencv_core.GpuMat src, opencv_core.GpuMat dst, float[] h)`
`static void`	`fastNlMeansDenoising(opencv_core.GpuMat src, opencv_core.GpuMat dst, float[] h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoising(opencv_core.GpuMat src, opencv_core.GpuMat dst, FloatBuffer h)`
`static void`	`fastNlMeansDenoising(opencv_core.GpuMat src, opencv_core.GpuMat dst, FloatBuffer h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoising(opencv_core.GpuMat src, opencv_core.GpuMat dst, float h, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoising(opencv_core.GpuMat src, opencv_core.GpuMat dst, float h, int search_window, int block_size, opencv_core.Stream stream)`
`static void`	`fastNlMeansDenoising(opencv_core.GpuMat src, opencv_core.GpuMat dst, org.bytedeco.javacpp.FloatPointer h)`
`static void`	`fastNlMeansDenoising(opencv_core.GpuMat src, opencv_core.GpuMat dst, org.bytedeco.javacpp.FloatPointer h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoising(opencv_core.Mat src, opencv_core.Mat dst)`
`static void`	`fastNlMeansDenoising(opencv_core.Mat src, opencv_core.Mat dst, float h)`
`static void`	`fastNlMeansDenoising(opencv_core.Mat src, opencv_core.Mat dst, float[] h)`
`static void`	`fastNlMeansDenoising(opencv_core.Mat src, opencv_core.Mat dst, float[] h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoising(opencv_core.Mat src, opencv_core.Mat dst, FloatBuffer h)`
`static void`	`fastNlMeansDenoising(opencv_core.Mat src, opencv_core.Mat dst, FloatBuffer h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoising(opencv_core.Mat src, opencv_core.Mat dst, float h, int templateWindowSize, int searchWindowSize)` \addtogroup photo_denoise \{
`static void`	`fastNlMeansDenoising(opencv_core.Mat src, opencv_core.Mat dst, float h, int search_window, int block_size, opencv_core.Stream stream)` \brief Perform image denoising using Non-local Means Denoising algorithm with several computational optimizations.
`static void`	`fastNlMeansDenoising(opencv_core.Mat src, opencv_core.Mat dst, org.bytedeco.javacpp.FloatPointer h)`
`static void`	`fastNlMeansDenoising(opencv_core.Mat src, opencv_core.Mat dst, org.bytedeco.javacpp.FloatPointer h, int templateWindowSize, int searchWindowSize, int normType)` \brief Perform image denoising using Non-local Means Denoising algorithm with several computational optimizations.
`static void`	`fastNlMeansDenoising(opencv_core.UMat src, opencv_core.UMat dst)`
`static void`	`fastNlMeansDenoising(opencv_core.UMat src, opencv_core.UMat dst, float h)`
`static void`	`fastNlMeansDenoising(opencv_core.UMat src, opencv_core.UMat dst, float[] h)`
`static void`	`fastNlMeansDenoising(opencv_core.UMat src, opencv_core.UMat dst, float[] h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoising(opencv_core.UMat src, opencv_core.UMat dst, FloatBuffer h)`
`static void`	`fastNlMeansDenoising(opencv_core.UMat src, opencv_core.UMat dst, FloatBuffer h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoising(opencv_core.UMat src, opencv_core.UMat dst, float h, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoising(opencv_core.UMat src, opencv_core.UMat dst, float h, int search_window, int block_size, opencv_core.Stream stream)`
`static void`	`fastNlMeansDenoising(opencv_core.UMat src, opencv_core.UMat dst, org.bytedeco.javacpp.FloatPointer h)`
`static void`	`fastNlMeansDenoising(opencv_core.UMat src, opencv_core.UMat dst, org.bytedeco.javacpp.FloatPointer h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoisingColored(opencv_core.GpuMat src, opencv_core.GpuMat dst)`
`static void`	`fastNlMeansDenoisingColored(opencv_core.GpuMat src, opencv_core.GpuMat dst, float h_luminance, float photo_render)`
`static void`	`fastNlMeansDenoisingColored(opencv_core.GpuMat src, opencv_core.GpuMat dst, float h, float hColor, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingColored(opencv_core.GpuMat src, opencv_core.GpuMat dst, float h_luminance, float photo_render, int search_window, int block_size, opencv_core.Stream stream)`
`static void`	`fastNlMeansDenoisingColored(opencv_core.Mat src, opencv_core.Mat dst)`
`static void`	`fastNlMeansDenoisingColored(opencv_core.Mat src, opencv_core.Mat dst, float h_luminance, float photo_render)`
`static void`	`fastNlMeansDenoisingColored(opencv_core.Mat src, opencv_core.Mat dst, float h, float hColor, int templateWindowSize, int searchWindowSize)` \brief Modification of fastNlMeansDenoising function for colored images
`static void`	`fastNlMeansDenoisingColored(opencv_core.Mat src, opencv_core.Mat dst, float h_luminance, float photo_render, int search_window, int block_size, opencv_core.Stream stream)` \brief Modification of fastNlMeansDenoising function for colored images
`static void`	`fastNlMeansDenoisingColored(opencv_core.UMat src, opencv_core.UMat dst)`
`static void`	`fastNlMeansDenoisingColored(opencv_core.UMat src, opencv_core.UMat dst, float h_luminance, float photo_render)`
`static void`	`fastNlMeansDenoisingColored(opencv_core.UMat src, opencv_core.UMat dst, float h, float hColor, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingColored(opencv_core.UMat src, opencv_core.UMat dst, float h_luminance, float photo_render, int search_window, int block_size, opencv_core.Stream stream)`
`static void`	`fastNlMeansDenoisingColoredMulti(opencv_core.GpuMatVector srcImgs, opencv_core.GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(opencv_core.GpuMatVector srcImgs, opencv_core.GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(opencv_core.GpuMatVector srcImgs, opencv_core.Mat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(opencv_core.GpuMatVector srcImgs, opencv_core.Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(opencv_core.GpuMatVector srcImgs, opencv_core.UMat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(opencv_core.GpuMatVector srcImgs, opencv_core.UMat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(opencv_core.MatVector srcImgs, opencv_core.GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(opencv_core.MatVector srcImgs, opencv_core.GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(opencv_core.MatVector srcImgs, opencv_core.Mat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(opencv_core.MatVector srcImgs, opencv_core.Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize)` \brief Modification of fastNlMeansDenoisingMulti function for colored images sequences
`static void`	`fastNlMeansDenoisingColoredMulti(opencv_core.MatVector srcImgs, opencv_core.UMat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(opencv_core.MatVector srcImgs, opencv_core.UMat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(opencv_core.UMatVector srcImgs, opencv_core.GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(opencv_core.UMatVector srcImgs, opencv_core.GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(opencv_core.UMatVector srcImgs, opencv_core.Mat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(opencv_core.UMatVector srcImgs, opencv_core.Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(opencv_core.UMatVector srcImgs, opencv_core.UMat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(opencv_core.UMatVector srcImgs, opencv_core.UMat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.GpuMatVector srcImgs, opencv_core.GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.GpuMatVector srcImgs, opencv_core.GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize, float[] h)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.GpuMatVector srcImgs, opencv_core.GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize, float[] h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.GpuMatVector srcImgs, opencv_core.GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.GpuMatVector srcImgs, opencv_core.Mat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.GpuMatVector srcImgs, opencv_core.Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float[] h)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.GpuMatVector srcImgs, opencv_core.Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float[] h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.GpuMatVector srcImgs, opencv_core.Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.GpuMatVector srcImgs, opencv_core.UMat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.GpuMatVector srcImgs, opencv_core.UMat dst, int imgToDenoiseIndex, int temporalWindowSize, float[] h)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.GpuMatVector srcImgs, opencv_core.UMat dst, int imgToDenoiseIndex, int temporalWindowSize, float[] h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.GpuMatVector srcImgs, opencv_core.UMat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.MatVector srcImgs, opencv_core.GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.MatVector srcImgs, opencv_core.GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.MatVector srcImgs, opencv_core.GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize, org.bytedeco.javacpp.FloatPointer h)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.MatVector srcImgs, opencv_core.GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize, org.bytedeco.javacpp.FloatPointer h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.MatVector srcImgs, opencv_core.Mat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.MatVector srcImgs, opencv_core.Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize)` \brief Modification of fastNlMeansDenoising function for images sequence where consecutive images have been captured in small period of time.
`static void`	`fastNlMeansDenoisingMulti(opencv_core.MatVector srcImgs, opencv_core.Mat dst, int imgToDenoiseIndex, int temporalWindowSize, org.bytedeco.javacpp.FloatPointer h)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.MatVector srcImgs, opencv_core.Mat dst, int imgToDenoiseIndex, int temporalWindowSize, org.bytedeco.javacpp.FloatPointer h, int templateWindowSize, int searchWindowSize, int normType)` \brief Modification of fastNlMeansDenoising function for images sequence where consecutive images have been captured in small period of time.
`static void`	`fastNlMeansDenoisingMulti(opencv_core.MatVector srcImgs, opencv_core.UMat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.MatVector srcImgs, opencv_core.UMat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.MatVector srcImgs, opencv_core.UMat dst, int imgToDenoiseIndex, int temporalWindowSize, org.bytedeco.javacpp.FloatPointer h)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.MatVector srcImgs, opencv_core.UMat dst, int imgToDenoiseIndex, int temporalWindowSize, org.bytedeco.javacpp.FloatPointer h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.UMatVector srcImgs, opencv_core.GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.UMatVector srcImgs, opencv_core.GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize, FloatBuffer h)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.UMatVector srcImgs, opencv_core.GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize, FloatBuffer h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.UMatVector srcImgs, opencv_core.GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.UMatVector srcImgs, opencv_core.Mat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.UMatVector srcImgs, opencv_core.Mat dst, int imgToDenoiseIndex, int temporalWindowSize, FloatBuffer h)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.UMatVector srcImgs, opencv_core.Mat dst, int imgToDenoiseIndex, int temporalWindowSize, FloatBuffer h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.UMatVector srcImgs, opencv_core.Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.UMatVector srcImgs, opencv_core.UMat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.UMatVector srcImgs, opencv_core.UMat dst, int imgToDenoiseIndex, int temporalWindowSize, FloatBuffer h)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.UMatVector srcImgs, opencv_core.UMat dst, int imgToDenoiseIndex, int temporalWindowSize, FloatBuffer h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoisingMulti(opencv_core.UMatVector srcImgs, opencv_core.UMat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize)`
`static void`	`illuminationChange(opencv_core.GpuMat src, opencv_core.GpuMat mask, opencv_core.GpuMat dst)`
`static void`	`illuminationChange(opencv_core.GpuMat src, opencv_core.GpuMat mask, opencv_core.GpuMat dst, float alpha, float beta)`
`static void`	`illuminationChange(opencv_core.Mat src, opencv_core.Mat mask, opencv_core.Mat dst)`
`static void`	`illuminationChange(opencv_core.Mat src, opencv_core.Mat mask, opencv_core.Mat dst, float alpha, float beta)` \brief 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(opencv_core.UMat src, opencv_core.UMat mask, opencv_core.UMat dst)`
`static void`	`illuminationChange(opencv_core.UMat src, opencv_core.UMat mask, opencv_core.UMat dst, float alpha, float beta)`
`static void`	`inpaint(opencv_core.GpuMat src, opencv_core.GpuMat inpaintMask, opencv_core.GpuMat dst, double inpaintRadius, int flags)`
`static void`	`inpaint(opencv_core.Mat src, opencv_core.Mat inpaintMask, opencv_core.Mat dst, double inpaintRadius, int flags)` \brief Restores the selected region in an image using the region neighborhood.
`static void`	`inpaint(opencv_core.UMat src, opencv_core.UMat inpaintMask, opencv_core.UMat dst, double inpaintRadius, int flags)`
`static void`	`nonLocalMeans(opencv_core.GpuMat src, opencv_core.GpuMat dst, float h)`
`static void`	`nonLocalMeans(opencv_core.GpuMat src, opencv_core.GpuMat dst, float h, int search_window, int block_size, int borderMode, opencv_core.Stream stream)`
`static void`	`nonLocalMeans(opencv_core.Mat src, opencv_core.Mat dst, float h)`
`static void`	`nonLocalMeans(opencv_core.Mat src, opencv_core.Mat dst, float h, int search_window, int block_size, int borderMode, opencv_core.Stream stream)` \addtogroup photo_denoise \{
`static void`	`nonLocalMeans(opencv_core.UMat src, opencv_core.UMat dst, float h)`
`static void`	`nonLocalMeans(opencv_core.UMat src, opencv_core.UMat dst, float h, int search_window, int block_size, int borderMode, opencv_core.Stream stream)`
`static void`	`pencilSketch(opencv_core.GpuMat src, opencv_core.GpuMat dst1, opencv_core.GpuMat dst2)`
`static void`	`pencilSketch(opencv_core.GpuMat src, opencv_core.GpuMat dst1, opencv_core.GpuMat dst2, float sigma_s, float sigma_r, float shade_factor)`
`static void`	`pencilSketch(opencv_core.Mat src, opencv_core.Mat dst1, opencv_core.Mat dst2)`
`static void`	`pencilSketch(opencv_core.Mat src, opencv_core.Mat dst1, opencv_core.Mat dst2, float sigma_s, float sigma_r, float shade_factor)` \brief Pencil-like non-photorealistic line drawing
`static void`	`pencilSketch(opencv_core.UMat src, opencv_core.UMat dst1, opencv_core.UMat dst2)`
`static void`	`pencilSketch(opencv_core.UMat src, opencv_core.UMat dst1, opencv_core.UMat dst2, float sigma_s, float sigma_r, float shade_factor)`
`static void`	`seamlessClone(opencv_core.GpuMat src, opencv_core.GpuMat dst, opencv_core.GpuMat mask, opencv_core.Point p, opencv_core.GpuMat blend, int flags)`
`static void`	`seamlessClone(opencv_core.Mat src, opencv_core.Mat dst, opencv_core.Mat mask, opencv_core.Point p, opencv_core.Mat blend, int flags)` \brief Image editing tasks concern either global changes (color/intensity corrections, filters, deformations) or local changes concerned to a selection.
`static void`	`seamlessClone(opencv_core.UMat src, opencv_core.UMat dst, opencv_core.UMat mask, opencv_core.Point p, opencv_core.UMat blend, int flags)`
`static void`	`stylization(opencv_core.GpuMat src, opencv_core.GpuMat dst)`
`static void`	`stylization(opencv_core.GpuMat src, opencv_core.GpuMat dst, float sigma_s, float sigma_r)`
`static void`	`stylization(opencv_core.Mat src, opencv_core.Mat dst)`
`static void`	`stylization(opencv_core.Mat src, opencv_core.Mat dst, float sigma_s, float sigma_r)` \brief Stylization aims to produce digital imagery with a wide variety of effects not focused on photorealism.
`static void`	`stylization(opencv_core.UMat src, opencv_core.UMat dst)`
`static void`	`stylization(opencv_core.UMat src, opencv_core.UMat dst, float sigma_s, float sigma_r)`
`static void`	`textureFlattening(opencv_core.GpuMat src, opencv_core.GpuMat mask, opencv_core.GpuMat dst)`
`static void`	`textureFlattening(opencv_core.GpuMat src, opencv_core.GpuMat mask, opencv_core.GpuMat dst, float low_threshold, float high_threshold, int kernel_size)`
`static void`	`textureFlattening(opencv_core.Mat src, opencv_core.Mat mask, opencv_core.Mat dst)`
`static void`	`textureFlattening(opencv_core.Mat src, opencv_core.Mat mask, opencv_core.Mat dst, float low_threshold, float high_threshold, int kernel_size)` \brief 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.
`static void`	`textureFlattening(opencv_core.UMat src, opencv_core.UMat mask, opencv_core.UMat dst)`
`static void`	`textureFlattening(opencv_core.UMat src, opencv_core.UMat mask, opencv_core.UMat dst, float low_threshold, float high_threshold, int kernel_size)`

Methods inherited from class org.bytedeco.javacpp.presets.opencv_photo
map

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- CV_INPAINT_NS
```
public static final int CV_INPAINT_NS
```
  enum InpaintingModes
  
  See Also:
  
  Constant Field Values
- CV_INPAINT_TELEA
```
public static final int CV_INPAINT_TELEA
```
  enum InpaintingModes
  
  See Also:
  
  Constant Field Values
- INPAINT_NS
```
public static final int INPAINT_NS
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- INPAINT_TELEA
```
public static final int INPAINT_TELEA
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- NORMAL_CLONE
```
public static final int NORMAL_CLONE
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- MIXED_CLONE
```
public static final int MIXED_CLONE
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- MONOCHROME_TRANSFER
```
public static final int MONOCHROME_TRANSFER
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- RECURS_FILTER
```
public static final int RECURS_FILTER
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- NORMCONV_FILTER
```
public static final int NORMCONV_FILTER
```
  enum cv::
  
  See Also:
  
  Constant Field Values
- LDR_SIZE
```
public static final int LDR_SIZE
```
  enum cv::
  
  See Also:
  
  Constant Field Values

Constructor Detail
- opencv_photo
```
public opencv_photo()
```

Method Detail

cvInpaint

public static void cvInpaint(@Const
                             opencv_core.CvArr src,
                             @Const
                             opencv_core.CvArr inpaint_mask,
                             opencv_core.CvArr dst,
                             double inpaintRange,
                             int flags)

inpaint
```
@Namespace(value="cv")
public static void inpaint(@ByVal
                                                  opencv_core.Mat src,
                                                  @ByVal
                                                  opencv_core.Mat inpaintMask,
                                                  @ByVal
                                                  opencv_core.Mat dst,
                                                  double inpaintRadius,
                                                  int flags)
```
\brief 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 one of the following: - **INPAINT_NS** Navier-Stokes based method [Navier01] - **INPAINT_TELEA** Method by Alexandru Telea \cite Telea04 .
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 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

inpaint

@Namespace(value="cv")
public static void inpaint(@ByVal
                                                  opencv_core.UMat src,
                                                  @ByVal
                                                  opencv_core.UMat inpaintMask,
                                                  @ByVal
                                                  opencv_core.UMat dst,
                                                  double inpaintRadius,
                                                  int flags)

inpaint

@Namespace(value="cv")
public static void inpaint(@ByVal
                                                  opencv_core.GpuMat src,
                                                  @ByVal
                                                  opencv_core.GpuMat inpaintMask,
                                                  @ByVal
                                                  opencv_core.GpuMat dst,
                                                  double inpaintRadius,
                                                  int flags)

fastNlMeansDenoising
```
@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               opencv_core.Mat src,
                                                               @ByVal
                                                               opencv_core.Mat dst,
                                                               float h,
                                                               int templateWindowSize,
                                                               int searchWindowSize)
```
\addtogroup photo_denoise \{
/** \brief Perform image denoising using Non-local Means Denoising algorithm 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

@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               opencv_core.Mat src,
                                                               @ByVal
                                                               opencv_core.Mat dst)

fastNlMeansDenoising

@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               opencv_core.UMat src,
                                                               @ByVal
                                                               opencv_core.UMat dst,
                                                               float h,
                                                               int templateWindowSize,
                                                               int searchWindowSize)

fastNlMeansDenoising

@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               opencv_core.UMat src,
                                                               @ByVal
                                                               opencv_core.UMat dst)

fastNlMeansDenoising

@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               opencv_core.GpuMat src,
                                                               @ByVal
                                                               opencv_core.GpuMat dst,
                                                               float h,
                                                               int templateWindowSize,
                                                               int searchWindowSize)

fastNlMeansDenoising

@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               opencv_core.GpuMat src,
                                                               @ByVal
                                                               opencv_core.GpuMat dst)

fastNlMeansDenoising
```
@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               opencv_core.Mat src,
                                                               @ByVal
                                                               opencv_core.Mat dst,
                                                               @StdVector
                                                               org.bytedeco.javacpp.FloatPointer h,
                                                               int templateWindowSize,
                                                               int searchWindowSize,
                                                               int normType)
```
\brief Perform image denoising using Non-local Means Denoising algorithm 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

@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               opencv_core.Mat src,
                                                               @ByVal
                                                               opencv_core.Mat dst,
                                                               @StdVector
                                                               org.bytedeco.javacpp.FloatPointer h)

fastNlMeansDenoising

@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               opencv_core.Mat src,
                                                               @ByVal
                                                               opencv_core.Mat dst,
                                                               @StdVector
                                                               FloatBuffer h,
                                                               int templateWindowSize,
                                                               int searchWindowSize,
                                                               int normType)

fastNlMeansDenoising

@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               opencv_core.Mat src,
                                                               @ByVal
                                                               opencv_core.Mat dst,
                                                               @StdVector
                                                               FloatBuffer h)

fastNlMeansDenoising

@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               opencv_core.Mat src,
                                                               @ByVal
                                                               opencv_core.Mat dst,
                                                               @StdVector
                                                               float[] h,
                                                               int templateWindowSize,
                                                               int searchWindowSize,
                                                               int normType)

fastNlMeansDenoising

@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               opencv_core.Mat src,
                                                               @ByVal
                                                               opencv_core.Mat dst,
                                                               @StdVector
                                                               float[] h)

fastNlMeansDenoising

@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               opencv_core.UMat src,
                                                               @ByVal
                                                               opencv_core.UMat dst,
                                                               @StdVector
                                                               org.bytedeco.javacpp.FloatPointer h,
                                                               int templateWindowSize,
                                                               int searchWindowSize,
                                                               int normType)

fastNlMeansDenoising

@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               opencv_core.UMat src,
                                                               @ByVal
                                                               opencv_core.UMat dst,
                                                               @StdVector
                                                               org.bytedeco.javacpp.FloatPointer h)

fastNlMeansDenoising

@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               opencv_core.UMat src,
                                                               @ByVal
                                                               opencv_core.UMat dst,
                                                               @StdVector
                                                               FloatBuffer h,
                                                               int templateWindowSize,
                                                               int searchWindowSize,
                                                               int normType)

fastNlMeansDenoising

@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               opencv_core.UMat src,
                                                               @ByVal
                                                               opencv_core.UMat dst,
                                                               @StdVector
                                                               FloatBuffer h)

fastNlMeansDenoising

@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               opencv_core.UMat src,
                                                               @ByVal
                                                               opencv_core.UMat dst,
                                                               @StdVector
                                                               float[] h,
                                                               int templateWindowSize,
                                                               int searchWindowSize,
                                                               int normType)

fastNlMeansDenoising

@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               opencv_core.UMat src,
                                                               @ByVal
                                                               opencv_core.UMat dst,
                                                               @StdVector
                                                               float[] h)

fastNlMeansDenoising

@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               opencv_core.GpuMat src,
                                                               @ByVal
                                                               opencv_core.GpuMat dst,
                                                               @StdVector
                                                               org.bytedeco.javacpp.FloatPointer h,
                                                               int templateWindowSize,
                                                               int searchWindowSize,
                                                               int normType)

fastNlMeansDenoising

@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               opencv_core.GpuMat src,
                                                               @ByVal
                                                               opencv_core.GpuMat dst,
                                                               @StdVector
                                                               org.bytedeco.javacpp.FloatPointer h)

fastNlMeansDenoising

@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               opencv_core.GpuMat src,
                                                               @ByVal
                                                               opencv_core.GpuMat dst,
                                                               @StdVector
                                                               FloatBuffer h,
                                                               int templateWindowSize,
                                                               int searchWindowSize,
                                                               int normType)

fastNlMeansDenoising

@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               opencv_core.GpuMat src,
                                                               @ByVal
                                                               opencv_core.GpuMat dst,
                                                               @StdVector
                                                               FloatBuffer h)

fastNlMeansDenoising

@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               opencv_core.GpuMat src,
                                                               @ByVal
                                                               opencv_core.GpuMat dst,
                                                               @StdVector
                                                               float[] h,
                                                               int templateWindowSize,
                                                               int searchWindowSize,
                                                               int normType)

fastNlMeansDenoising

@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               opencv_core.GpuMat src,
                                                               @ByVal
                                                               opencv_core.GpuMat dst,
                                                               @StdVector
                                                               float[] h)

fastNlMeansDenoisingColored
```
@Namespace(value="cv")
public static void fastNlMeansDenoisingColored(@ByVal
                                                                      opencv_core.Mat src,
                                                                      @ByVal
                                                                      opencv_core.Mat dst,
                                                                      float h,
                                                                      float hColor,
                                                                      int templateWindowSize,
                                                                      int searchWindowSize)
```
\brief 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

@Namespace(value="cv")
public static void fastNlMeansDenoisingColored(@ByVal
                                                                      opencv_core.Mat src,
                                                                      @ByVal
                                                                      opencv_core.Mat dst)

fastNlMeansDenoisingColored

@Namespace(value="cv")
public static void fastNlMeansDenoisingColored(@ByVal
                                                                      opencv_core.UMat src,
                                                                      @ByVal
                                                                      opencv_core.UMat dst,
                                                                      float h,
                                                                      float hColor,
                                                                      int templateWindowSize,
                                                                      int searchWindowSize)

fastNlMeansDenoisingColored

@Namespace(value="cv")
public static void fastNlMeansDenoisingColored(@ByVal
                                                                      opencv_core.UMat src,
                                                                      @ByVal
                                                                      opencv_core.UMat dst)

fastNlMeansDenoisingColored

@Namespace(value="cv")
public static void fastNlMeansDenoisingColored(@ByVal
                                                                      opencv_core.GpuMat src,
                                                                      @ByVal
                                                                      opencv_core.GpuMat dst,
                                                                      float h,
                                                                      float hColor,
                                                                      int templateWindowSize,
                                                                      int searchWindowSize)

fastNlMeansDenoisingColored

@Namespace(value="cv")
public static void fastNlMeansDenoisingColored(@ByVal
                                                                      opencv_core.GpuMat src,
                                                                      @ByVal
                                                                      opencv_core.GpuMat dst)

fastNlMeansDenoisingMulti
```
@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.MatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.Mat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    float h,
                                                                    int templateWindowSize,
                                                                    int searchWindowSize)
```
\brief 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. For more details see

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

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.MatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.Mat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.UMatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.Mat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    float h,
                                                                    int templateWindowSize,
                                                                    int searchWindowSize)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.UMatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.Mat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.GpuMatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.Mat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    float h,
                                                                    int templateWindowSize,
                                                                    int searchWindowSize)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.GpuMatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.Mat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.MatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.UMat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    float h,
                                                                    int templateWindowSize,
                                                                    int searchWindowSize)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.MatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.UMat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.UMatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.UMat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    float h,
                                                                    int templateWindowSize,
                                                                    int searchWindowSize)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.UMatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.UMat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.GpuMatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.UMat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    float h,
                                                                    int templateWindowSize,
                                                                    int searchWindowSize)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.GpuMatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.UMat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.MatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.GpuMat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    float h,
                                                                    int templateWindowSize,
                                                                    int searchWindowSize)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.MatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.GpuMat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.UMatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.GpuMat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    float h,
                                                                    int templateWindowSize,
                                                                    int searchWindowSize)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.UMatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.GpuMat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.GpuMatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.GpuMat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    float h,
                                                                    int templateWindowSize,
                                                                    int searchWindowSize)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.GpuMatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.GpuMat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize)

fastNlMeansDenoisingMulti
```
@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.MatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.Mat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    @StdVector
                                                                    org.bytedeco.javacpp.FloatPointer h,
                                                                    int templateWindowSize,
                                                                    int searchWindowSize,
                                                                    int normType)
```
\brief 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. For more details see

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

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.MatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.Mat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    @StdVector
                                                                    org.bytedeco.javacpp.FloatPointer h)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.UMatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.Mat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    @StdVector
                                                                    FloatBuffer h,
                                                                    int templateWindowSize,
                                                                    int searchWindowSize,
                                                                    int normType)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.UMatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.Mat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    @StdVector
                                                                    FloatBuffer h)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.GpuMatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.Mat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    @StdVector
                                                                    float[] h,
                                                                    int templateWindowSize,
                                                                    int searchWindowSize,
                                                                    int normType)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.GpuMatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.Mat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    @StdVector
                                                                    float[] h)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.MatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.UMat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    @StdVector
                                                                    org.bytedeco.javacpp.FloatPointer h,
                                                                    int templateWindowSize,
                                                                    int searchWindowSize,
                                                                    int normType)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.MatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.UMat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    @StdVector
                                                                    org.bytedeco.javacpp.FloatPointer h)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.UMatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.UMat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    @StdVector
                                                                    FloatBuffer h,
                                                                    int templateWindowSize,
                                                                    int searchWindowSize,
                                                                    int normType)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.UMatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.UMat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    @StdVector
                                                                    FloatBuffer h)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.GpuMatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.UMat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    @StdVector
                                                                    float[] h,
                                                                    int templateWindowSize,
                                                                    int searchWindowSize,
                                                                    int normType)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.GpuMatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.UMat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    @StdVector
                                                                    float[] h)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.MatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.GpuMat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    @StdVector
                                                                    org.bytedeco.javacpp.FloatPointer h,
                                                                    int templateWindowSize,
                                                                    int searchWindowSize,
                                                                    int normType)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.MatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.GpuMat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    @StdVector
                                                                    org.bytedeco.javacpp.FloatPointer h)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.UMatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.GpuMat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    @StdVector
                                                                    FloatBuffer h,
                                                                    int templateWindowSize,
                                                                    int searchWindowSize,
                                                                    int normType)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.UMatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.GpuMat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    @StdVector
                                                                    FloatBuffer h)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.GpuMatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.GpuMat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    @StdVector
                                                                    float[] h,
                                                                    int templateWindowSize,
                                                                    int searchWindowSize,
                                                                    int normType)

fastNlMeansDenoisingMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    opencv_core.GpuMatVector srcImgs,
                                                                    @ByVal
                                                                    opencv_core.GpuMat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    @StdVector
                                                                    float[] h)

fastNlMeansDenoisingColoredMulti
```
@Namespace(value="cv")
public static void fastNlMeansDenoisingColoredMulti(@ByVal
                                                                           opencv_core.MatVector srcImgs,
                                                                           @ByVal
                                                                           opencv_core.Mat dst,
                                                                           int imgToDenoiseIndex,
                                                                           int temporalWindowSize,
                                                                           float h,
                                                                           float hColor,
                                                                           int templateWindowSize,
                                                                           int searchWindowSize)
```
\brief 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

@Namespace(value="cv")
public static void fastNlMeansDenoisingColoredMulti(@ByVal
                                                                           opencv_core.MatVector srcImgs,
                                                                           @ByVal
                                                                           opencv_core.Mat dst,
                                                                           int imgToDenoiseIndex,
                                                                           int temporalWindowSize)

fastNlMeansDenoisingColoredMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingColoredMulti(@ByVal
                                                                           opencv_core.UMatVector srcImgs,
                                                                           @ByVal
                                                                           opencv_core.Mat dst,
                                                                           int imgToDenoiseIndex,
                                                                           int temporalWindowSize,
                                                                           float h,
                                                                           float hColor,
                                                                           int templateWindowSize,
                                                                           int searchWindowSize)

fastNlMeansDenoisingColoredMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingColoredMulti(@ByVal
                                                                           opencv_core.UMatVector srcImgs,
                                                                           @ByVal
                                                                           opencv_core.Mat dst,
                                                                           int imgToDenoiseIndex,
                                                                           int temporalWindowSize)

fastNlMeansDenoisingColoredMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingColoredMulti(@ByVal
                                                                           opencv_core.GpuMatVector srcImgs,
                                                                           @ByVal
                                                                           opencv_core.Mat dst,
                                                                           int imgToDenoiseIndex,
                                                                           int temporalWindowSize,
                                                                           float h,
                                                                           float hColor,
                                                                           int templateWindowSize,
                                                                           int searchWindowSize)

fastNlMeansDenoisingColoredMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingColoredMulti(@ByVal
                                                                           opencv_core.GpuMatVector srcImgs,
                                                                           @ByVal
                                                                           opencv_core.Mat dst,
                                                                           int imgToDenoiseIndex,
                                                                           int temporalWindowSize)

fastNlMeansDenoisingColoredMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingColoredMulti(@ByVal
                                                                           opencv_core.MatVector srcImgs,
                                                                           @ByVal
                                                                           opencv_core.UMat dst,
                                                                           int imgToDenoiseIndex,
                                                                           int temporalWindowSize,
                                                                           float h,
                                                                           float hColor,
                                                                           int templateWindowSize,
                                                                           int searchWindowSize)

fastNlMeansDenoisingColoredMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingColoredMulti(@ByVal
                                                                           opencv_core.MatVector srcImgs,
                                                                           @ByVal
                                                                           opencv_core.UMat dst,
                                                                           int imgToDenoiseIndex,
                                                                           int temporalWindowSize)

fastNlMeansDenoisingColoredMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingColoredMulti(@ByVal
                                                                           opencv_core.UMatVector srcImgs,
                                                                           @ByVal
                                                                           opencv_core.UMat dst,
                                                                           int imgToDenoiseIndex,
                                                                           int temporalWindowSize,
                                                                           float h,
                                                                           float hColor,
                                                                           int templateWindowSize,
                                                                           int searchWindowSize)

fastNlMeansDenoisingColoredMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingColoredMulti(@ByVal
                                                                           opencv_core.UMatVector srcImgs,
                                                                           @ByVal
                                                                           opencv_core.UMat dst,
                                                                           int imgToDenoiseIndex,
                                                                           int temporalWindowSize)

fastNlMeansDenoisingColoredMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingColoredMulti(@ByVal
                                                                           opencv_core.GpuMatVector srcImgs,
                                                                           @ByVal
                                                                           opencv_core.UMat dst,
                                                                           int imgToDenoiseIndex,
                                                                           int temporalWindowSize,
                                                                           float h,
                                                                           float hColor,
                                                                           int templateWindowSize,
                                                                           int searchWindowSize)

fastNlMeansDenoisingColoredMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingColoredMulti(@ByVal
                                                                           opencv_core.GpuMatVector srcImgs,
                                                                           @ByVal
                                                                           opencv_core.UMat dst,
                                                                           int imgToDenoiseIndex,
                                                                           int temporalWindowSize)

fastNlMeansDenoisingColoredMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingColoredMulti(@ByVal
                                                                           opencv_core.MatVector srcImgs,
                                                                           @ByVal
                                                                           opencv_core.GpuMat dst,
                                                                           int imgToDenoiseIndex,
                                                                           int temporalWindowSize,
                                                                           float h,
                                                                           float hColor,
                                                                           int templateWindowSize,
                                                                           int searchWindowSize)

fastNlMeansDenoisingColoredMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingColoredMulti(@ByVal
                                                                           opencv_core.MatVector srcImgs,
                                                                           @ByVal
                                                                           opencv_core.GpuMat dst,
                                                                           int imgToDenoiseIndex,
                                                                           int temporalWindowSize)

fastNlMeansDenoisingColoredMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingColoredMulti(@ByVal
                                                                           opencv_core.UMatVector srcImgs,
                                                                           @ByVal
                                                                           opencv_core.GpuMat dst,
                                                                           int imgToDenoiseIndex,
                                                                           int temporalWindowSize,
                                                                           float h,
                                                                           float hColor,
                                                                           int templateWindowSize,
                                                                           int searchWindowSize)

fastNlMeansDenoisingColoredMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingColoredMulti(@ByVal
                                                                           opencv_core.UMatVector srcImgs,
                                                                           @ByVal
                                                                           opencv_core.GpuMat dst,
                                                                           int imgToDenoiseIndex,
                                                                           int temporalWindowSize)

fastNlMeansDenoisingColoredMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingColoredMulti(@ByVal
                                                                           opencv_core.GpuMatVector srcImgs,
                                                                           @ByVal
                                                                           opencv_core.GpuMat dst,
                                                                           int imgToDenoiseIndex,
                                                                           int temporalWindowSize,
                                                                           float h,
                                                                           float hColor,
                                                                           int templateWindowSize,
                                                                           int searchWindowSize)

fastNlMeansDenoisingColoredMulti

@Namespace(value="cv")
public static void fastNlMeansDenoisingColoredMulti(@ByVal
                                                                           opencv_core.GpuMatVector srcImgs,
                                                                           @ByVal
                                                                           opencv_core.GpuMat dst,
                                                                           int imgToDenoiseIndex,
                                                                           int temporalWindowSize)

denoise_TVL1
```
@Namespace(value="cv")
public static void denoise_TVL1(@Const @ByRef
                                                       opencv_core.MatVector observations,
                                                       @ByRef
                                                       opencv_core.Mat result,
                                                       double lambda,
                                                       int niters)
```
\brief 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 \cite 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 \cite ChambolleEtAl, it might make sense to skim over it here, following \cite 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 \f$\left\{(x,y)\in\mathbb{N}\times\mathbb{N}\mid 1\leq x\leq n,\;1\leq y\leq m\right\}\f$ for some \f$m,\;n\in\mathbb{N}\f$) into \f$\{0,1,\dots,255\}\f$. We shall denote the noised images as \f$f_i\f$ and with this view, given some image \f$x\f$ of the same size, we may measure how bad it is by the formula
\f[\left\|\left\|\nabla x\right\|\right\| + \lambda\sum_i\left\|\left\|x-f_i\right\|\right\|\f]
\f$\|\|\cdot\|\|\f$ here denotes \f$L_2\f$-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 \f$x\f$ 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 \f$\lambda\f$ 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

@Namespace(value="cv")
public static void denoise_TVL1(@Const @ByRef
                                                       opencv_core.MatVector observations,
                                                       @ByRef
                                                       opencv_core.Mat result)

createTonemap
```
@Namespace(value="cv")
 @opencv_core.Ptr
public static opencv_photo.Tonemap createTonemap(float gamma)
```
\brief 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

@Namespace(value="cv")
 @opencv_core.Ptr
public static opencv_photo.Tonemap createTonemap()

createTonemapDrago
```
@Namespace(value="cv")
 @opencv_core.Ptr
public static opencv_photo.TonemapDrago createTonemapDrago(float gamma,
                                                                                                    float saturation,
                                                                                                    float bias)
```
\brief 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

@Namespace(value="cv")
 @opencv_core.Ptr
public static opencv_photo.TonemapDrago createTonemapDrago()

createTonemapDurand

@Namespace(value="cv")
 @opencv_core.Ptr
public static opencv_photo.TonemapDurand createTonemapDurand(float gamma,
                                                                                                      float contrast,
                                                                                                      float saturation,
                                                                                                      float sigma_space,
                                                                                                      float sigma_color)

\brief Creates TonemapDurand object

Parameters:: gamma - gamma value for gamma correction. See createTonemap; contrast - resulting contrast on logarithmic scale, i. e. log(max / min), where max and min are maximum and minimum luminance values of the resulting image.; saturation - saturation enhancement value. See createTonemapDrago; sigma_space - bilateral filter sigma in color space; sigma_color - bilateral filter sigma in coordinate space

createTonemapDurand

@Namespace(value="cv")
 @opencv_core.Ptr
public static opencv_photo.TonemapDurand createTonemapDurand()

createTonemapReinhard
```
@Namespace(value="cv")
 @opencv_core.Ptr
public static opencv_photo.TonemapReinhard createTonemapReinhard(float gamma,
                                                                                                          float intensity,
                                                                                                          float light_adapt,
                                                                                                          float color_adapt)
```
\brief 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

@Namespace(value="cv")
 @opencv_core.Ptr
public static opencv_photo.TonemapReinhard createTonemapReinhard()

createTonemapMantiuk

@Namespace(value="cv")
 @opencv_core.Ptr
public static opencv_photo.TonemapMantiuk createTonemapMantiuk(float gamma,
                                                                                                        float scale,
                                                                                                        float saturation)

\brief 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

@Namespace(value="cv")
 @opencv_core.Ptr
public static opencv_photo.TonemapMantiuk createTonemapMantiuk()

createAlignMTB

@Namespace(value="cv")
 @opencv_core.Ptr
public static opencv_photo.AlignMTB createAlignMTB(int max_bits,
                                                                                            int exclude_range,
                                                                                            @Cast(value="bool")
                                                                                            boolean cut)

\brief 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

@Namespace(value="cv")
 @opencv_core.Ptr
public static opencv_photo.AlignMTB createAlignMTB()

createCalibrateDebevec

@Namespace(value="cv")
 @opencv_core.Ptr
public static opencv_photo.CalibrateDebevec createCalibrateDebevec(int samples,
                                                                                                            float lambda,
                                                                                                            @Cast(value="bool")
                                                                                                            boolean random)

\brief 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

@Namespace(value="cv")
 @opencv_core.Ptr
public static opencv_photo.CalibrateDebevec createCalibrateDebevec()

createCalibrateRobertson

@Namespace(value="cv")
 @opencv_core.Ptr
public static opencv_photo.CalibrateRobertson createCalibrateRobertson(int max_iter,
                                                                                                                float threshold)

\brief 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

@Namespace(value="cv")
 @opencv_core.Ptr
public static opencv_photo.CalibrateRobertson createCalibrateRobertson()

createMergeDebevec

@Namespace(value="cv")
 @opencv_core.Ptr
public static opencv_photo.MergeDebevec createMergeDebevec()

\brief Creates MergeDebevec object

createMergeMertens

@Namespace(value="cv")
 @opencv_core.Ptr
public static opencv_photo.MergeMertens createMergeMertens(float contrast_weight,
                                                                                                    float saturation_weight,
                                                                                                    float exposure_weight)

\brief Creates MergeMertens object

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

createMergeMertens

@Namespace(value="cv")
 @opencv_core.Ptr
public static opencv_photo.MergeMertens createMergeMertens()

createMergeRobertson

@Namespace(value="cv")
 @opencv_core.Ptr
public static opencv_photo.MergeRobertson createMergeRobertson()

\brief Creates MergeRobertson object

decolor

@Namespace(value="cv")
public static void decolor(@ByVal
                                                  opencv_core.Mat src,
                                                  @ByVal
                                                  opencv_core.Mat grayscale,
                                                  @ByVal
                                                  opencv_core.Mat color_boost)

\} photo_hdr

/** \brief 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 \cite 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.

decolor

@Namespace(value="cv")
public static void decolor(@ByVal
                                                  opencv_core.UMat src,
                                                  @ByVal
                                                  opencv_core.UMat grayscale,
                                                  @ByVal
                                                  opencv_core.UMat color_boost)

decolor

@Namespace(value="cv")
public static void decolor(@ByVal
                                                  opencv_core.GpuMat src,
                                                  @ByVal
                                                  opencv_core.GpuMat grayscale,
                                                  @ByVal
                                                  opencv_core.GpuMat color_boost)

seamlessClone
```
@Namespace(value="cv")
public static void seamlessClone(@ByVal
                                                        opencv_core.Mat src,
                                                        @ByVal
                                                        opencv_core.Mat dst,
                                                        @ByVal
                                                        opencv_core.Mat mask,
                                                        @ByVal
                                                        opencv_core.Point p,
                                                        @ByVal
                                                        opencv_core.Mat blend,
                                                        int flags)
```
\brief 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 \cite 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 one of the following: - **NORMAL_CLONE** The power of the method is fully expressed when inserting objects with complex outlines into a new background - **MIXED_CLONE** The classic method, color-based selection and alpha masking might be time consuming and often leaves an undesirable halo. Seamless cloning, even averaged with the original image, is not effective. Mixed seamless cloning based on a loose selection proves effective. - **MONOCHROME_TRANSFER** Monochrome transfer allows the user to easily replace certain features of one object by alternative features.

seamlessClone

@Namespace(value="cv")
public static void seamlessClone(@ByVal
                                                        opencv_core.UMat src,
                                                        @ByVal
                                                        opencv_core.UMat dst,
                                                        @ByVal
                                                        opencv_core.UMat mask,
                                                        @ByVal
                                                        opencv_core.Point p,
                                                        @ByVal
                                                        opencv_core.UMat blend,
                                                        int flags)

seamlessClone

@Namespace(value="cv")
public static void seamlessClone(@ByVal
                                                        opencv_core.GpuMat src,
                                                        @ByVal
                                                        opencv_core.GpuMat dst,
                                                        @ByVal
                                                        opencv_core.GpuMat mask,
                                                        @ByVal
                                                        opencv_core.Point p,
                                                        @ByVal
                                                        opencv_core.GpuMat blend,
                                                        int flags)

colorChange

@Namespace(value="cv")
public static void colorChange(@ByVal
                                                      opencv_core.Mat src,
                                                      @ByVal
                                                      opencv_core.Mat mask,
                                                      @ByVal
                                                      opencv_core.Mat dst,
                                                      float red_mul,
                                                      float green_mul,
                                                      float blue_mul)

\brief 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

@Namespace(value="cv")
public static void colorChange(@ByVal
                                                      opencv_core.Mat src,
                                                      @ByVal
                                                      opencv_core.Mat mask,
                                                      @ByVal
                                                      opencv_core.Mat dst)

colorChange

@Namespace(value="cv")
public static void colorChange(@ByVal
                                                      opencv_core.UMat src,
                                                      @ByVal
                                                      opencv_core.UMat mask,
                                                      @ByVal
                                                      opencv_core.UMat dst,
                                                      float red_mul,
                                                      float green_mul,
                                                      float blue_mul)

colorChange

@Namespace(value="cv")
public static void colorChange(@ByVal
                                                      opencv_core.UMat src,
                                                      @ByVal
                                                      opencv_core.UMat mask,
                                                      @ByVal
                                                      opencv_core.UMat dst)

colorChange

@Namespace(value="cv")
public static void colorChange(@ByVal
                                                      opencv_core.GpuMat src,
                                                      @ByVal
                                                      opencv_core.GpuMat mask,
                                                      @ByVal
                                                      opencv_core.GpuMat dst,
                                                      float red_mul,
                                                      float green_mul,
                                                      float blue_mul)

colorChange

@Namespace(value="cv")
public static void colorChange(@ByVal
                                                      opencv_core.GpuMat src,
                                                      @ByVal
                                                      opencv_core.GpuMat mask,
                                                      @ByVal
                                                      opencv_core.GpuMat dst)

illuminationChange

@Namespace(value="cv")
public static void illuminationChange(@ByVal
                                                             opencv_core.Mat src,
                                                             @ByVal
                                                             opencv_core.Mat mask,
                                                             @ByVal
                                                             opencv_core.Mat dst,
                                                             float alpha,
                                                             float beta)

\brief 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

@Namespace(value="cv")
public static void illuminationChange(@ByVal
                                                             opencv_core.Mat src,
                                                             @ByVal
                                                             opencv_core.Mat mask,
                                                             @ByVal
                                                             opencv_core.Mat dst)

illuminationChange

@Namespace(value="cv")
public static void illuminationChange(@ByVal
                                                             opencv_core.UMat src,
                                                             @ByVal
                                                             opencv_core.UMat mask,
                                                             @ByVal
                                                             opencv_core.UMat dst,
                                                             float alpha,
                                                             float beta)

illuminationChange

@Namespace(value="cv")
public static void illuminationChange(@ByVal
                                                             opencv_core.UMat src,
                                                             @ByVal
                                                             opencv_core.UMat mask,
                                                             @ByVal
                                                             opencv_core.UMat dst)

illuminationChange

@Namespace(value="cv")
public static void illuminationChange(@ByVal
                                                             opencv_core.GpuMat src,
                                                             @ByVal
                                                             opencv_core.GpuMat mask,
                                                             @ByVal
                                                             opencv_core.GpuMat dst,
                                                             float alpha,
                                                             float beta)

illuminationChange

@Namespace(value="cv")
public static void illuminationChange(@ByVal
                                                             opencv_core.GpuMat src,
                                                             @ByVal
                                                             opencv_core.GpuMat mask,
                                                             @ByVal
                                                             opencv_core.GpuMat dst)

textureFlattening

@Namespace(value="cv")
public static void textureFlattening(@ByVal
                                                            opencv_core.Mat src,
                                                            @ByVal
                                                            opencv_core.Mat mask,
                                                            @ByVal
                                                            opencv_core.Mat dst,
                                                            float low_threshold,
                                                            float high_threshold,
                                                            int kernel_size)

\brief 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

@Namespace(value="cv")
public static void textureFlattening(@ByVal
                                                            opencv_core.Mat src,
                                                            @ByVal
                                                            opencv_core.Mat mask,
                                                            @ByVal
                                                            opencv_core.Mat dst)

textureFlattening

@Namespace(value="cv")
public static void textureFlattening(@ByVal
                                                            opencv_core.UMat src,
                                                            @ByVal
                                                            opencv_core.UMat mask,
                                                            @ByVal
                                                            opencv_core.UMat dst,
                                                            float low_threshold,
                                                            float high_threshold,
                                                            int kernel_size)

textureFlattening

@Namespace(value="cv")
public static void textureFlattening(@ByVal
                                                            opencv_core.UMat src,
                                                            @ByVal
                                                            opencv_core.UMat mask,
                                                            @ByVal
                                                            opencv_core.UMat dst)

textureFlattening

@Namespace(value="cv")
public static void textureFlattening(@ByVal
                                                            opencv_core.GpuMat src,
                                                            @ByVal
                                                            opencv_core.GpuMat mask,
                                                            @ByVal
                                                            opencv_core.GpuMat dst,
                                                            float low_threshold,
                                                            float high_threshold,
                                                            int kernel_size)

textureFlattening

@Namespace(value="cv")
public static void textureFlattening(@ByVal
                                                            opencv_core.GpuMat src,
                                                            @ByVal
                                                            opencv_core.GpuMat mask,
                                                            @ByVal
                                                            opencv_core.GpuMat dst)

edgePreservingFilter

@Namespace(value="cv")
public static void edgePreservingFilter(@ByVal
                                                               opencv_core.Mat src,
                                                               @ByVal
                                                               opencv_core.Mat dst,
                                                               int flags,
                                                               float sigma_s,
                                                               float sigma_r)

\} photo_clone

\addtogroup photo_render \{

/** \brief Filtering is the fundamental operation in image and video processing. Edge-preserving smoothing filters are used in many different applications \cite EM11 .

Parameters:: src - Input 8-bit 3-channel image.; dst - Output 8-bit 3-channel image.; flags - Edge preserving filters: - **RECURS_FILTER** = 1 - **NORMCONV_FILTER** = 2; sigma_s - Range between 0 to 200.; sigma_r - Range between 0 to 1.

edgePreservingFilter

@Namespace(value="cv")
public static void edgePreservingFilter(@ByVal
                                                               opencv_core.Mat src,
                                                               @ByVal
                                                               opencv_core.Mat dst)

edgePreservingFilter

@Namespace(value="cv")
public static void edgePreservingFilter(@ByVal
                                                               opencv_core.UMat src,
                                                               @ByVal
                                                               opencv_core.UMat dst,
                                                               int flags,
                                                               float sigma_s,
                                                               float sigma_r)

edgePreservingFilter

@Namespace(value="cv")
public static void edgePreservingFilter(@ByVal
                                                               opencv_core.UMat src,
                                                               @ByVal
                                                               opencv_core.UMat dst)

edgePreservingFilter

@Namespace(value="cv")
public static void edgePreservingFilter(@ByVal
                                                               opencv_core.GpuMat src,
                                                               @ByVal
                                                               opencv_core.GpuMat dst,
                                                               int flags,
                                                               float sigma_s,
                                                               float sigma_r)

edgePreservingFilter

@Namespace(value="cv")
public static void edgePreservingFilter(@ByVal
                                                               opencv_core.GpuMat src,
                                                               @ByVal
                                                               opencv_core.GpuMat dst)

detailEnhance

@Namespace(value="cv")
public static void detailEnhance(@ByVal
                                                        opencv_core.Mat src,
                                                        @ByVal
                                                        opencv_core.Mat dst,
                                                        float sigma_s,
                                                        float sigma_r)

\brief 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

@Namespace(value="cv")
public static void detailEnhance(@ByVal
                                                        opencv_core.Mat src,
                                                        @ByVal
                                                        opencv_core.Mat dst)

detailEnhance

@Namespace(value="cv")
public static void detailEnhance(@ByVal
                                                        opencv_core.UMat src,
                                                        @ByVal
                                                        opencv_core.UMat dst,
                                                        float sigma_s,
                                                        float sigma_r)

detailEnhance

@Namespace(value="cv")
public static void detailEnhance(@ByVal
                                                        opencv_core.UMat src,
                                                        @ByVal
                                                        opencv_core.UMat dst)

detailEnhance

@Namespace(value="cv")
public static void detailEnhance(@ByVal
                                                        opencv_core.GpuMat src,
                                                        @ByVal
                                                        opencv_core.GpuMat dst,
                                                        float sigma_s,
                                                        float sigma_r)

detailEnhance

@Namespace(value="cv")
public static void detailEnhance(@ByVal
                                                        opencv_core.GpuMat src,
                                                        @ByVal
                                                        opencv_core.GpuMat dst)

pencilSketch

@Namespace(value="cv")
public static void pencilSketch(@ByVal
                                                       opencv_core.Mat src,
                                                       @ByVal
                                                       opencv_core.Mat dst1,
                                                       @ByVal
                                                       opencv_core.Mat dst2,
                                                       float sigma_s,
                                                       float sigma_r,
                                                       float shade_factor)

\brief 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

@Namespace(value="cv")
public static void pencilSketch(@ByVal
                                                       opencv_core.Mat src,
                                                       @ByVal
                                                       opencv_core.Mat dst1,
                                                       @ByVal
                                                       opencv_core.Mat dst2)

pencilSketch

@Namespace(value="cv")
public static void pencilSketch(@ByVal
                                                       opencv_core.UMat src,
                                                       @ByVal
                                                       opencv_core.UMat dst1,
                                                       @ByVal
                                                       opencv_core.UMat dst2,
                                                       float sigma_s,
                                                       float sigma_r,
                                                       float shade_factor)

pencilSketch

@Namespace(value="cv")
public static void pencilSketch(@ByVal
                                                       opencv_core.UMat src,
                                                       @ByVal
                                                       opencv_core.UMat dst1,
                                                       @ByVal
                                                       opencv_core.UMat dst2)

pencilSketch

@Namespace(value="cv")
public static void pencilSketch(@ByVal
                                                       opencv_core.GpuMat src,
                                                       @ByVal
                                                       opencv_core.GpuMat dst1,
                                                       @ByVal
                                                       opencv_core.GpuMat dst2,
                                                       float sigma_s,
                                                       float sigma_r,
                                                       float shade_factor)

pencilSketch

@Namespace(value="cv")
public static void pencilSketch(@ByVal
                                                       opencv_core.GpuMat src,
                                                       @ByVal
                                                       opencv_core.GpuMat dst1,
                                                       @ByVal
                                                       opencv_core.GpuMat dst2)

stylization

@Namespace(value="cv")
public static void stylization(@ByVal
                                                      opencv_core.Mat src,
                                                      @ByVal
                                                      opencv_core.Mat dst,
                                                      float sigma_s,
                                                      float sigma_r)

\brief 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

@Namespace(value="cv")
public static void stylization(@ByVal
                                                      opencv_core.Mat src,
                                                      @ByVal
                                                      opencv_core.Mat dst)

stylization

@Namespace(value="cv")
public static void stylization(@ByVal
                                                      opencv_core.UMat src,
                                                      @ByVal
                                                      opencv_core.UMat dst,
                                                      float sigma_s,
                                                      float sigma_r)

stylization

@Namespace(value="cv")
public static void stylization(@ByVal
                                                      opencv_core.UMat src,
                                                      @ByVal
                                                      opencv_core.UMat dst)

stylization

@Namespace(value="cv")
public static void stylization(@ByVal
                                                      opencv_core.GpuMat src,
                                                      @ByVal
                                                      opencv_core.GpuMat dst,
                                                      float sigma_s,
                                                      float sigma_r)

stylization

@Namespace(value="cv")
public static void stylization(@ByVal
                                                      opencv_core.GpuMat src,
                                                      @ByVal
                                                      opencv_core.GpuMat dst)

nonLocalMeans

@Namespace(value="cv::cuda")
public static void nonLocalMeans(@ByVal
                                                              opencv_core.Mat src,
                                                              @ByVal
                                                              opencv_core.Mat dst,
                                                              float h,
                                                              int search_window,
                                                              int block_size,
                                                              int borderMode,
                                                              @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                              opencv_core.Stream stream)

\addtogroup photo_denoise \{

/** \brief Performs pure non local means denoising without any simplification, and thus it is not fast.

Parameters:: src - Source image. Supports only CV_8UC1, CV_8UC2 and CV_8UC3.; dst - Destination image.; h - Filter sigma regulating filter strength for color.; search_window - Size of search window.; block_size - Size of block used for computing weights.; borderMode - Border type. See borderInterpolate for details. BORDER_REFLECT101 , BORDER_REPLICATE , BORDER_CONSTANT , BORDER_REFLECT and BORDER_WRAP are supported for now.; stream - Stream for the asynchronous version.
\sa fastNlMeansDenoising

nonLocalMeans

@Namespace(value="cv::cuda")
public static void nonLocalMeans(@ByVal
                                                              opencv_core.Mat src,
                                                              @ByVal
                                                              opencv_core.Mat dst,
                                                              float h)

nonLocalMeans

@Namespace(value="cv::cuda")
public static void nonLocalMeans(@ByVal
                                                              opencv_core.UMat src,
                                                              @ByVal
                                                              opencv_core.UMat dst,
                                                              float h,
                                                              int search_window,
                                                              int block_size,
                                                              int borderMode,
                                                              @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                              opencv_core.Stream stream)

nonLocalMeans

@Namespace(value="cv::cuda")
public static void nonLocalMeans(@ByVal
                                                              opencv_core.UMat src,
                                                              @ByVal
                                                              opencv_core.UMat dst,
                                                              float h)

nonLocalMeans

@Namespace(value="cv::cuda")
public static void nonLocalMeans(@ByVal
                                                              opencv_core.GpuMat src,
                                                              @ByVal
                                                              opencv_core.GpuMat dst,
                                                              float h,
                                                              int search_window,
                                                              int block_size,
                                                              int borderMode,
                                                              @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                              opencv_core.Stream stream)

nonLocalMeans

@Namespace(value="cv::cuda")
public static void nonLocalMeans(@ByVal
                                                              opencv_core.GpuMat src,
                                                              @ByVal
                                                              opencv_core.GpuMat dst,
                                                              float h)

fastNlMeansDenoising

@Namespace(value="cv::cuda")
public static void fastNlMeansDenoising(@ByVal
                                                                     opencv_core.Mat src,
                                                                     @ByVal
                                                                     opencv_core.Mat dst,
                                                                     float h,
                                                                     int search_window,
                                                                     int block_size,
                                                                     @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                     opencv_core.Stream stream)

\brief Perform image denoising using Non-local Means Denoising algorithm with several computational optimizations. Noise expected to be a gaussian white noise

Parameters:

src - Input 8-bit 1-channel, 2-channel or 3-channel image.

dst - Output image with the same size and type as src .

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

search_window - Size in pixels of the window that is used to compute weighted average for given pixel. Should be odd. Affect performance linearly: greater search_window - greater denoising time. Recommended value 21 pixels

block_size - Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels

stream - Stream for the asynchronous invocations.

This function expected to be applied to grayscale images. For colored images look at FastNonLocalMeansDenoising::labMethod.

\sa fastNlMeansDenoising

fastNlMeansDenoising

@Namespace(value="cv::cuda")
public static void fastNlMeansDenoising(@ByVal
                                                                     opencv_core.Mat src,
                                                                     @ByVal
                                                                     opencv_core.Mat dst,
                                                                     float h)

fastNlMeansDenoising

@Namespace(value="cv::cuda")
public static void fastNlMeansDenoising(@ByVal
                                                                     opencv_core.UMat src,
                                                                     @ByVal
                                                                     opencv_core.UMat dst,
                                                                     float h,
                                                                     int search_window,
                                                                     int block_size,
                                                                     @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                     opencv_core.Stream stream)

fastNlMeansDenoising

@Namespace(value="cv::cuda")
public static void fastNlMeansDenoising(@ByVal
                                                                     opencv_core.UMat src,
                                                                     @ByVal
                                                                     opencv_core.UMat dst,
                                                                     float h)

fastNlMeansDenoising

@Namespace(value="cv::cuda")
public static void fastNlMeansDenoising(@ByVal
                                                                     opencv_core.GpuMat src,
                                                                     @ByVal
                                                                     opencv_core.GpuMat dst,
                                                                     float h,
                                                                     int search_window,
                                                                     int block_size,
                                                                     @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                     opencv_core.Stream stream)

fastNlMeansDenoising

@Namespace(value="cv::cuda")
public static void fastNlMeansDenoising(@ByVal
                                                                     opencv_core.GpuMat src,
                                                                     @ByVal
                                                                     opencv_core.GpuMat dst,
                                                                     float h)

fastNlMeansDenoisingColored

@Namespace(value="cv::cuda")
public static void fastNlMeansDenoisingColored(@ByVal
                                                                            opencv_core.Mat src,
                                                                            @ByVal
                                                                            opencv_core.Mat dst,
                                                                            float h_luminance,
                                                                            float photo_render,
                                                                            int search_window,
                                                                            int block_size,
                                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                            opencv_core.Stream stream)

\brief 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 .

h_luminance - 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

photo_render - float 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

block_size - Size in pixels of the template patch that is used to compute weights. Should be odd. Recommended value 7 pixels

stream - Stream for the asynchronous invocations.

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

\sa fastNlMeansDenoisingColored

fastNlMeansDenoisingColored

@Namespace(value="cv::cuda")
public static void fastNlMeansDenoisingColored(@ByVal
                                                                            opencv_core.Mat src,
                                                                            @ByVal
                                                                            opencv_core.Mat dst,
                                                                            float h_luminance,
                                                                            float photo_render)

fastNlMeansDenoisingColored

@Namespace(value="cv::cuda")
public static void fastNlMeansDenoisingColored(@ByVal
                                                                            opencv_core.UMat src,
                                                                            @ByVal
                                                                            opencv_core.UMat dst,
                                                                            float h_luminance,
                                                                            float photo_render,
                                                                            int search_window,
                                                                            int block_size,
                                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                            opencv_core.Stream stream)

fastNlMeansDenoisingColored

@Namespace(value="cv::cuda")
public static void fastNlMeansDenoisingColored(@ByVal
                                                                            opencv_core.UMat src,
                                                                            @ByVal
                                                                            opencv_core.UMat dst,
                                                                            float h_luminance,
                                                                            float photo_render)

fastNlMeansDenoisingColored

@Namespace(value="cv::cuda")
public static void fastNlMeansDenoisingColored(@ByVal
                                                                            opencv_core.GpuMat src,
                                                                            @ByVal
                                                                            opencv_core.GpuMat dst,
                                                                            float h_luminance,
                                                                            float photo_render,
                                                                            int search_window,
                                                                            int block_size,
                                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                            opencv_core.Stream stream)

fastNlMeansDenoisingColored

@Namespace(value="cv::cuda")
public static void fastNlMeansDenoisingColored(@ByVal
                                                                            opencv_core.GpuMat src,
                                                                            @ByVal
                                                                            opencv_core.GpuMat dst,
                                                                            float h_luminance,
                                                                            float photo_render)

Class opencv_photo

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.javacpp.presets.opencv_photo

Methods inherited from class java.lang.Object

Field Detail

CV_INPAINT_NS

CV_INPAINT_TELEA

INPAINT_NS

INPAINT_TELEA

NORMAL_CLONE

MIXED_CLONE

MONOCHROME_TRANSFER

RECURS_FILTER

NORMCONV_FILTER

LDR_SIZE

Constructor Detail

opencv_photo

Method Detail

cvInpaint

inpaint

inpaint

inpaint

fastNlMeansDenoising

fastNlMeansDenoising

fastNlMeansDenoising

fastNlMeansDenoising

fastNlMeansDenoising

fastNlMeansDenoising

fastNlMeansDenoising

fastNlMeansDenoising

fastNlMeansDenoising

fastNlMeansDenoising

fastNlMeansDenoising

fastNlMeansDenoising

fastNlMeansDenoising

fastNlMeansDenoising

fastNlMeansDenoising

fastNlMeansDenoising

fastNlMeansDenoising

fastNlMeansDenoising

fastNlMeansDenoising

fastNlMeansDenoising

fastNlMeansDenoising

fastNlMeansDenoising

fastNlMeansDenoising

fastNlMeansDenoising

fastNlMeansDenoisingColored

fastNlMeansDenoisingColored

fastNlMeansDenoisingColored

fastNlMeansDenoisingColored

fastNlMeansDenoisingColored

fastNlMeansDenoisingColored

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti