opencv_photo (JavaCPP Presets for OpenCV 4.3.0-1.5.3 API)

java.lang.Object
- org.bytedeco.opencv.presets.opencv_photo
- - org.bytedeco.opencv.global.opencv_photo

All Implemented Interfaces:: InfoMapper

public class opencv_photo
extends opencv_photo

Field Summary

Fields
Modifier and Type	Field and Description
`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(GpuMat src, GpuMat mask, GpuMat dst)`
`static void`	`colorChange(GpuMat src, GpuMat mask, GpuMat dst, float red_mul, float green_mul, float blue_mul)`
`static void`	`colorChange(Mat src, Mat mask, Mat dst)`
`static void`	`colorChange(Mat src, Mat mask, 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(UMat src, UMat mask, UMat dst)`
`static void`	`colorChange(UMat src, UMat mask, UMat dst, float red_mul, float green_mul, float blue_mul)`
`static AlignMTB`	`createAlignMTB()`
`static AlignMTB`	`createAlignMTB(int max_bits, int exclude_range, boolean cut)` \brief Creates AlignMTB object
`static CalibrateDebevec`	`createCalibrateDebevec()`
`static CalibrateDebevec`	`createCalibrateDebevec(int samples, float lambda, boolean random)` \brief Creates CalibrateDebevec object
`static CalibrateRobertson`	`createCalibrateRobertson()`
`static CalibrateRobertson`	`createCalibrateRobertson(int max_iter, float threshold)` \brief Creates CalibrateRobertson object
`static MergeDebevec`	`createMergeDebevec()` \brief Creates MergeDebevec object
`static MergeMertens`	`createMergeMertens()`
`static MergeMertens`	`createMergeMertens(float contrast_weight, float saturation_weight, float exposure_weight)` \brief Creates MergeMertens object
`static MergeRobertson`	`createMergeRobertson()` \brief Creates MergeRobertson object
`static Tonemap`	`createTonemap()`
`static Tonemap`	`createTonemap(float gamma)` \brief Creates simple linear mapper with gamma correction
`static TonemapDrago`	`createTonemapDrago()`
`static TonemapDrago`	`createTonemapDrago(float gamma, float saturation, float bias)` \brief Creates TonemapDrago object
`static TonemapMantiuk`	`createTonemapMantiuk()`
`static TonemapMantiuk`	`createTonemapMantiuk(float gamma, float scale, float saturation)` \brief Creates TonemapMantiuk object
`static TonemapReinhard`	`createTonemapReinhard()`
`static TonemapReinhard`	`createTonemapReinhard(float gamma, float intensity, float light_adapt, float color_adapt)` \brief Creates TonemapReinhard object
`static void`	`decolor(GpuMat src, GpuMat grayscale, GpuMat color_boost)`
`static void`	`decolor(Mat src, Mat grayscale, Mat color_boost)` \} photo_hdr
`static void`	`decolor(UMat src, UMat grayscale, UMat color_boost)`
`static void`	`denoise_TVL1(MatVector observations, Mat result)`
`static void`	`denoise_TVL1(MatVector observations, 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(GpuMat src, GpuMat dst)`
`static void`	`detailEnhance(GpuMat src, GpuMat dst, float sigma_s, float sigma_r)`
`static void`	`detailEnhance(Mat src, Mat dst)`
`static void`	`detailEnhance(Mat src, Mat dst, float sigma_s, float sigma_r)` \brief This filter enhances the details of a particular image.
`static void`	`detailEnhance(UMat src, UMat dst)`
`static void`	`detailEnhance(UMat src, UMat dst, float sigma_s, float sigma_r)`
`static void`	`edgePreservingFilter(GpuMat src, GpuMat dst)`
`static void`	`edgePreservingFilter(GpuMat src, GpuMat dst, int flags, float sigma_s, float sigma_r)`
`static void`	`edgePreservingFilter(Mat src, Mat dst)`
`static void`	`edgePreservingFilter(Mat src, Mat dst, int flags, float sigma_s, float sigma_r)` \brief Filtering is the fundamental operation in image and video processing.
`static void`	`edgePreservingFilter(UMat src, UMat dst)`
`static void`	`edgePreservingFilter(UMat src, UMat dst, int flags, float sigma_s, float sigma_r)`
`static void`	`fastNlMeansDenoising(GpuMat src, GpuMat dst)`
`static void`	`fastNlMeansDenoising(GpuMat src, GpuMat dst, float h)`
`static void`	`fastNlMeansDenoising(GpuMat src, GpuMat dst, float[] h)`
`static void`	`fastNlMeansDenoising(GpuMat src, GpuMat dst, float[] h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoising(GpuMat src, GpuMat dst, FloatBuffer h)`
`static void`	`fastNlMeansDenoising(GpuMat src, GpuMat dst, FloatBuffer h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoising(GpuMat src, GpuMat dst, float h, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoising(GpuMat src, GpuMat dst, float h, int search_window, int block_size, Stream stream)`
`static void`	`fastNlMeansDenoising(GpuMat src, GpuMat dst, FloatPointer h)`
`static void`	`fastNlMeansDenoising(GpuMat src, GpuMat dst, FloatPointer h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoising(Mat src, Mat dst)`
`static void`	`fastNlMeansDenoising(Mat src, Mat dst, float h)`
`static void`	`fastNlMeansDenoising(Mat src, Mat dst, float[] h)`
`static void`	`fastNlMeansDenoising(Mat src, Mat dst, float[] h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoising(Mat src, Mat dst, FloatBuffer h)`
`static void`	`fastNlMeansDenoising(Mat src, Mat dst, FloatBuffer h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoising(Mat src, Mat dst, float h, int templateWindowSize, int searchWindowSize)` \} photo_inpaint
`static void`	`fastNlMeansDenoising(Mat src, Mat dst, float h, int search_window, int block_size, Stream stream)` \brief Perform image denoising using Non-local Means Denoising algorithm with several computational optimizations.
`static void`	`fastNlMeansDenoising(Mat src, Mat dst, FloatPointer h)`
`static void`	`fastNlMeansDenoising(Mat src, Mat dst, 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(UMat src, UMat dst)`
`static void`	`fastNlMeansDenoising(UMat src, UMat dst, float h)`
`static void`	`fastNlMeansDenoising(UMat src, UMat dst, float[] h)`
`static void`	`fastNlMeansDenoising(UMat src, UMat dst, float[] h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoising(UMat src, UMat dst, FloatBuffer h)`
`static void`	`fastNlMeansDenoising(UMat src, UMat dst, FloatBuffer h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoising(UMat src, UMat dst, float h, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoising(UMat src, UMat dst, float h, int search_window, int block_size, Stream stream)`
`static void`	`fastNlMeansDenoising(UMat src, UMat dst, FloatPointer h)`
`static void`	`fastNlMeansDenoising(UMat src, UMat dst, FloatPointer h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoisingColored(GpuMat src, GpuMat dst)`
`static void`	`fastNlMeansDenoisingColored(GpuMat src, GpuMat dst, float h_luminance, float photo_render)`
`static void`	`fastNlMeansDenoisingColored(GpuMat src, GpuMat dst, float h, float hColor, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingColored(GpuMat src, GpuMat dst, float h_luminance, float photo_render, int search_window, int block_size, Stream stream)`
`static void`	`fastNlMeansDenoisingColored(Mat src, Mat dst)`
`static void`	`fastNlMeansDenoisingColored(Mat src, Mat dst, float h_luminance, float photo_render)`
`static void`	`fastNlMeansDenoisingColored(Mat src, Mat dst, float h, float hColor, int templateWindowSize, int searchWindowSize)` \brief Modification of fastNlMeansDenoising function for colored images
`static void`	`fastNlMeansDenoisingColored(Mat src, Mat dst, float h_luminance, float photo_render, int search_window, int block_size, Stream stream)` \brief Modification of fastNlMeansDenoising function for colored images
`static void`	`fastNlMeansDenoisingColored(UMat src, UMat dst)`
`static void`	`fastNlMeansDenoisingColored(UMat src, UMat dst, float h_luminance, float photo_render)`
`static void`	`fastNlMeansDenoisingColored(UMat src, UMat dst, float h, float hColor, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingColored(UMat src, UMat dst, float h_luminance, float photo_render, int search_window, int block_size, Stream stream)`
`static void`	`fastNlMeansDenoisingColoredMulti(GpuMatVector srcImgs, GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(GpuMatVector srcImgs, GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(GpuMatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(GpuMatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(GpuMatVector srcImgs, UMat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(GpuMatVector srcImgs, UMat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(MatVector srcImgs, GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(MatVector srcImgs, GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(MatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(MatVector srcImgs, 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(MatVector srcImgs, UMat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(MatVector srcImgs, UMat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(UMatVector srcImgs, GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(UMatVector srcImgs, GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(UMatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(UMatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(UMatVector srcImgs, UMat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingColoredMulti(UMatVector srcImgs, UMat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, float hColor, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(GpuMatVector srcImgs, GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(GpuMatVector srcImgs, GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize, float[] h)`
`static void`	`fastNlMeansDenoisingMulti(GpuMatVector srcImgs, GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize, float[] h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoisingMulti(GpuMatVector srcImgs, GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(GpuMatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(GpuMatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float[] h)`
`static void`	`fastNlMeansDenoisingMulti(GpuMatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float[] h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoisingMulti(GpuMatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(GpuMatVector srcImgs, UMat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(GpuMatVector srcImgs, UMat dst, int imgToDenoiseIndex, int temporalWindowSize, float[] h)`
`static void`	`fastNlMeansDenoisingMulti(GpuMatVector srcImgs, UMat dst, int imgToDenoiseIndex, int temporalWindowSize, float[] h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoisingMulti(GpuMatVector srcImgs, UMat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(MatVector srcImgs, GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(MatVector srcImgs, GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(MatVector srcImgs, GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize, FloatPointer h)`
`static void`	`fastNlMeansDenoisingMulti(MatVector srcImgs, GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize, FloatPointer h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoisingMulti(MatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(MatVector srcImgs, 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(MatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, FloatPointer h)`
`static void`	`fastNlMeansDenoisingMulti(MatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, 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(MatVector srcImgs, UMat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(MatVector srcImgs, UMat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(MatVector srcImgs, UMat dst, int imgToDenoiseIndex, int temporalWindowSize, FloatPointer h)`
`static void`	`fastNlMeansDenoisingMulti(MatVector srcImgs, UMat dst, int imgToDenoiseIndex, int temporalWindowSize, FloatPointer h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoisingMulti(UMatVector srcImgs, GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(UMatVector srcImgs, GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize, FloatBuffer h)`
`static void`	`fastNlMeansDenoisingMulti(UMatVector srcImgs, GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize, FloatBuffer h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoisingMulti(UMatVector srcImgs, GpuMat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(UMatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(UMatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, FloatBuffer h)`
`static void`	`fastNlMeansDenoisingMulti(UMatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, FloatBuffer h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoisingMulti(UMatVector srcImgs, Mat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(UMatVector srcImgs, UMat dst, int imgToDenoiseIndex, int temporalWindowSize)`
`static void`	`fastNlMeansDenoisingMulti(UMatVector srcImgs, UMat dst, int imgToDenoiseIndex, int temporalWindowSize, FloatBuffer h)`
`static void`	`fastNlMeansDenoisingMulti(UMatVector srcImgs, UMat dst, int imgToDenoiseIndex, int temporalWindowSize, FloatBuffer h, int templateWindowSize, int searchWindowSize, int normType)`
`static void`	`fastNlMeansDenoisingMulti(UMatVector srcImgs, UMat dst, int imgToDenoiseIndex, int temporalWindowSize, float h, int templateWindowSize, int searchWindowSize)`
`static void`	`illuminationChange(GpuMat src, GpuMat mask, GpuMat dst)`
`static void`	`illuminationChange(GpuMat src, GpuMat mask, GpuMat dst, float alpha, float beta)`
`static void`	`illuminationChange(Mat src, Mat mask, Mat dst)`
`static void`	`illuminationChange(Mat src, Mat mask, 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(UMat src, UMat mask, UMat dst)`
`static void`	`illuminationChange(UMat src, UMat mask, UMat dst, float alpha, float beta)`
`static void`	`inpaint(GpuMat src, GpuMat inpaintMask, GpuMat dst, double inpaintRadius, int flags)`
`static void`	`inpaint(Mat src, Mat inpaintMask, Mat dst, double inpaintRadius, int flags)` \brief Restores the selected region in an image using the region neighborhood.
`static void`	`inpaint(UMat src, UMat inpaintMask, UMat dst, double inpaintRadius, int flags)`
`static void`	`nonLocalMeans(GpuMat src, GpuMat dst, float h)`
`static void`	`nonLocalMeans(GpuMat src, GpuMat dst, float h, int search_window, int block_size, int borderMode, Stream stream)`
`static void`	`nonLocalMeans(Mat src, Mat dst, float h)`
`static void`	`nonLocalMeans(Mat src, Mat dst, float h, int search_window, int block_size, int borderMode, Stream stream)` \addtogroup photo_denoise \{
`static void`	`nonLocalMeans(UMat src, UMat dst, float h)`
`static void`	`nonLocalMeans(UMat src, UMat dst, float h, int search_window, int block_size, int borderMode, Stream stream)`
`static void`	`pencilSketch(GpuMat src, GpuMat dst1, GpuMat dst2)`
`static void`	`pencilSketch(GpuMat src, GpuMat dst1, GpuMat dst2, float sigma_s, float sigma_r, float shade_factor)`
`static void`	`pencilSketch(Mat src, Mat dst1, Mat dst2)`
`static void`	`pencilSketch(Mat src, Mat dst1, Mat dst2, float sigma_s, float sigma_r, float shade_factor)` \brief Pencil-like non-photorealistic line drawing
`static void`	`pencilSketch(UMat src, UMat dst1, UMat dst2)`
`static void`	`pencilSketch(UMat src, UMat dst1, UMat dst2, float sigma_s, float sigma_r, float shade_factor)`
`static void`	`seamlessClone(GpuMat src, GpuMat dst, GpuMat mask, Point p, GpuMat blend, int flags)`
`static void`	`seamlessClone(Mat src, Mat dst, Mat mask, Point p, 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(UMat src, UMat dst, UMat mask, Point p, UMat blend, int flags)`
`static void`	`stylization(GpuMat src, GpuMat dst)`
`static void`	`stylization(GpuMat src, GpuMat dst, float sigma_s, float sigma_r)`
`static void`	`stylization(Mat src, Mat dst)`
`static void`	`stylization(Mat src, 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(UMat src, UMat dst)`
`static void`	`stylization(UMat src, UMat dst, float sigma_s, float sigma_r)`
`static void`	`textureFlattening(GpuMat src, GpuMat mask, GpuMat dst)`
`static void`	`textureFlattening(GpuMat src, GpuMat mask, GpuMat dst, float low_threshold, float high_threshold, int kernel_size)`
`static void`	`textureFlattening(Mat src, Mat mask, Mat dst)`
`static void`	`textureFlattening(Mat src, Mat mask, 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(UMat src, UMat mask, UMat dst)`
`static void`	`textureFlattening(UMat src, UMat mask, UMat dst, float low_threshold, float high_threshold, int kernel_size)`

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

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

Field Detail
- 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
- LDR_SIZE
```
public static final int LDR_SIZE
```
  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

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

Method Detail

inpaint
```
@Namespace(value="cv")
public static void inpaint(@ByVal
                                                  Mat src,
                                                  @ByVal
                                                  Mat inpaintMask,
                                                  @ByVal
                                                  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 cv::INPAINT_NS or cv::INPAINT_TELEA
The function reconstructs the selected image area from the pixel near the area boundary. The function may be used to remove dust and scratches from a scanned photo, or to remove undesirable objects from still images or video. See 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
                                                  UMat src,
                                                  @ByVal
                                                  UMat inpaintMask,
                                                  @ByVal
                                                  UMat dst,
                                                  double inpaintRadius,
                                                  int flags)

inpaint

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

fastNlMeansDenoising
```
@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               Mat src,
                                                               @ByVal
                                                               Mat dst,
                                                               float h,
                                                               int templateWindowSize,
                                                               int searchWindowSize)
```
\} photo_inpaint
\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
                                                               Mat src,
                                                               @ByVal
                                                               Mat dst)

fastNlMeansDenoising

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

fastNlMeansDenoising

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

fastNlMeansDenoising

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

fastNlMeansDenoising

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

fastNlMeansDenoising
```
@Namespace(value="cv")
public static void fastNlMeansDenoising(@ByVal
                                                               Mat src,
                                                               @ByVal
                                                               Mat dst,
                                                               @StdVector
                                                               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
                                                               Mat src,
                                                               @ByVal
                                                               Mat dst,
                                                               @StdVector
                                                               FloatPointer h)

fastNlMeansDenoising

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

fastNlMeansDenoising

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

fastNlMeansDenoising

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

fastNlMeansDenoising

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

fastNlMeansDenoising

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

fastNlMeansDenoising

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

fastNlMeansDenoising

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

fastNlMeansDenoising

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

fastNlMeansDenoising

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

fastNlMeansDenoising

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

fastNlMeansDenoising

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

fastNlMeansDenoising

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

fastNlMeansDenoising

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

fastNlMeansDenoising

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

fastNlMeansDenoising

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

fastNlMeansDenoising

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

fastNlMeansDenoisingColored
```
@Namespace(value="cv")
public static void fastNlMeansDenoisingColored(@ByVal
                                                                      Mat src,
                                                                      @ByVal
                                                                      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
                                                                      Mat src,
                                                                      @ByVal
                                                                      Mat dst)

fastNlMeansDenoisingColored

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

fastNlMeansDenoisingColored

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

fastNlMeansDenoisingColored

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

fastNlMeansDenoisingColored

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

fastNlMeansDenoisingMulti
```
@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    MatVector srcImgs,
                                                                    @ByVal
                                                                    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
                                                                    MatVector srcImgs,
                                                                    @ByVal
                                                                    Mat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize)

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti
```
@Namespace(value="cv")
public static void fastNlMeansDenoisingMulti(@ByVal
                                                                    MatVector srcImgs,
                                                                    @ByVal
                                                                    Mat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    @StdVector
                                                                    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
                                                                    MatVector srcImgs,
                                                                    @ByVal
                                                                    Mat dst,
                                                                    int imgToDenoiseIndex,
                                                                    int temporalWindowSize,
                                                                    @StdVector
                                                                    FloatPointer h)

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingMulti

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

fastNlMeansDenoisingColoredMulti
```
@Namespace(value="cv")
public static void fastNlMeansDenoisingColoredMulti(@ByVal
                                                                           MatVector srcImgs,
                                                                           @ByVal
                                                                           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
                                                                           MatVector srcImgs,
                                                                           @ByVal
                                                                           Mat dst,
                                                                           int imgToDenoiseIndex,
                                                                           int temporalWindowSize)

fastNlMeansDenoisingColoredMulti

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

fastNlMeansDenoisingColoredMulti

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

fastNlMeansDenoisingColoredMulti

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

fastNlMeansDenoisingColoredMulti

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

fastNlMeansDenoisingColoredMulti

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

fastNlMeansDenoisingColoredMulti

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

fastNlMeansDenoisingColoredMulti

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

fastNlMeansDenoisingColoredMulti

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

fastNlMeansDenoisingColoredMulti

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

fastNlMeansDenoisingColoredMulti

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

fastNlMeansDenoisingColoredMulti

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

fastNlMeansDenoisingColoredMulti

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

fastNlMeansDenoisingColoredMulti

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

fastNlMeansDenoisingColoredMulti

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

fastNlMeansDenoisingColoredMulti

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

fastNlMeansDenoisingColoredMulti

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

denoise_TVL1
```
@Namespace(value="cv")
public static void denoise_TVL1(@Const @ByRef
                                                       MatVector observations,
                                                       @ByRef
                                                       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 \left\{(x,y)\in\mathbb{N}\times\mathbb{N}\mid 1\leq x\leq n,\;1\leq y\leq m\right\} for some m,\;n\in\mathbb{N}) into \{0,1,\dots,255\}. We shall denote the noised images as f_i and with this view, given some image x of the same size, we may measure how bad it is by the formula
```
 \[\left\|\left\|\nabla x\right\|\right\| + \lambda\sum_i\left\|\left\|x-f_i\right\|\right\|\]
```
\|\|\cdot\|\| here denotes L_2-norm and as you see, the first addend states that we want our image to be smooth (ideally, having zero gradient, thus being constant) and the second states that we want our result to be close to the observations we've got. If we treat x as a function, this is exactly the functional what we seek to minimize and here the Primal-Dual algorithm comes into play.
Parameters:

observations - This array should contain one or more noised versions of the image that is to be restored.

result - Here the denoised image will be stored. There is no need to do pre-allocation of storage space, as it will be automatically allocated, if necessary.

lambda - Corresponds to \lambda in the formulas above. As it is enlarged, the smooth (blurred) images are treated more favorably than detailed (but maybe more noised) ones. Roughly speaking, as it becomes smaller, the result will be more blur but more sever outliers will be removed.

niters - Number of iterations that the algorithm will run. Of course, as more iterations as better, but it is hard to quantitatively refine this statement, so just use the default and increase it if the results are poor.

denoise_TVL1

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

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

createTonemapDrago
```
@Namespace(value="cv")
 @opencv_core.Ptr
public static 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 TonemapDrago createTonemapDrago()

createTonemapReinhard
```
@Namespace(value="cv")
 @opencv_core.Ptr
public static 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 TonemapReinhard createTonemapReinhard()

createTonemapMantiuk
```
@Namespace(value="cv")
 @opencv_core.Ptr
public static 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 TonemapMantiuk createTonemapMantiuk()

createAlignMTB

@Namespace(value="cv")
 @opencv_core.Ptr
public static 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 AlignMTB createAlignMTB()

createCalibrateDebevec

@Namespace(value="cv")
 @opencv_core.Ptr
public static 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 CalibrateDebevec createCalibrateDebevec()

createCalibrateRobertson

@Namespace(value="cv")
 @opencv_core.Ptr
public static 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 CalibrateRobertson createCalibrateRobertson()

createMergeDebevec

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

\brief Creates MergeDebevec object

createMergeMertens

@Namespace(value="cv")
 @opencv_core.Ptr
public static 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 MergeMertens createMergeMertens()

createMergeRobertson

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

\brief Creates MergeRobertson object

decolor

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

\} photo_hdr

\addtogroup photo_decolor \{

/** \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
                                                  UMat src,
                                                  @ByVal
                                                  UMat grayscale,
                                                  @ByVal
                                                  UMat color_boost)

decolor

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

seamlessClone

@Namespace(value="cv")
public static void seamlessClone(@ByVal
                                                        Mat src,
                                                        @ByVal
                                                        Mat dst,
                                                        @ByVal
                                                        Mat mask,
                                                        @ByVal
                                                        Point p,
                                                        @ByVal
                                                        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 cv::NORMAL_CLONE, cv::MIXED_CLONE or cv::MONOCHROME_TRANSFER

seamlessClone

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

seamlessClone

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

colorChange

@Namespace(value="cv")
public static void colorChange(@ByVal
                                                      Mat src,
                                                      @ByVal
                                                      Mat mask,
                                                      @ByVal
                                                      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
                                                      Mat src,
                                                      @ByVal
                                                      Mat mask,
                                                      @ByVal
                                                      Mat dst)

colorChange

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

colorChange

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

colorChange

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

colorChange

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

illuminationChange

@Namespace(value="cv")
public static void illuminationChange(@ByVal
                                                             Mat src,
                                                             @ByVal
                                                             Mat mask,
                                                             @ByVal
                                                             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
                                                             Mat src,
                                                             @ByVal
                                                             Mat mask,
                                                             @ByVal
                                                             Mat dst)

illuminationChange

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

illuminationChange

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

illuminationChange

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

illuminationChange

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

textureFlattening

@Namespace(value="cv")
public static void textureFlattening(@ByVal
                                                            Mat src,
                                                            @ByVal
                                                            Mat mask,
                                                            @ByVal
                                                            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
                                                            Mat src,
                                                            @ByVal
                                                            Mat mask,
                                                            @ByVal
                                                            Mat dst)

textureFlattening

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

textureFlattening

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

textureFlattening

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

textureFlattening

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

edgePreservingFilter

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

\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: cv::RECURS_FILTER or cv::NORMCONV_FILTER; sigma_s - %Range between 0 to 200.; sigma_r - %Range between 0 to 1.

edgePreservingFilter

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

edgePreservingFilter

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

edgePreservingFilter

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

edgePreservingFilter

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

edgePreservingFilter

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

detailEnhance

@Namespace(value="cv")
public static void detailEnhance(@ByVal
                                                        Mat src,
                                                        @ByVal
                                                        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
                                                        Mat src,
                                                        @ByVal
                                                        Mat dst)

detailEnhance

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

detailEnhance

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

detailEnhance

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

detailEnhance

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

pencilSketch

@Namespace(value="cv")
public static void pencilSketch(@ByVal
                                                       Mat src,
                                                       @ByVal
                                                       Mat dst1,
                                                       @ByVal
                                                       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
                                                       Mat src,
                                                       @ByVal
                                                       Mat dst1,
                                                       @ByVal
                                                       Mat dst2)

pencilSketch

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

pencilSketch

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

pencilSketch

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

pencilSketch

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

stylization

@Namespace(value="cv")
public static void stylization(@ByVal
                                                      Mat src,
                                                      @ByVal
                                                      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
                                                      Mat src,
                                                      @ByVal
                                                      Mat dst)

stylization

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

stylization

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

stylization

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

stylization

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

nonLocalMeans

@Namespace(value="cv::cuda")
public static void nonLocalMeans(@ByVal
                                                              Mat src,
                                                              @ByVal
                                                              Mat dst,
                                                              float h,
                                                              int search_window,
                                                              int block_size,
                                                              int borderMode,
                                                              @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                              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.
See Also:: fastNlMeansDenoising

nonLocalMeans

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

nonLocalMeans

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

nonLocalMeans

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

nonLocalMeans

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

nonLocalMeans

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

fastNlMeansDenoising

@Namespace(value="cv::cuda")
public static void fastNlMeansDenoising(@ByVal
                                                                     Mat src,
                                                                     @ByVal
                                                                     Mat dst,
                                                                     float h,
                                                                     int search_window,
                                                                     int block_size,
                                                                     @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                     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.

See Also:

fastNlMeansDenoising

fastNlMeansDenoising

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

fastNlMeansDenoising

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

fastNlMeansDenoising

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

fastNlMeansDenoising

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

fastNlMeansDenoising

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

fastNlMeansDenoisingColored

@Namespace(value="cv::cuda")
public static void fastNlMeansDenoisingColored(@ByVal
                                                                            Mat src,
                                                                            @ByVal
                                                                            Mat dst,
                                                                            float h_luminance,
                                                                            float photo_render,
                                                                            int search_window,
                                                                            int block_size,
                                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                            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.

See Also:

fastNlMeansDenoisingColored

fastNlMeansDenoisingColored

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

fastNlMeansDenoisingColored

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

fastNlMeansDenoisingColored

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

fastNlMeansDenoisingColored

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

fastNlMeansDenoisingColored

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

Class opencv_photo

Field Summary

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Field Detail

INPAINT_NS

INPAINT_TELEA

LDR_SIZE

NORMAL_CLONE

MIXED_CLONE

MONOCHROME_TRANSFER

RECURS_FILTER

NORMCONV_FILTER

Constructor Detail

opencv_photo

Method Detail

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

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti

fastNlMeansDenoisingMulti