opencv_cudaimgproc (JavaCPP Presets for OpenCV 4.10.0-1.5.11 API)

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

All Implemented Interfaces:: InfoMapper

public class opencv_cudaimgproc
extends opencv_cudaimgproc

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ALPHA_ATOP` enum cv::cuda::AlphaCompTypes
`static int`	`ALPHA_ATOP_PREMUL` enum cv::cuda::AlphaCompTypes
`static int`	`ALPHA_IN` enum cv::cuda::AlphaCompTypes
`static int`	`ALPHA_IN_PREMUL` enum cv::cuda::AlphaCompTypes
`static int`	`ALPHA_OUT` enum cv::cuda::AlphaCompTypes
`static int`	`ALPHA_OUT_PREMUL` enum cv::cuda::AlphaCompTypes
`static int`	`ALPHA_OVER` enum cv::cuda::AlphaCompTypes
`static int`	`ALPHA_OVER_PREMUL` enum cv::cuda::AlphaCompTypes
`static int`	`ALPHA_PLUS` enum cv::cuda::AlphaCompTypes
`static int`	`ALPHA_PLUS_PREMUL` enum cv::cuda::AlphaCompTypes
`static int`	`ALPHA_PREMUL` enum cv::cuda::AlphaCompTypes
`static int`	`ALPHA_XOR` enum cv::cuda::AlphaCompTypes
`static int`	`ALPHA_XOR_PREMUL` enum cv::cuda::AlphaCompTypes
`static int`	`CCL_BKE` enum cv::cuda::ConnectedComponentsAlgorithmsTypes
`static int`	`CCL_DEFAULT` enum cv::cuda::ConnectedComponentsAlgorithmsTypes
`static int`	`COLOR_BayerBG2BGR_MHT` enum cv::cuda::DemosaicTypes
`static int`	`COLOR_BayerBG2GRAY_MHT` enum cv::cuda::DemosaicTypes
`static int`	`COLOR_BayerBG2RGB_MHT` enum cv::cuda::DemosaicTypes
`static int`	`COLOR_BayerGB2BGR_MHT` enum cv::cuda::DemosaicTypes
`static int`	`COLOR_BayerGB2GRAY_MHT` enum cv::cuda::DemosaicTypes
`static int`	`COLOR_BayerGB2RGB_MHT` enum cv::cuda::DemosaicTypes
`static int`	`COLOR_BayerGR2BGR_MHT` enum cv::cuda::DemosaicTypes
`static int`	`COLOR_BayerGR2GRAY_MHT` enum cv::cuda::DemosaicTypes
`static int`	`COLOR_BayerGR2RGB_MHT` enum cv::cuda::DemosaicTypes
`static int`	`COLOR_BayerRG2BGR_MHT` enum cv::cuda::DemosaicTypes
`static int`	`COLOR_BayerRG2GRAY_MHT` enum cv::cuda::DemosaicTypes
`static int`	`COLOR_BayerRG2RGB_MHT` enum cv::cuda::DemosaicTypes
`static int`	`FIRST_ORDER_MOMENTS` enum cv::cuda::MomentsOrder
`static int`	`SECOND_ORDER_MOMENTS` enum cv::cuda::MomentsOrder
`static int`	`THIRD_ORDER_MOMENTS` enum cv::cuda::MomentsOrder

Constructor Summary

Constructors
Constructor and Description

opencv_cudaimgproc()

Constructors
Constructor and Description
`opencv_cudaimgproc()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`alphaComp(GpuMat img1, GpuMat img2, GpuMat dst, int alpha_op)`
`static void`	`alphaComp(GpuMat img1, GpuMat img2, GpuMat dst, int alpha_op, Stream stream)`
`static void`	`alphaComp(Mat img1, Mat img2, Mat dst, int alpha_op)`
`static void`	`alphaComp(Mat img1, Mat img2, Mat dst, int alpha_op, Stream stream)` \brief Composites two images using alpha opacity values contained in each image.
`static void`	`alphaComp(UMat img1, UMat img2, UMat dst, int alpha_op)`
`static void`	`alphaComp(UMat img1, UMat img2, UMat dst, int alpha_op, Stream stream)`
`static void`	`bilateralFilter(GpuMat src, GpuMat dst, int kernel_size, float sigma_color, float sigma_spatial)`
`static void`	`bilateralFilter(GpuMat src, GpuMat dst, int kernel_size, float sigma_color, float sigma_spatial, int borderMode, Stream stream)`
`static void`	`bilateralFilter(Mat src, Mat dst, int kernel_size, float sigma_color, float sigma_spatial)`
`static void`	`bilateralFilter(Mat src, Mat dst, int kernel_size, float sigma_color, float sigma_spatial, int borderMode, Stream stream)` \brief Performs bilateral filtering of passed image
`static void`	`bilateralFilter(UMat src, UMat dst, int kernel_size, float sigma_color, float sigma_spatial)`
`static void`	`bilateralFilter(UMat src, UMat dst, int kernel_size, float sigma_color, float sigma_spatial, int borderMode, Stream stream)`
`static void`	`blendLinear(GpuMat img1, GpuMat img2, GpuMat weights1, GpuMat weights2, GpuMat result)`
`static void`	`blendLinear(GpuMat img1, GpuMat img2, GpuMat weights1, GpuMat weights2, GpuMat result, Stream stream)`
`static void`	`blendLinear(Mat img1, Mat img2, Mat weights1, Mat weights2, Mat result)`
`static void`	`blendLinear(Mat img1, Mat img2, Mat weights1, Mat weights2, Mat result, Stream stream)` \brief Performs linear blending of two images.
`static void`	`blendLinear(UMat img1, UMat img2, UMat weights1, UMat weights2, UMat result)`
`static void`	`blendLinear(UMat img1, UMat img2, UMat weights1, UMat weights2, UMat result, Stream stream)`
`static void`	`calcHist(GpuMat src, GpuMat hist)`
`static void`	`calcHist(GpuMat src, GpuMat mask, GpuMat hist)`
`static void`	`calcHist(GpuMat src, GpuMat mask, GpuMat hist, Stream stream)`
`static void`	`calcHist(GpuMat src, GpuMat hist, Stream stream)`
`static void`	`calcHist(Mat src, Mat hist)`
`static void`	`calcHist(Mat src, Mat mask, Mat hist)`
`static void`	`calcHist(Mat src, Mat mask, Mat hist, Stream stream)` \brief Calculates histogram for one channel 8-bit image confined in given mask.
`static void`	`calcHist(Mat src, Mat hist, Stream stream)` \} cudaimgproc_color
`static void`	`calcHist(UMat src, UMat hist)`
`static void`	`calcHist(UMat src, UMat hist, Stream stream)`
`static void`	`calcHist(UMat src, UMat mask, UMat hist)`
`static void`	`calcHist(UMat src, UMat mask, UMat hist, Stream stream)`
`static void`	`connectedComponents(GpuMat image, GpuMat labels)`
`static void`	`connectedComponents(GpuMat image, GpuMat labels, int connectivity, int ltype)`
`static void`	`connectedComponents(Mat image, Mat labels)`
`static void`	`connectedComponents(Mat image, Mat labels, int connectivity, int ltype)` \overload
`static void`	`connectedComponents(UMat image, UMat labels)`
`static void`	`connectedComponents(UMat image, UMat labels, int connectivity, int ltype)`
`static void`	`connectedComponentsWithAlgorithm(GpuMat image, GpuMat labels, int connectivity, int ltype, int ccltype)`
`static void`	`connectedComponentsWithAlgorithm(Mat image, Mat labels, int connectivity, int ltype, int ccltype)` \brief Computes the Connected Components Labeled image of a binary image.
`static void`	`connectedComponentsWithAlgorithm(UMat image, UMat labels, int connectivity, int ltype, int ccltype)`
`static Moments`	`convertSpatialMoments(Mat spatialMoments, int order, int momentsType)` \brief Converts the spatial image moments returned from cuda::spatialMoments to cv::Moments.
`static CannyEdgeDetector`	`createCannyEdgeDetector(double low_thresh, double high_thresh)`
`static CannyEdgeDetector`	`createCannyEdgeDetector(double low_thresh, double high_thresh, int apperture_size, boolean L2gradient)` \brief Creates implementation for cuda::CannyEdgeDetector .
`static CudaCLAHE`	`createCLAHE()`
`static CudaCLAHE`	`createCLAHE(double clipLimit, Size tileGridSize)` \brief Creates implementation for cuda::CLAHE .
`static GeneralizedHoughBallard`	`createGeneralizedHoughBallard()` \brief Creates implementation for generalized hough transform from \cite Ballard1981 .
`static GeneralizedHoughGuil`	`createGeneralizedHoughGuil()` \brief Creates implementation for generalized hough transform from \cite Guil1999 .
`static CornersDetector`	`createGoodFeaturesToTrackDetector(int srcType)`
`static CornersDetector`	`createGoodFeaturesToTrackDetector(int srcType, int maxCorners, double qualityLevel, double minDistance, int blockSize, boolean useHarrisDetector, double harrisK)` \brief Creates implementation for cuda::CornersDetector .
`static CornernessCriteria`	`createHarrisCorner(int srcType, int blockSize, int ksize, double k)`
`static CornernessCriteria`	`createHarrisCorner(int srcType, int blockSize, int ksize, double k, int borderType)` \brief Creates implementation for Harris cornerness criteria.
`static HoughCirclesDetector`	`createHoughCirclesDetector(float dp, float minDist, int cannyThreshold, int votesThreshold, int minRadius, int maxRadius)`
`static HoughCirclesDetector`	`createHoughCirclesDetector(float dp, float minDist, int cannyThreshold, int votesThreshold, int minRadius, int maxRadius, int maxCircles)` \brief Creates implementation for cuda::HoughCirclesDetector .
`static HoughLinesDetector`	`createHoughLinesDetector(float rho, float theta, int threshold)`
`static HoughLinesDetector`	`createHoughLinesDetector(float rho, float theta, int threshold, boolean doSort, int maxLines)` \brief Creates implementation for cuda::HoughLinesDetector .
`static HoughSegmentDetector`	`createHoughSegmentDetector(float rho, float theta, int minLineLength, int maxLineGap)`
`static HoughSegmentDetector`	`createHoughSegmentDetector(float rho, float theta, int minLineLength, int maxLineGap, int maxLines, int threshold)` \brief Creates implementation for cuda::HoughSegmentDetector .
`static CornernessCriteria`	`createMinEigenValCorner(int srcType, int blockSize, int ksize)`
`static CornernessCriteria`	`createMinEigenValCorner(int srcType, int blockSize, int ksize, int borderType)` \brief Creates implementation for the minimum eigen value of a 2x2 derivative covariation matrix (the cornerness criteria).
`static TemplateMatching`	`createTemplateMatching(int srcType, int method)`
`static TemplateMatching`	`createTemplateMatching(int srcType, int method, Size user_block_size)` \brief Creates implementation for cuda::TemplateMatching .
`static void`	`cvtColor(GpuMat src, GpuMat dst, int code)`
`static void`	`cvtColor(GpuMat src, GpuMat dst, int code, int dcn, Stream stream)`
`static void`	`cvtColor(Mat src, Mat dst, int code)`
`static void`	`cvtColor(Mat src, Mat dst, int code, int dcn, Stream stream)` \addtogroup cudaimgproc \{
`static void`	`cvtColor(UMat src, UMat dst, int code)`
`static void`	`cvtColor(UMat src, UMat dst, int code, int dcn, Stream stream)`
`static void`	`demosaicing(GpuMat src, GpuMat dst, int code)`
`static void`	`demosaicing(GpuMat src, GpuMat dst, int code, int dcn, Stream stream)`
`static void`	`demosaicing(Mat src, Mat dst, int code)`
`static void`	`demosaicing(Mat src, Mat dst, int code, int dcn, Stream stream)` \brief Converts an image from Bayer pattern to RGB or grayscale.
`static void`	`demosaicing(UMat src, UMat dst, int code)`
`static void`	`demosaicing(UMat src, UMat dst, int code, int dcn, Stream stream)`
`static void`	`equalizeHist(GpuMat src, GpuMat dst)`
`static void`	`equalizeHist(GpuMat src, GpuMat dst, Stream stream)`
`static void`	`equalizeHist(Mat src, Mat dst)`
`static void`	`equalizeHist(Mat src, Mat dst, Stream stream)` \brief Equalizes the histogram of a grayscale image.
`static void`	`equalizeHist(UMat src, UMat dst)`
`static void`	`equalizeHist(UMat src, UMat dst, Stream stream)`
`static void`	`evenLevels(GpuMat levels, int nLevels, int lowerLevel, int upperLevel)`
`static void`	`evenLevels(GpuMat levels, int nLevels, int lowerLevel, int upperLevel, Stream stream)`
`static void`	`evenLevels(Mat levels, int nLevels, int lowerLevel, int upperLevel)`
`static void`	`evenLevels(Mat levels, int nLevels, int lowerLevel, int upperLevel, Stream stream)` \brief Computes levels with even distribution.
`static void`	`evenLevels(UMat levels, int nLevels, int lowerLevel, int upperLevel)`
`static void`	`evenLevels(UMat levels, int nLevels, int lowerLevel, int upperLevel, Stream stream)`
`static void`	`gammaCorrection(GpuMat src, GpuMat dst)`
`static void`	`gammaCorrection(GpuMat src, GpuMat dst, boolean forward, Stream stream)`
`static void`	`gammaCorrection(Mat src, Mat dst)`
`static void`	`gammaCorrection(Mat src, Mat dst, boolean forward, Stream stream)` \brief Routines for correcting image color gamma.
`static void`	`gammaCorrection(UMat src, UMat dst)`
`static void`	`gammaCorrection(UMat src, UMat dst, boolean forward, Stream stream)`
`static void`	`histEven(GpuMat src, GpuMat hist, int[] histSize, int[] lowerLevel, int[] upperLevel)`
`static void`	`histEven(GpuMat src, GpuMat hist, int[] histSize, int[] lowerLevel, int[] upperLevel, Stream stream)`
`static void`	`histEven(GpuMat src, GpuMat hist, IntBuffer histSize, IntBuffer lowerLevel, IntBuffer upperLevel)`
`static void`	`histEven(GpuMat src, GpuMat hist, IntBuffer histSize, IntBuffer lowerLevel, IntBuffer upperLevel, Stream stream)`
`static void`	`histEven(GpuMat src, GpuMat hist, int histSize, int lowerLevel, int upperLevel)`
`static void`	`histEven(GpuMat src, GpuMat hist, int histSize, int lowerLevel, int upperLevel, Stream stream)`
`static void`	`histEven(GpuMat src, GpuMat hist, IntPointer histSize, IntPointer lowerLevel, IntPointer upperLevel)`
`static void`	`histEven(GpuMat src, GpuMat hist, IntPointer histSize, IntPointer lowerLevel, IntPointer upperLevel, Stream stream)`
`static void`	`histEven(Mat src, GpuMat hist, int[] histSize, int[] lowerLevel, int[] upperLevel)`
`static void`	`histEven(Mat src, GpuMat hist, int[] histSize, int[] lowerLevel, int[] upperLevel, Stream stream)`
`static void`	`histEven(Mat src, GpuMat hist, IntBuffer histSize, IntBuffer lowerLevel, IntBuffer upperLevel)`
`static void`	`histEven(Mat src, GpuMat hist, IntBuffer histSize, IntBuffer lowerLevel, IntBuffer upperLevel, Stream stream)`
`static void`	`histEven(Mat src, GpuMat hist, IntPointer histSize, IntPointer lowerLevel, IntPointer upperLevel)`
`static void`	`histEven(Mat src, GpuMat hist, IntPointer histSize, IntPointer lowerLevel, IntPointer upperLevel, Stream stream)` \overload
`static void`	`histEven(Mat src, Mat hist, int histSize, int lowerLevel, int upperLevel)`
`static void`	`histEven(Mat src, Mat hist, int histSize, int lowerLevel, int upperLevel, Stream stream)` \brief Calculates a histogram with evenly distributed bins.
`static void`	`histEven(UMat src, GpuMat hist, int[] histSize, int[] lowerLevel, int[] upperLevel)`
`static void`	`histEven(UMat src, GpuMat hist, int[] histSize, int[] lowerLevel, int[] upperLevel, Stream stream)`
`static void`	`histEven(UMat src, GpuMat hist, IntBuffer histSize, IntBuffer lowerLevel, IntBuffer upperLevel)`
`static void`	`histEven(UMat src, GpuMat hist, IntBuffer histSize, IntBuffer lowerLevel, IntBuffer upperLevel, Stream stream)`
`static void`	`histEven(UMat src, GpuMat hist, IntPointer histSize, IntPointer lowerLevel, IntPointer upperLevel)`
`static void`	`histEven(UMat src, GpuMat hist, IntPointer histSize, IntPointer lowerLevel, IntPointer upperLevel, Stream stream)`
`static void`	`histEven(UMat src, UMat hist, int histSize, int lowerLevel, int upperLevel)`
`static void`	`histEven(UMat src, UMat hist, int histSize, int lowerLevel, int upperLevel, Stream stream)`
`static void`	`histRange(GpuMat src, GpuMat hist, GpuMat levels)`
`static void`	`histRange(GpuMat src, GpuMat hist, GpuMat levels, Stream stream)`
`static void`	`histRange(Mat src, GpuMat hist, GpuMat levels)`
`static void`	`histRange(Mat src, GpuMat hist, GpuMat levels, Stream stream)` \overload
`static void`	`histRange(Mat src, Mat hist, Mat levels)`
`static void`	`histRange(Mat src, Mat hist, Mat levels, Stream stream)` \brief Calculates a histogram with bins determined by the levels array.
`static void`	`histRange(UMat src, GpuMat hist, GpuMat levels)`
`static void`	`histRange(UMat src, GpuMat hist, GpuMat levels, Stream stream)`
`static void`	`histRange(UMat src, UMat hist, UMat levels)`
`static void`	`histRange(UMat src, UMat hist, UMat levels, Stream stream)`
`static void`	`meanShiftFiltering(GpuMat src, GpuMat dst, int sp, int sr)`
`static void`	`meanShiftFiltering(GpuMat src, GpuMat dst, int sp, int sr, TermCriteria criteria, Stream stream)`
`static void`	`meanShiftFiltering(Mat src, Mat dst, int sp, int sr)`
`static void`	`meanShiftFiltering(Mat src, Mat dst, int sp, int sr, TermCriteria criteria, Stream stream)` \} cudaimgproc_feature
`static void`	`meanShiftFiltering(UMat src, UMat dst, int sp, int sr)`
`static void`	`meanShiftFiltering(UMat src, UMat dst, int sp, int sr, TermCriteria criteria, Stream stream)`
`static void`	`meanShiftProc(GpuMat src, GpuMat dstr, GpuMat dstsp, int sp, int sr)`
`static void`	`meanShiftProc(GpuMat src, GpuMat dstr, GpuMat dstsp, int sp, int sr, TermCriteria criteria, Stream stream)`
`static void`	`meanShiftProc(Mat src, Mat dstr, Mat dstsp, int sp, int sr)`
`static void`	`meanShiftProc(Mat src, Mat dstr, Mat dstsp, int sp, int sr, TermCriteria criteria, Stream stream)` \brief Performs a mean-shift procedure and stores information about processed points (their colors and positions) in two images.
`static void`	`meanShiftProc(UMat src, UMat dstr, UMat dstsp, int sp, int sr)`
`static void`	`meanShiftProc(UMat src, UMat dstr, UMat dstsp, int sp, int sr, TermCriteria criteria, Stream stream)`
`static void`	`meanShiftSegmentation(GpuMat src, GpuMat dst, int sp, int sr, int minsize)`
`static void`	`meanShiftSegmentation(GpuMat src, GpuMat dst, int sp, int sr, int minsize, TermCriteria criteria, Stream stream)`
`static void`	`meanShiftSegmentation(Mat src, Mat dst, int sp, int sr, int minsize)`
`static void`	`meanShiftSegmentation(Mat src, Mat dst, int sp, int sr, int minsize, TermCriteria criteria, Stream stream)` \brief Performs a mean-shift segmentation of the source image and eliminates small segments.
`static void`	`meanShiftSegmentation(UMat src, UMat dst, int sp, int sr, int minsize)`
`static void`	`meanShiftSegmentation(UMat src, UMat dst, int sp, int sr, int minsize, TermCriteria criteria, Stream stream)`
`static Moments`	`moments(GpuMat src)`
`static Moments`	`moments(GpuMat src, boolean binaryImage, int order, int momentsType)`
`static Moments`	`moments(Mat src)`
`static Moments`	`moments(Mat src, boolean binaryImage, int order, int momentsType)` \brief Calculates all of the moments up to the 3rd order of a rasterized shape.
`static Moments`	`moments(UMat src)`
`static Moments`	`moments(UMat src, boolean binaryImage, int order, int momentsType)`
`static int`	`numMoments(int order)` \brief Returns the number of image moments less than or equal to the largest image moments \a order.
`static void`	`spatialMoments(GpuMat src, GpuMat moments)`
`static void`	`spatialMoments(GpuMat src, GpuMat moments, boolean binaryImage, int order, int momentsType, Stream stream)`
`static void`	`spatialMoments(Mat src, Mat moments)`
`static void`	`spatialMoments(Mat src, Mat moments, boolean binaryImage, int order, int momentsType, Stream stream)` \brief Calculates all of the spatial moments up to the 3rd order of a rasterized shape.
`static void`	`spatialMoments(UMat src, UMat moments)`
`static void`	`spatialMoments(UMat src, UMat moments, boolean binaryImage, int order, int momentsType, Stream stream)`
`static void`	`swapChannels(GpuMat image, int[] dstOrder)`
`static void`	`swapChannels(GpuMat image, int[] dstOrder, Stream stream)`
`static void`	`swapChannels(GpuMat image, IntBuffer dstOrder)`
`static void`	`swapChannels(GpuMat image, IntBuffer dstOrder, Stream stream)`
`static void`	`swapChannels(GpuMat image, IntPointer dstOrder)`
`static void`	`swapChannels(GpuMat image, IntPointer dstOrder, Stream stream)`
`static void`	`swapChannels(Mat image, int[] dstOrder)`
`static void`	`swapChannels(Mat image, int[] dstOrder, Stream stream)`
`static void`	`swapChannels(Mat image, IntBuffer dstOrder)`
`static void`	`swapChannels(Mat image, IntBuffer dstOrder, Stream stream)`
`static void`	`swapChannels(Mat image, IntPointer dstOrder)`
`static void`	`swapChannels(Mat image, IntPointer dstOrder, Stream stream)` \brief Exchanges the color channels of an image in-place.
`static void`	`swapChannels(UMat image, int[] dstOrder)`
`static void`	`swapChannels(UMat image, int[] dstOrder, Stream stream)`
`static void`	`swapChannels(UMat image, IntBuffer dstOrder)`
`static void`	`swapChannels(UMat image, IntBuffer dstOrder, Stream stream)`
`static void`	`swapChannels(UMat image, IntPointer dstOrder)`
`static void`	`swapChannels(UMat image, IntPointer dstOrder, Stream stream)`

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

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

Field Detail
- COLOR_BayerBG2BGR_MHT
```
public static final int COLOR_BayerBG2BGR_MHT
```
  enum cv::cuda::DemosaicTypes
  
  See Also:
  
  Constant Field Values
- COLOR_BayerGB2BGR_MHT
```
public static final int COLOR_BayerGB2BGR_MHT
```
  enum cv::cuda::DemosaicTypes
  
  See Also:
  
  Constant Field Values
- COLOR_BayerRG2BGR_MHT
```
public static final int COLOR_BayerRG2BGR_MHT
```
  enum cv::cuda::DemosaicTypes
  
  See Also:
  
  Constant Field Values
- COLOR_BayerGR2BGR_MHT
```
public static final int COLOR_BayerGR2BGR_MHT
```
  enum cv::cuda::DemosaicTypes
  
  See Also:
  
  Constant Field Values
- COLOR_BayerBG2RGB_MHT
```
public static final int COLOR_BayerBG2RGB_MHT
```
  enum cv::cuda::DemosaicTypes
  
  See Also:
  
  Constant Field Values
- COLOR_BayerGB2RGB_MHT
```
public static final int COLOR_BayerGB2RGB_MHT
```
  enum cv::cuda::DemosaicTypes
  
  See Also:
  
  Constant Field Values
- COLOR_BayerRG2RGB_MHT
```
public static final int COLOR_BayerRG2RGB_MHT
```
  enum cv::cuda::DemosaicTypes
  
  See Also:
  
  Constant Field Values
- COLOR_BayerGR2RGB_MHT
```
public static final int COLOR_BayerGR2RGB_MHT
```
  enum cv::cuda::DemosaicTypes
  
  See Also:
  
  Constant Field Values
- COLOR_BayerBG2GRAY_MHT
```
public static final int COLOR_BayerBG2GRAY_MHT
```
  enum cv::cuda::DemosaicTypes
  
  See Also:
  
  Constant Field Values
- COLOR_BayerGB2GRAY_MHT
```
public static final int COLOR_BayerGB2GRAY_MHT
```
  enum cv::cuda::DemosaicTypes
  
  See Also:
  
  Constant Field Values
- COLOR_BayerRG2GRAY_MHT
```
public static final int COLOR_BayerRG2GRAY_MHT
```
  enum cv::cuda::DemosaicTypes
  
  See Also:
  
  Constant Field Values
- COLOR_BayerGR2GRAY_MHT
```
public static final int COLOR_BayerGR2GRAY_MHT
```
  enum cv::cuda::DemosaicTypes
  
  See Also:
  
  Constant Field Values
- ALPHA_OVER
```
public static final int ALPHA_OVER
```
  enum cv::cuda::AlphaCompTypes
  
  See Also:
  
  Constant Field Values
- ALPHA_IN
```
public static final int ALPHA_IN
```
  enum cv::cuda::AlphaCompTypes
  
  See Also:
  
  Constant Field Values
- ALPHA_OUT
```
public static final int ALPHA_OUT
```
  enum cv::cuda::AlphaCompTypes
  
  See Also:
  
  Constant Field Values
- ALPHA_ATOP
```
public static final int ALPHA_ATOP
```
  enum cv::cuda::AlphaCompTypes
  
  See Also:
  
  Constant Field Values
- ALPHA_XOR
```
public static final int ALPHA_XOR
```
  enum cv::cuda::AlphaCompTypes
  
  See Also:
  
  Constant Field Values
- ALPHA_PLUS
```
public static final int ALPHA_PLUS
```
  enum cv::cuda::AlphaCompTypes
  
  See Also:
  
  Constant Field Values
- ALPHA_OVER_PREMUL
```
public static final int ALPHA_OVER_PREMUL
```
  enum cv::cuda::AlphaCompTypes
  
  See Also:
  
  Constant Field Values
- ALPHA_IN_PREMUL
```
public static final int ALPHA_IN_PREMUL
```
  enum cv::cuda::AlphaCompTypes
  
  See Also:
  
  Constant Field Values
- ALPHA_OUT_PREMUL
```
public static final int ALPHA_OUT_PREMUL
```
  enum cv::cuda::AlphaCompTypes
  
  See Also:
  
  Constant Field Values
- ALPHA_ATOP_PREMUL
```
public static final int ALPHA_ATOP_PREMUL
```
  enum cv::cuda::AlphaCompTypes
  
  See Also:
  
  Constant Field Values
- ALPHA_XOR_PREMUL
```
public static final int ALPHA_XOR_PREMUL
```
  enum cv::cuda::AlphaCompTypes
  
  See Also:
  
  Constant Field Values
- ALPHA_PLUS_PREMUL
```
public static final int ALPHA_PLUS_PREMUL
```
  enum cv::cuda::AlphaCompTypes
  
  See Also:
  
  Constant Field Values
- ALPHA_PREMUL
```
public static final int ALPHA_PREMUL
```
  enum cv::cuda::AlphaCompTypes
  
  See Also:
  
  Constant Field Values
- CCL_DEFAULT
```
public static final int CCL_DEFAULT
```
  enum cv::cuda::ConnectedComponentsAlgorithmsTypes
  
  See Also:
  
  Constant Field Values
- CCL_BKE
```
public static final int CCL_BKE
```
  enum cv::cuda::ConnectedComponentsAlgorithmsTypes
  
  See Also:
  
  Constant Field Values
- FIRST_ORDER_MOMENTS
```
public static final int FIRST_ORDER_MOMENTS
```
  enum cv::cuda::MomentsOrder
  
  See Also:
  
  Constant Field Values
- SECOND_ORDER_MOMENTS
```
public static final int SECOND_ORDER_MOMENTS
```
  enum cv::cuda::MomentsOrder
  
  See Also:
  
  Constant Field Values
- THIRD_ORDER_MOMENTS
```
public static final int THIRD_ORDER_MOMENTS
```
  enum cv::cuda::MomentsOrder
  
  See Also:
  
  Constant Field Values

Constructor Detail
- opencv_cudaimgproc
```
public opencv_cudaimgproc()
```

Method Detail

cvtColor

@Namespace(value="cv::cuda")
public static void cvtColor(@ByVal
                                                          Mat src,
                                                          @ByVal
                                                          Mat dst,
                                                          int code,
                                                          int dcn,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

\addtogroup cudaimgproc \{

/////////////////////////// Color Processing ///////////////////////////

\addtogroup cudaimgproc_color \{

/** \brief Converts an image from one color space to another.

Parameters:

src - Source image with CV_8U , CV_16U , or CV_32F depth and 1, 3, or 4 channels.

dst - Destination image.

code - Color space conversion code. For details, see cvtColor .

dcn - Number of channels in the destination image. If the parameter is 0, the number of the channels is derived automatically from src and the code .

stream - Stream for the asynchronous version.

3-channel color spaces (like HSV, XYZ, and so on) can be stored in a 4-channel image for better performance.

See Also:

cvtColor

cvtColor

@Namespace(value="cv::cuda")
public static void cvtColor(@ByVal
                                                          Mat src,
                                                          @ByVal
                                                          Mat dst,
                                                          int code)

cvtColor

@Namespace(value="cv::cuda")
public static void cvtColor(@ByVal
                                                          UMat src,
                                                          @ByVal
                                                          UMat dst,
                                                          int code,
                                                          int dcn,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

cvtColor

@Namespace(value="cv::cuda")
public static void cvtColor(@ByVal
                                                          UMat src,
                                                          @ByVal
                                                          UMat dst,
                                                          int code)

cvtColor

@Namespace(value="cv::cuda")
public static void cvtColor(@ByVal
                                                          GpuMat src,
                                                          @ByVal
                                                          GpuMat dst,
                                                          int code,
                                                          int dcn,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

cvtColor

@Namespace(value="cv::cuda")
public static void cvtColor(@ByVal
                                                          GpuMat src,
                                                          @ByVal
                                                          GpuMat dst,
                                                          int code)

demosaicing
```
@Namespace(value="cv::cuda")
public static void demosaicing(@ByVal
                                                             Mat src,
                                                             @ByVal
                                                             Mat dst,
                                                             int code,
                                                             int dcn,
                                                             @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                             Stream stream)
```
\brief Converts an image from Bayer pattern to RGB or grayscale.

Parameters:

src - Source image (8-bit or 16-bit single channel).

dst - Destination image.

code - Color space conversion code (see the description below).

dcn - Number of channels in the destination image. If the parameter is 0, the number of the channels is derived automatically from src and the code .

stream - Stream for the asynchronous version.
The function can do the following transformations:
- Demosaicing using bilinear interpolation
> - COLOR_BayerBG2GRAY , COLOR_BayerGB2GRAY , COLOR_BayerRG2GRAY , COLOR_BayerGR2GRAY > - COLOR_BayerBG2BGR , COLOR_BayerGB2BGR , COLOR_BayerRG2BGR , COLOR_BayerGR2BGR
- Demosaicing using Malvar-He-Cutler algorithm (\cite MHT2011)
> - COLOR_BayerBG2GRAY_MHT , COLOR_BayerGB2GRAY_MHT , COLOR_BayerRG2GRAY_MHT , > COLOR_BayerGR2GRAY_MHT > - COLOR_BayerBG2BGR_MHT , COLOR_BayerGB2BGR_MHT , COLOR_BayerRG2BGR_MHT , > COLOR_BayerGR2BGR_MHT

See Also:

cvtColor

demosaicing

@Namespace(value="cv::cuda")
public static void demosaicing(@ByVal
                                                             Mat src,
                                                             @ByVal
                                                             Mat dst,
                                                             int code)

demosaicing

@Namespace(value="cv::cuda")
public static void demosaicing(@ByVal
                                                             UMat src,
                                                             @ByVal
                                                             UMat dst,
                                                             int code,
                                                             int dcn,
                                                             @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                             Stream stream)

demosaicing

@Namespace(value="cv::cuda")
public static void demosaicing(@ByVal
                                                             UMat src,
                                                             @ByVal
                                                             UMat dst,
                                                             int code)

demosaicing

@Namespace(value="cv::cuda")
public static void demosaicing(@ByVal
                                                             GpuMat src,
                                                             @ByVal
                                                             GpuMat dst,
                                                             int code,
                                                             int dcn,
                                                             @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                             Stream stream)

demosaicing

@Namespace(value="cv::cuda")
public static void demosaicing(@ByVal
                                                             GpuMat src,
                                                             @ByVal
                                                             GpuMat dst,
                                                             int code)

swapChannels

@Namespace(value="cv::cuda")
public static void swapChannels(@ByVal
                                                              Mat image,
                                                              @Const
                                                              IntPointer dstOrder,
                                                              @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                              Stream stream)

\brief Exchanges the color channels of an image in-place.

Parameters:: image - Source image. Supports only CV_8UC4 type.; dstOrder - Integer array describing how channel values are permutated. The n-th entry of the array contains the number of the channel that is stored in the n-th channel of the output image. E.g. Given an RGBA image, aDstOrder = [3,2,1,0] converts this to ABGR channel order.; stream - Stream for the asynchronous version.
The methods support arbitrary permutations of the original channels, including replication.

swapChannels

@Namespace(value="cv::cuda")
public static void swapChannels(@ByVal
                                                              Mat image,
                                                              @Const
                                                              IntPointer dstOrder)

swapChannels

@Namespace(value="cv::cuda")
public static void swapChannels(@ByVal
                                                              Mat image,
                                                              @Const
                                                              IntBuffer dstOrder,
                                                              @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                              Stream stream)

swapChannels

@Namespace(value="cv::cuda")
public static void swapChannels(@ByVal
                                                              Mat image,
                                                              @Const
                                                              IntBuffer dstOrder)

swapChannels

@Namespace(value="cv::cuda")
public static void swapChannels(@ByVal
                                                              Mat image,
                                                              @Const
                                                              int[] dstOrder,
                                                              @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                              Stream stream)

swapChannels

@Namespace(value="cv::cuda")
public static void swapChannels(@ByVal
                                                              Mat image,
                                                              @Const
                                                              int[] dstOrder)

swapChannels

@Namespace(value="cv::cuda")
public static void swapChannels(@ByVal
                                                              UMat image,
                                                              @Const
                                                              IntPointer dstOrder,
                                                              @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                              Stream stream)

swapChannels

@Namespace(value="cv::cuda")
public static void swapChannels(@ByVal
                                                              UMat image,
                                                              @Const
                                                              IntPointer dstOrder)

swapChannels

@Namespace(value="cv::cuda")
public static void swapChannels(@ByVal
                                                              UMat image,
                                                              @Const
                                                              IntBuffer dstOrder,
                                                              @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                              Stream stream)

swapChannels

@Namespace(value="cv::cuda")
public static void swapChannels(@ByVal
                                                              UMat image,
                                                              @Const
                                                              IntBuffer dstOrder)

swapChannels

@Namespace(value="cv::cuda")
public static void swapChannels(@ByVal
                                                              UMat image,
                                                              @Const
                                                              int[] dstOrder,
                                                              @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                              Stream stream)

swapChannels

@Namespace(value="cv::cuda")
public static void swapChannels(@ByVal
                                                              UMat image,
                                                              @Const
                                                              int[] dstOrder)

swapChannels

@Namespace(value="cv::cuda")
public static void swapChannels(@ByVal
                                                              GpuMat image,
                                                              @Const
                                                              IntPointer dstOrder,
                                                              @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                              Stream stream)

swapChannels

@Namespace(value="cv::cuda")
public static void swapChannels(@ByVal
                                                              GpuMat image,
                                                              @Const
                                                              IntPointer dstOrder)

swapChannels

@Namespace(value="cv::cuda")
public static void swapChannels(@ByVal
                                                              GpuMat image,
                                                              @Const
                                                              IntBuffer dstOrder,
                                                              @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                              Stream stream)

swapChannels

@Namespace(value="cv::cuda")
public static void swapChannels(@ByVal
                                                              GpuMat image,
                                                              @Const
                                                              IntBuffer dstOrder)

swapChannels

@Namespace(value="cv::cuda")
public static void swapChannels(@ByVal
                                                              GpuMat image,
                                                              @Const
                                                              int[] dstOrder,
                                                              @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                              Stream stream)

swapChannels

@Namespace(value="cv::cuda")
public static void swapChannels(@ByVal
                                                              GpuMat image,
                                                              @Const
                                                              int[] dstOrder)

gammaCorrection

@Namespace(value="cv::cuda")
public static void gammaCorrection(@ByVal
                                                                 Mat src,
                                                                 @ByVal
                                                                 Mat dst,
                                                                 @Cast(value="bool")
                                                                 boolean forward,
                                                                 @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                 Stream stream)

\brief Routines for correcting image color gamma.

Parameters:: src - Source image (3- or 4-channel 8 bit).; dst - Destination image.; forward - true for forward gamma correction or false for inverse gamma correction.; stream - Stream for the asynchronous version.

gammaCorrection

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

gammaCorrection

@Namespace(value="cv::cuda")
public static void gammaCorrection(@ByVal
                                                                 UMat src,
                                                                 @ByVal
                                                                 UMat dst,
                                                                 @Cast(value="bool")
                                                                 boolean forward,
                                                                 @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                 Stream stream)

gammaCorrection

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

gammaCorrection

@Namespace(value="cv::cuda")
public static void gammaCorrection(@ByVal
                                                                 GpuMat src,
                                                                 @ByVal
                                                                 GpuMat dst,
                                                                 @Cast(value="bool")
                                                                 boolean forward,
                                                                 @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                 Stream stream)

gammaCorrection

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

alphaComp

@Namespace(value="cv::cuda")
public static void alphaComp(@ByVal
                                                           Mat img1,
                                                           @ByVal
                                                           Mat img2,
                                                           @ByVal
                                                           Mat dst,
                                                           int alpha_op,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

\brief Composites two images using alpha opacity values contained in each image.

Parameters:: img1 - First image. Supports CV_8UC4 , CV_16UC4 , CV_32SC4 and CV_32FC4 types.; img2 - Second image. Must have the same size and the same type as img1 .; dst - Destination image.; alpha_op - Flag specifying the alpha-blending operation: - **ALPHA_OVER** - **ALPHA_IN** - **ALPHA_OUT** - **ALPHA_ATOP** - **ALPHA_XOR** - **ALPHA_PLUS** - **ALPHA_OVER_PREMUL** - **ALPHA_IN_PREMUL** - **ALPHA_OUT_PREMUL** - **ALPHA_ATOP_PREMUL** - **ALPHA_XOR_PREMUL** - **ALPHA_PLUS_PREMUL** - **ALPHA_PREMUL**; stream - Stream for the asynchronous version.
\note - An example demonstrating the use of alphaComp can be found at opencv_source_code/samples/gpu/alpha_comp.cpp

alphaComp

@Namespace(value="cv::cuda")
public static void alphaComp(@ByVal
                                                           Mat img1,
                                                           @ByVal
                                                           Mat img2,
                                                           @ByVal
                                                           Mat dst,
                                                           int alpha_op)

alphaComp

@Namespace(value="cv::cuda")
public static void alphaComp(@ByVal
                                                           UMat img1,
                                                           @ByVal
                                                           UMat img2,
                                                           @ByVal
                                                           UMat dst,
                                                           int alpha_op,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

alphaComp

@Namespace(value="cv::cuda")
public static void alphaComp(@ByVal
                                                           UMat img1,
                                                           @ByVal
                                                           UMat img2,
                                                           @ByVal
                                                           UMat dst,
                                                           int alpha_op)

alphaComp

@Namespace(value="cv::cuda")
public static void alphaComp(@ByVal
                                                           GpuMat img1,
                                                           @ByVal
                                                           GpuMat img2,
                                                           @ByVal
                                                           GpuMat dst,
                                                           int alpha_op,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

alphaComp

@Namespace(value="cv::cuda")
public static void alphaComp(@ByVal
                                                           GpuMat img1,
                                                           @ByVal
                                                           GpuMat img2,
                                                           @ByVal
                                                           GpuMat dst,
                                                           int alpha_op)

calcHist

@Namespace(value="cv::cuda")
public static void calcHist(@ByVal
                                                          Mat src,
                                                          @ByVal
                                                          Mat hist,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

\} cudaimgproc_color

////////////////////////////// Histogram ///////////////////////////////

\addtogroup cudaimgproc_hist \{

/** \brief Calculates histogram for one channel 8-bit image.

Parameters:: src - Source image with CV_8UC1 type.; hist - Destination histogram with one row, 256 columns, and the CV_32SC1 type.; stream - Stream for the asynchronous version.

calcHist

@Namespace(value="cv::cuda")
public static void calcHist(@ByVal
                                                          Mat src,
                                                          @ByVal
                                                          Mat hist)

calcHist

@Namespace(value="cv::cuda")
public static void calcHist(@ByVal
                                                          UMat src,
                                                          @ByVal
                                                          UMat hist,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

calcHist

@Namespace(value="cv::cuda")
public static void calcHist(@ByVal
                                                          UMat src,
                                                          @ByVal
                                                          UMat hist)

calcHist

@Namespace(value="cv::cuda")
public static void calcHist(@ByVal
                                                          GpuMat src,
                                                          @ByVal
                                                          GpuMat hist,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

calcHist

@Namespace(value="cv::cuda")
public static void calcHist(@ByVal
                                                          GpuMat src,
                                                          @ByVal
                                                          GpuMat hist)

calcHist

@Namespace(value="cv::cuda")
public static void calcHist(@ByVal
                                                          Mat src,
                                                          @ByVal
                                                          Mat mask,
                                                          @ByVal
                                                          Mat hist,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

\brief Calculates histogram for one channel 8-bit image confined in given mask.

Parameters:: src - Source image with CV_8UC1 type.; hist - Destination histogram with one row, 256 columns, and the CV_32SC1 type.; mask - A mask image same size as src and of type CV_8UC1.; stream - Stream for the asynchronous version.

calcHist

@Namespace(value="cv::cuda")
public static void calcHist(@ByVal
                                                          Mat src,
                                                          @ByVal
                                                          Mat mask,
                                                          @ByVal
                                                          Mat hist)

calcHist

@Namespace(value="cv::cuda")
public static void calcHist(@ByVal
                                                          UMat src,
                                                          @ByVal
                                                          UMat mask,
                                                          @ByVal
                                                          UMat hist,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

calcHist

@Namespace(value="cv::cuda")
public static void calcHist(@ByVal
                                                          UMat src,
                                                          @ByVal
                                                          UMat mask,
                                                          @ByVal
                                                          UMat hist)

calcHist

@Namespace(value="cv::cuda")
public static void calcHist(@ByVal
                                                          GpuMat src,
                                                          @ByVal
                                                          GpuMat mask,
                                                          @ByVal
                                                          GpuMat hist,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

calcHist

@Namespace(value="cv::cuda")
public static void calcHist(@ByVal
                                                          GpuMat src,
                                                          @ByVal
                                                          GpuMat mask,
                                                          @ByVal
                                                          GpuMat hist)

equalizeHist

@Namespace(value="cv::cuda")
public static void equalizeHist(@ByVal
                                                              Mat src,
                                                              @ByVal
                                                              Mat dst,
                                                              @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                              Stream stream)

\brief Equalizes the histogram of a grayscale image.

Parameters:: src - Source image with CV_8UC1 type.; dst - Destination image.; stream - Stream for the asynchronous version.
See Also:: equalizeHist

equalizeHist

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

equalizeHist

@Namespace(value="cv::cuda")
public static void equalizeHist(@ByVal
                                                              UMat src,
                                                              @ByVal
                                                              UMat dst,
                                                              @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                              Stream stream)

equalizeHist

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

equalizeHist

@Namespace(value="cv::cuda")
public static void equalizeHist(@ByVal
                                                              GpuMat src,
                                                              @ByVal
                                                              GpuMat dst,
                                                              @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                              Stream stream)

equalizeHist

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

createCLAHE

@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static CudaCLAHE createCLAHE(double clipLimit,
                                                                                     @ByVal(nullValue="cv::Size(8, 8)")
                                                                                     Size tileGridSize)

\brief Creates implementation for cuda::CLAHE .

Parameters:: clipLimit - Threshold for contrast limiting.; tileGridSize - Size of grid for histogram equalization. Input image will be divided into equally sized rectangular tiles. tileGridSize defines the number of tiles in row and column.

createCLAHE

@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static CudaCLAHE createCLAHE()

evenLevels

@Namespace(value="cv::cuda")
public static void evenLevels(@ByVal
                                                            Mat levels,
                                                            int nLevels,
                                                            int lowerLevel,
                                                            int upperLevel,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

\brief Computes levels with even distribution.

Parameters:: levels - Destination array. levels has 1 row, nLevels columns, and the CV_32SC1 type.; nLevels - Number of computed levels. nLevels must be at least 2.; lowerLevel - Lower boundary value of the lowest level.; upperLevel - Upper boundary value of the greatest level.; stream - Stream for the asynchronous version.

evenLevels

@Namespace(value="cv::cuda")
public static void evenLevels(@ByVal
                                                            Mat levels,
                                                            int nLevels,
                                                            int lowerLevel,
                                                            int upperLevel)

evenLevels

@Namespace(value="cv::cuda")
public static void evenLevels(@ByVal
                                                            UMat levels,
                                                            int nLevels,
                                                            int lowerLevel,
                                                            int upperLevel,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

evenLevels

@Namespace(value="cv::cuda")
public static void evenLevels(@ByVal
                                                            UMat levels,
                                                            int nLevels,
                                                            int lowerLevel,
                                                            int upperLevel)

evenLevels

@Namespace(value="cv::cuda")
public static void evenLevels(@ByVal
                                                            GpuMat levels,
                                                            int nLevels,
                                                            int lowerLevel,
                                                            int upperLevel,
                                                            @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                            Stream stream)

evenLevels

@Namespace(value="cv::cuda")
public static void evenLevels(@ByVal
                                                            GpuMat levels,
                                                            int nLevels,
                                                            int lowerLevel,
                                                            int upperLevel)

histEven

@Namespace(value="cv::cuda")
public static void histEven(@ByVal
                                                          Mat src,
                                                          @ByVal
                                                          Mat hist,
                                                          int histSize,
                                                          int lowerLevel,
                                                          int upperLevel,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

\brief Calculates a histogram with evenly distributed bins.

Parameters:: src - Source image. CV_8U, CV_16U, or CV_16S depth and 1 or 4 channels are supported. For a four-channel image, all channels are processed separately.; hist - Destination histogram with one row, histSize columns, and the CV_32S type.; histSize - Size of the histogram.; lowerLevel - Lower boundary of lowest-level bin.; upperLevel - Upper boundary of highest-level bin.; stream - Stream for the asynchronous version.

histEven

@Namespace(value="cv::cuda")
public static void histEven(@ByVal
                                                          Mat src,
                                                          @ByVal
                                                          Mat hist,
                                                          int histSize,
                                                          int lowerLevel,
                                                          int upperLevel)

histEven

@Namespace(value="cv::cuda")
public static void histEven(@ByVal
                                                          UMat src,
                                                          @ByVal
                                                          UMat hist,
                                                          int histSize,
                                                          int lowerLevel,
                                                          int upperLevel,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

histEven

@Namespace(value="cv::cuda")
public static void histEven(@ByVal
                                                          UMat src,
                                                          @ByVal
                                                          UMat hist,
                                                          int histSize,
                                                          int lowerLevel,
                                                          int upperLevel)

histEven

@Namespace(value="cv::cuda")
public static void histEven(@ByVal
                                                          GpuMat src,
                                                          @ByVal
                                                          GpuMat hist,
                                                          int histSize,
                                                          int lowerLevel,
                                                          int upperLevel,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

histEven

@Namespace(value="cv::cuda")
public static void histEven(@ByVal
                                                          GpuMat src,
                                                          @ByVal
                                                          GpuMat hist,
                                                          int histSize,
                                                          int lowerLevel,
                                                          int upperLevel)

histEven

@Namespace(value="cv::cuda")
public static void histEven(@ByVal
                                                          Mat src,
                                                          GpuMat hist,
                                                          IntPointer histSize,
                                                          IntPointer lowerLevel,
                                                          IntPointer upperLevel,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

\overload

histEven

@Namespace(value="cv::cuda")
public static void histEven(@ByVal
                                                          Mat src,
                                                          GpuMat hist,
                                                          IntPointer histSize,
                                                          IntPointer lowerLevel,
                                                          IntPointer upperLevel)

histEven

@Namespace(value="cv::cuda")
public static void histEven(@ByVal
                                                          Mat src,
                                                          GpuMat hist,
                                                          IntBuffer histSize,
                                                          IntBuffer lowerLevel,
                                                          IntBuffer upperLevel,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

histEven

@Namespace(value="cv::cuda")
public static void histEven(@ByVal
                                                          Mat src,
                                                          GpuMat hist,
                                                          IntBuffer histSize,
                                                          IntBuffer lowerLevel,
                                                          IntBuffer upperLevel)

histEven

@Namespace(value="cv::cuda")
public static void histEven(@ByVal
                                                          Mat src,
                                                          GpuMat hist,
                                                          int[] histSize,
                                                          int[] lowerLevel,
                                                          int[] upperLevel,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

histEven

@Namespace(value="cv::cuda")
public static void histEven(@ByVal
                                                          Mat src,
                                                          GpuMat hist,
                                                          int[] histSize,
                                                          int[] lowerLevel,
                                                          int[] upperLevel)

histEven

@Namespace(value="cv::cuda")
public static void histEven(@ByVal
                                                          UMat src,
                                                          GpuMat hist,
                                                          IntPointer histSize,
                                                          IntPointer lowerLevel,
                                                          IntPointer upperLevel,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

histEven

@Namespace(value="cv::cuda")
public static void histEven(@ByVal
                                                          UMat src,
                                                          GpuMat hist,
                                                          IntPointer histSize,
                                                          IntPointer lowerLevel,
                                                          IntPointer upperLevel)

histEven

@Namespace(value="cv::cuda")
public static void histEven(@ByVal
                                                          UMat src,
                                                          GpuMat hist,
                                                          IntBuffer histSize,
                                                          IntBuffer lowerLevel,
                                                          IntBuffer upperLevel,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

histEven

@Namespace(value="cv::cuda")
public static void histEven(@ByVal
                                                          UMat src,
                                                          GpuMat hist,
                                                          IntBuffer histSize,
                                                          IntBuffer lowerLevel,
                                                          IntBuffer upperLevel)

histEven

@Namespace(value="cv::cuda")
public static void histEven(@ByVal
                                                          UMat src,
                                                          GpuMat hist,
                                                          int[] histSize,
                                                          int[] lowerLevel,
                                                          int[] upperLevel,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

histEven

@Namespace(value="cv::cuda")
public static void histEven(@ByVal
                                                          UMat src,
                                                          GpuMat hist,
                                                          int[] histSize,
                                                          int[] lowerLevel,
                                                          int[] upperLevel)

histEven

@Namespace(value="cv::cuda")
public static void histEven(@ByVal
                                                          GpuMat src,
                                                          GpuMat hist,
                                                          IntPointer histSize,
                                                          IntPointer lowerLevel,
                                                          IntPointer upperLevel,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

histEven

@Namespace(value="cv::cuda")
public static void histEven(@ByVal
                                                          GpuMat src,
                                                          GpuMat hist,
                                                          IntPointer histSize,
                                                          IntPointer lowerLevel,
                                                          IntPointer upperLevel)

histEven

@Namespace(value="cv::cuda")
public static void histEven(@ByVal
                                                          GpuMat src,
                                                          GpuMat hist,
                                                          IntBuffer histSize,
                                                          IntBuffer lowerLevel,
                                                          IntBuffer upperLevel,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

histEven

@Namespace(value="cv::cuda")
public static void histEven(@ByVal
                                                          GpuMat src,
                                                          GpuMat hist,
                                                          IntBuffer histSize,
                                                          IntBuffer lowerLevel,
                                                          IntBuffer upperLevel)

histEven

@Namespace(value="cv::cuda")
public static void histEven(@ByVal
                                                          GpuMat src,
                                                          GpuMat hist,
                                                          int[] histSize,
                                                          int[] lowerLevel,
                                                          int[] upperLevel,
                                                          @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                          Stream stream)

histEven

@Namespace(value="cv::cuda")
public static void histEven(@ByVal
                                                          GpuMat src,
                                                          GpuMat hist,
                                                          int[] histSize,
                                                          int[] lowerLevel,
                                                          int[] upperLevel)

histRange

@Namespace(value="cv::cuda")
public static void histRange(@ByVal
                                                           Mat src,
                                                           @ByVal
                                                           Mat hist,
                                                           @ByVal
                                                           Mat levels,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

\brief Calculates a histogram with bins determined by the levels array.

Parameters:: src - Source image. CV_8U , CV_16U , or CV_16S depth and 1 or 4 channels are supported. For a four-channel image, all channels are processed separately.; hist - Destination histogram with one row, (levels.cols-1) columns, and the CV_32SC1 type.; levels - Number of levels in the histogram.; stream - Stream for the asynchronous version.

histRange

@Namespace(value="cv::cuda")
public static void histRange(@ByVal
                                                           Mat src,
                                                           @ByVal
                                                           Mat hist,
                                                           @ByVal
                                                           Mat levels)

histRange

@Namespace(value="cv::cuda")
public static void histRange(@ByVal
                                                           UMat src,
                                                           @ByVal
                                                           UMat hist,
                                                           @ByVal
                                                           UMat levels,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

histRange

@Namespace(value="cv::cuda")
public static void histRange(@ByVal
                                                           UMat src,
                                                           @ByVal
                                                           UMat hist,
                                                           @ByVal
                                                           UMat levels)

histRange

@Namespace(value="cv::cuda")
public static void histRange(@ByVal
                                                           GpuMat src,
                                                           @ByVal
                                                           GpuMat hist,
                                                           @ByVal
                                                           GpuMat levels,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

histRange

@Namespace(value="cv::cuda")
public static void histRange(@ByVal
                                                           GpuMat src,
                                                           @ByVal
                                                           GpuMat hist,
                                                           @ByVal
                                                           GpuMat levels)

histRange

@Namespace(value="cv::cuda")
public static void histRange(@ByVal
                                                           Mat src,
                                                           GpuMat hist,
                                                           @Const
                                                           GpuMat levels,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

\overload

histRange

@Namespace(value="cv::cuda")
public static void histRange(@ByVal
                                                           Mat src,
                                                           GpuMat hist,
                                                           @Const
                                                           GpuMat levels)

histRange

@Namespace(value="cv::cuda")
public static void histRange(@ByVal
                                                           UMat src,
                                                           GpuMat hist,
                                                           @Const
                                                           GpuMat levels,
                                                           @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                           Stream stream)

histRange

@Namespace(value="cv::cuda")
public static void histRange(@ByVal
                                                           UMat src,
                                                           GpuMat hist,
                                                           @Const
                                                           GpuMat levels)

createCannyEdgeDetector

@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static CannyEdgeDetector createCannyEdgeDetector(double low_thresh,
                                                                                                         double high_thresh,
                                                                                                         int apperture_size,
                                                                                                         @Cast(value="bool")
                                                                                                         boolean L2gradient)

\brief Creates implementation for cuda::CannyEdgeDetector .

Parameters:: low_thresh - First threshold for the hysteresis procedure.; high_thresh - Second threshold for the hysteresis procedure.; apperture_size - Aperture size for the Sobel operator.; L2gradient - Flag indicating whether a more accurate L_2 norm =\sqrt{(dI/dx)^2 + (dI/dy)^2} should be used to compute the image gradient magnitude ( L2gradient=true ), or a faster default L_1 norm =|dI/dx|+|dI/dy| is enough ( L2gradient=false ).

createCannyEdgeDetector

@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static CannyEdgeDetector createCannyEdgeDetector(double low_thresh,
                                                                                                         double high_thresh)

createHoughLinesDetector

@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static HoughLinesDetector createHoughLinesDetector(float rho,
                                                                                                           float theta,
                                                                                                           int threshold,
                                                                                                           @Cast(value="bool")
                                                                                                           boolean doSort,
                                                                                                           int maxLines)

\brief Creates implementation for cuda::HoughLinesDetector .

Parameters:: rho - Distance resolution of the accumulator in pixels.; theta - Angle resolution of the accumulator in radians.; threshold - Accumulator threshold parameter. Only those lines are returned that get enough votes ( >\texttt{threshold} ).; doSort - Performs lines sort by votes.; maxLines - Maximum number of output lines.

createHoughLinesDetector

@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static HoughLinesDetector createHoughLinesDetector(float rho,
                                                                                                           float theta,
                                                                                                           int threshold)

createHoughSegmentDetector

@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static HoughSegmentDetector createHoughSegmentDetector(float rho,
                                                                                                               float theta,
                                                                                                               int minLineLength,
                                                                                                               int maxLineGap,
                                                                                                               int maxLines,
                                                                                                               int threshold)

\brief Creates implementation for cuda::HoughSegmentDetector .

Parameters:: rho - Distance resolution of the accumulator in pixels.; theta - Angle resolution of the accumulator in radians.; minLineLength - Minimum line length. Line segments shorter than that are rejected.; maxLineGap - Maximum allowed gap between points on the same line to link them.; maxLines - Maximum number of output lines.; threshold - %Accumulator threshold parameter. Only those lines are returned that get enough votes ( >\texttt{threshold} ).

createHoughSegmentDetector

@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static HoughSegmentDetector createHoughSegmentDetector(float rho,
                                                                                                               float theta,
                                                                                                               int minLineLength,
                                                                                                               int maxLineGap)

createHoughCirclesDetector
```
@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static HoughCirclesDetector createHoughCirclesDetector(float dp,
                                                                                                               float minDist,
                                                                                                               int cannyThreshold,
                                                                                                               int votesThreshold,
                                                                                                               int minRadius,
                                                                                                               int maxRadius,
                                                                                                               int maxCircles)
```
\brief Creates implementation for cuda::HoughCirclesDetector .

Parameters:

dp - Inverse ratio of the accumulator resolution to the image resolution. For example, if dp=1 , the accumulator has the same resolution as the input image. If dp=2 , the accumulator has half as big width and height.

minDist - Minimum distance between the centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed.

cannyThreshold - The higher threshold of the two passed to Canny edge detector (the lower one is twice smaller).

votesThreshold - The accumulator threshold for the circle centers at the detection stage. The smaller it is, the more false circles may be detected.

minRadius - Minimum circle radius.

maxRadius - Maximum circle radius.

maxCircles - Maximum number of output circles.

createHoughCirclesDetector

@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static HoughCirclesDetector createHoughCirclesDetector(float dp,
                                                                                                               float minDist,
                                                                                                               int cannyThreshold,
                                                                                                               int votesThreshold,
                                                                                                               int minRadius,
                                                                                                               int maxRadius)

createGeneralizedHoughBallard

@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static GeneralizedHoughBallard createGeneralizedHoughBallard()

\brief Creates implementation for generalized hough transform from \cite Ballard1981 .

createGeneralizedHoughGuil

@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static GeneralizedHoughGuil createGeneralizedHoughGuil()

\brief Creates implementation for generalized hough transform from \cite Guil1999 .

createHarrisCorner

@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static CornernessCriteria createHarrisCorner(int srcType,
                                                                                                     int blockSize,
                                                                                                     int ksize,
                                                                                                     double k,
                                                                                                     int borderType)

\brief Creates implementation for Harris cornerness criteria.

Parameters:: srcType - Input source type. Only CV_8UC1 and CV_32FC1 are supported for now.; blockSize - Neighborhood size.; ksize - Aperture parameter for the Sobel operator.; k - Harris detector free parameter.; borderType - Pixel extrapolation method. Only BORDER_REFLECT101 and BORDER_REPLICATE are supported for now.
See Also:: cornerHarris

createHarrisCorner

@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static CornernessCriteria createHarrisCorner(int srcType,
                                                                                                     int blockSize,
                                                                                                     int ksize,
                                                                                                     double k)

createMinEigenValCorner

@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static CornernessCriteria createMinEigenValCorner(int srcType,
                                                                                                          int blockSize,
                                                                                                          int ksize,
                                                                                                          int borderType)

\brief Creates implementation for the minimum eigen value of a 2x2 derivative covariation matrix (the cornerness criteria).

Parameters:: srcType - Input source type. Only CV_8UC1 and CV_32FC1 are supported for now.; blockSize - Neighborhood size.; ksize - Aperture parameter for the Sobel operator.; borderType - Pixel extrapolation method. Only BORDER_REFLECT101 and BORDER_REPLICATE are supported for now.
See Also:: cornerMinEigenVal

createMinEigenValCorner

@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static CornernessCriteria createMinEigenValCorner(int srcType,
                                                                                                          int blockSize,
                                                                                                          int ksize)

createGoodFeaturesToTrackDetector
```
@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static CornersDetector createGoodFeaturesToTrackDetector(int srcType,
                                                                                                                 int maxCorners,
                                                                                                                 double qualityLevel,
                                                                                                                 double minDistance,
                                                                                                                 int blockSize,
                                                                                                                 @Cast(value="bool")
                                                                                                                 boolean useHarrisDetector,
                                                                                                                 double harrisK)
```
\brief Creates implementation for cuda::CornersDetector .

Parameters:

srcType - Input source type. Only CV_8UC1 and CV_32FC1 are supported for now.

maxCorners - Maximum number of corners to return. If there are more corners than are found, the strongest of them is returned.

qualityLevel - Parameter characterizing the minimal accepted quality of image corners. The parameter value is multiplied by the best corner quality measure, which is the minimal eigenvalue (see cornerMinEigenVal ) or the Harris function response (see cornerHarris ). The corners with the quality measure less than the product are rejected. For example, if the best corner has the quality measure = 1500, and the qualityLevel=0.01 , then all the corners with the quality measure less than 15 are rejected.

minDistance - Minimum possible Euclidean distance between the returned corners.

blockSize - Size of an average block for computing a derivative covariation matrix over each pixel neighborhood. See cornerEigenValsAndVecs .

useHarrisDetector - Parameter indicating whether to use a Harris detector (see cornerHarris) or cornerMinEigenVal.

harrisK - Free parameter of the Harris detector.

createGoodFeaturesToTrackDetector

@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static CornersDetector createGoodFeaturesToTrackDetector(int srcType)

meanShiftFiltering

@Namespace(value="cv::cuda")
public static void meanShiftFiltering(@ByVal
                                                                    Mat src,
                                                                    @ByVal
                                                                    Mat dst,
                                                                    int sp,
                                                                    int sr,
                                                                    @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::MAX_ITER + cv::TermCriteria::EPS, 5, 1)")
                                                                    TermCriteria criteria,
                                                                    @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                    Stream stream)

\} cudaimgproc_feature

///////////////////////////// Mean Shift //////////////////////////////

/** \brief Performs mean-shift filtering for each point of the source image.

Parameters:: src - Source image. Only CV_8UC4 images are supported for now.; dst - Destination image containing the color of mapped points. It has the same size and type as src .; sp - Spatial window radius.; sr - Color window radius.; criteria - Termination criteria. See TermCriteria.; stream - Stream for the asynchronous version.
It maps each point of the source image into another point. As a result, you have a new color and new position of each point.

meanShiftFiltering

@Namespace(value="cv::cuda")
public static void meanShiftFiltering(@ByVal
                                                                    Mat src,
                                                                    @ByVal
                                                                    Mat dst,
                                                                    int sp,
                                                                    int sr)

meanShiftFiltering

@Namespace(value="cv::cuda")
public static void meanShiftFiltering(@ByVal
                                                                    UMat src,
                                                                    @ByVal
                                                                    UMat dst,
                                                                    int sp,
                                                                    int sr,
                                                                    @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::MAX_ITER + cv::TermCriteria::EPS, 5, 1)")
                                                                    TermCriteria criteria,
                                                                    @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                    Stream stream)

meanShiftFiltering

@Namespace(value="cv::cuda")
public static void meanShiftFiltering(@ByVal
                                                                    UMat src,
                                                                    @ByVal
                                                                    UMat dst,
                                                                    int sp,
                                                                    int sr)

meanShiftFiltering

@Namespace(value="cv::cuda")
public static void meanShiftFiltering(@ByVal
                                                                    GpuMat src,
                                                                    @ByVal
                                                                    GpuMat dst,
                                                                    int sp,
                                                                    int sr,
                                                                    @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::MAX_ITER + cv::TermCriteria::EPS, 5, 1)")
                                                                    TermCriteria criteria,
                                                                    @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                    Stream stream)

meanShiftFiltering

@Namespace(value="cv::cuda")
public static void meanShiftFiltering(@ByVal
                                                                    GpuMat src,
                                                                    @ByVal
                                                                    GpuMat dst,
                                                                    int sp,
                                                                    int sr)

meanShiftProc

@Namespace(value="cv::cuda")
public static void meanShiftProc(@ByVal
                                                               Mat src,
                                                               @ByVal
                                                               Mat dstr,
                                                               @ByVal
                                                               Mat dstsp,
                                                               int sp,
                                                               int sr,
                                                               @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::MAX_ITER + cv::TermCriteria::EPS, 5, 1)")
                                                               TermCriteria criteria,
                                                               @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                               Stream stream)

\brief Performs a mean-shift procedure and stores information about processed points (their colors and positions) in two images.

Parameters:: src - Source image. Only CV_8UC4 images are supported for now.; dstr - Destination image containing the color of mapped points. The size and type is the same as src .; dstsp - Destination image containing the position of mapped points. The size is the same as src size. The type is CV_16SC2 .; sp - Spatial window radius.; sr - Color window radius.; criteria - Termination criteria. See TermCriteria.; stream - Stream for the asynchronous version.
See Also:: cuda::meanShiftFiltering

meanShiftProc

@Namespace(value="cv::cuda")
public static void meanShiftProc(@ByVal
                                                               Mat src,
                                                               @ByVal
                                                               Mat dstr,
                                                               @ByVal
                                                               Mat dstsp,
                                                               int sp,
                                                               int sr)

meanShiftProc

@Namespace(value="cv::cuda")
public static void meanShiftProc(@ByVal
                                                               UMat src,
                                                               @ByVal
                                                               UMat dstr,
                                                               @ByVal
                                                               UMat dstsp,
                                                               int sp,
                                                               int sr,
                                                               @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::MAX_ITER + cv::TermCriteria::EPS, 5, 1)")
                                                               TermCriteria criteria,
                                                               @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                               Stream stream)

meanShiftProc

@Namespace(value="cv::cuda")
public static void meanShiftProc(@ByVal
                                                               UMat src,
                                                               @ByVal
                                                               UMat dstr,
                                                               @ByVal
                                                               UMat dstsp,
                                                               int sp,
                                                               int sr)

meanShiftProc

@Namespace(value="cv::cuda")
public static void meanShiftProc(@ByVal
                                                               GpuMat src,
                                                               @ByVal
                                                               GpuMat dstr,
                                                               @ByVal
                                                               GpuMat dstsp,
                                                               int sp,
                                                               int sr,
                                                               @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::MAX_ITER + cv::TermCriteria::EPS, 5, 1)")
                                                               TermCriteria criteria,
                                                               @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                               Stream stream)

meanShiftProc

@Namespace(value="cv::cuda")
public static void meanShiftProc(@ByVal
                                                               GpuMat src,
                                                               @ByVal
                                                               GpuMat dstr,
                                                               @ByVal
                                                               GpuMat dstsp,
                                                               int sp,
                                                               int sr)

meanShiftSegmentation

@Namespace(value="cv::cuda")
public static void meanShiftSegmentation(@ByVal
                                                                       Mat src,
                                                                       @ByVal
                                                                       Mat dst,
                                                                       int sp,
                                                                       int sr,
                                                                       int minsize,
                                                                       @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::MAX_ITER + cv::TermCriteria::EPS, 5, 1)")
                                                                       TermCriteria criteria,
                                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                       Stream stream)

\brief Performs a mean-shift segmentation of the source image and eliminates small segments.

Parameters:: src - Source image. Only CV_8UC4 images are supported for now.; dst - Segmented image with the same size and type as src (host or gpu memory).; sp - Spatial window radius.; sr - Color window radius.; minsize - Minimum segment size. Smaller segments are merged.; criteria - Termination criteria. See TermCriteria.; stream - Stream for the asynchronous version.

meanShiftSegmentation

@Namespace(value="cv::cuda")
public static void meanShiftSegmentation(@ByVal
                                                                       Mat src,
                                                                       @ByVal
                                                                       Mat dst,
                                                                       int sp,
                                                                       int sr,
                                                                       int minsize)

meanShiftSegmentation

@Namespace(value="cv::cuda")
public static void meanShiftSegmentation(@ByVal
                                                                       UMat src,
                                                                       @ByVal
                                                                       UMat dst,
                                                                       int sp,
                                                                       int sr,
                                                                       int minsize,
                                                                       @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::MAX_ITER + cv::TermCriteria::EPS, 5, 1)")
                                                                       TermCriteria criteria,
                                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                       Stream stream)

meanShiftSegmentation

@Namespace(value="cv::cuda")
public static void meanShiftSegmentation(@ByVal
                                                                       UMat src,
                                                                       @ByVal
                                                                       UMat dst,
                                                                       int sp,
                                                                       int sr,
                                                                       int minsize)

meanShiftSegmentation

@Namespace(value="cv::cuda")
public static void meanShiftSegmentation(@ByVal
                                                                       GpuMat src,
                                                                       @ByVal
                                                                       GpuMat dst,
                                                                       int sp,
                                                                       int sr,
                                                                       int minsize,
                                                                       @ByVal(nullValue="cv::TermCriteria(cv::TermCriteria::MAX_ITER + cv::TermCriteria::EPS, 5, 1)")
                                                                       TermCriteria criteria,
                                                                       @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                       Stream stream)

meanShiftSegmentation

@Namespace(value="cv::cuda")
public static void meanShiftSegmentation(@ByVal
                                                                       GpuMat src,
                                                                       @ByVal
                                                                       GpuMat dst,
                                                                       int sp,
                                                                       int sr,
                                                                       int minsize)

createTemplateMatching
```
@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static TemplateMatching createTemplateMatching(int srcType,
                                                                                                       int method,
                                                                                                       @ByVal(nullValue="cv::Size()")
                                                                                                       Size user_block_size)
```
\brief Creates implementation for cuda::TemplateMatching .

Parameters:

srcType - Input source type. CV_32F and CV_8U depth images (1..4 channels) are supported for now.

method - Specifies the way to compare the template with the image.

user_block_size - You can use field user_block_size to set specific block size. If you leave its default value Size(0,0) then automatic estimation of block size will be used (which is optimized for speed). By varying user_block_size you can reduce memory requirements at the cost of speed.
The following methods are supported for the CV_8U depth images for now:
- CV_TM_SQDIFF - CV_TM_SQDIFF_NORMED - CV_TM_CCORR - CV_TM_CCORR_NORMED - CV_TM_CCOEFF - CV_TM_CCOEFF_NORMED
The following methods are supported for the CV_32F images for now:
- CV_TM_SQDIFF - CV_TM_CCORR

See Also:

matchTemplate

createTemplateMatching

@Namespace(value="cv::cuda")
 @opencv_core.Ptr
public static TemplateMatching createTemplateMatching(int srcType,
                                                                                                       int method)

bilateralFilter

@Namespace(value="cv::cuda")
public static void bilateralFilter(@ByVal
                                                                 Mat src,
                                                                 @ByVal
                                                                 Mat dst,
                                                                 int kernel_size,
                                                                 float sigma_color,
                                                                 float sigma_spatial,
                                                                 int borderMode,
                                                                 @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                 Stream stream)

\brief Performs bilateral filtering of passed image

Parameters:: src - Source image. Supports only (channels != 2 && depth() != CV_8S && depth() != CV_32S && depth() != CV_64F).; dst - Destination imagwe.; kernel_size - Kernel window size.; sigma_color - Filter sigma in the color space.; sigma_spatial - Filter sigma in the coordinate space.; 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:: bilateralFilter

bilateralFilter

@Namespace(value="cv::cuda")
public static void bilateralFilter(@ByVal
                                                                 Mat src,
                                                                 @ByVal
                                                                 Mat dst,
                                                                 int kernel_size,
                                                                 float sigma_color,
                                                                 float sigma_spatial)

bilateralFilter

@Namespace(value="cv::cuda")
public static void bilateralFilter(@ByVal
                                                                 UMat src,
                                                                 @ByVal
                                                                 UMat dst,
                                                                 int kernel_size,
                                                                 float sigma_color,
                                                                 float sigma_spatial,
                                                                 int borderMode,
                                                                 @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                 Stream stream)

bilateralFilter

@Namespace(value="cv::cuda")
public static void bilateralFilter(@ByVal
                                                                 UMat src,
                                                                 @ByVal
                                                                 UMat dst,
                                                                 int kernel_size,
                                                                 float sigma_color,
                                                                 float sigma_spatial)

bilateralFilter

@Namespace(value="cv::cuda")
public static void bilateralFilter(@ByVal
                                                                 GpuMat src,
                                                                 @ByVal
                                                                 GpuMat dst,
                                                                 int kernel_size,
                                                                 float sigma_color,
                                                                 float sigma_spatial,
                                                                 int borderMode,
                                                                 @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                 Stream stream)

bilateralFilter

@Namespace(value="cv::cuda")
public static void bilateralFilter(@ByVal
                                                                 GpuMat src,
                                                                 @ByVal
                                                                 GpuMat dst,
                                                                 int kernel_size,
                                                                 float sigma_color,
                                                                 float sigma_spatial)

blendLinear

@Namespace(value="cv::cuda")
public static void blendLinear(@ByVal
                                                             Mat img1,
                                                             @ByVal
                                                             Mat img2,
                                                             @ByVal
                                                             Mat weights1,
                                                             @ByVal
                                                             Mat weights2,
                                                             @ByVal
                                                             Mat result,
                                                             @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                             Stream stream)

\brief Performs linear blending of two images.

Parameters:: img1 - First image. Supports only CV_8U and CV_32F depth.; img2 - Second image. Must have the same size and the same type as img1 .; weights1 - Weights for first image. Must have tha same size as img1 . Supports only CV_32F type.; weights2 - Weights for second image. Must have tha same size as img2 . Supports only CV_32F type.; result - Destination image.; stream - Stream for the asynchronous version.

blendLinear

@Namespace(value="cv::cuda")
public static void blendLinear(@ByVal
                                                             Mat img1,
                                                             @ByVal
                                                             Mat img2,
                                                             @ByVal
                                                             Mat weights1,
                                                             @ByVal
                                                             Mat weights2,
                                                             @ByVal
                                                             Mat result)

blendLinear

@Namespace(value="cv::cuda")
public static void blendLinear(@ByVal
                                                             UMat img1,
                                                             @ByVal
                                                             UMat img2,
                                                             @ByVal
                                                             UMat weights1,
                                                             @ByVal
                                                             UMat weights2,
                                                             @ByVal
                                                             UMat result,
                                                             @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                             Stream stream)

blendLinear

@Namespace(value="cv::cuda")
public static void blendLinear(@ByVal
                                                             UMat img1,
                                                             @ByVal
                                                             UMat img2,
                                                             @ByVal
                                                             UMat weights1,
                                                             @ByVal
                                                             UMat weights2,
                                                             @ByVal
                                                             UMat result)

blendLinear

@Namespace(value="cv::cuda")
public static void blendLinear(@ByVal
                                                             GpuMat img1,
                                                             @ByVal
                                                             GpuMat img2,
                                                             @ByVal
                                                             GpuMat weights1,
                                                             @ByVal
                                                             GpuMat weights2,
                                                             @ByVal
                                                             GpuMat result,
                                                             @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                             Stream stream)

blendLinear

@Namespace(value="cv::cuda")
public static void blendLinear(@ByVal
                                                             GpuMat img1,
                                                             @ByVal
                                                             GpuMat img2,
                                                             @ByVal
                                                             GpuMat weights1,
                                                             @ByVal
                                                             GpuMat weights2,
                                                             @ByVal
                                                             GpuMat result)

connectedComponentsWithAlgorithm

@Namespace(value="cv::cuda")
 @Name(value="connectedComponents")
public static void connectedComponentsWithAlgorithm(@ByVal
                                                                                                                       Mat image,
                                                                                                                       @ByVal
                                                                                                                       Mat labels,
                                                                                                                       int connectivity,
                                                                                                                       int ltype,
                                                                                                                       @Cast(value="cv::cuda::ConnectedComponentsAlgorithmsTypes")
                                                                                                                       int ccltype)

\brief Computes the Connected Components Labeled image of a binary image.

The function takes as input a binary image and performs Connected Components Labeling. The output is an image where each Connected Component is assigned a unique label (integer value). ltype specifies the output label image type, an important consideration based on the total number of labels or alternatively the total number of pixels in the source image. ccltype specifies the connected components labeling algorithm to use, currently BKE \cite Allegretti2019 is supported, see the #ConnectedComponentsAlgorithmsTypes for details. Note that labels in the output are not required to be sequential.

Parameters:

image - The 8-bit single-channel image to be labeled.

labels - Destination labeled image.

connectivity - Connectivity to use for the labeling procedure. 8 for 8-way connectivity is supported.

ltype - Output image label type. Currently CV_32S is supported.

ccltype - Connected components algorithm type (see the #ConnectedComponentsAlgorithmsTypes).

\note A sample program demonstrating Connected Components Labeling in CUDA can be found at\n opencv_contrib_source_code/modules/cudaimgproc/samples/connected_components.cpp

connectedComponentsWithAlgorithm

@Namespace(value="cv::cuda")
 @Name(value="connectedComponents")
public static void connectedComponentsWithAlgorithm(@ByVal
                                                                                                                       UMat image,
                                                                                                                       @ByVal
                                                                                                                       UMat labels,
                                                                                                                       int connectivity,
                                                                                                                       int ltype,
                                                                                                                       @Cast(value="cv::cuda::ConnectedComponentsAlgorithmsTypes")
                                                                                                                       int ccltype)

connectedComponentsWithAlgorithm

@Namespace(value="cv::cuda")
 @Name(value="connectedComponents")
public static void connectedComponentsWithAlgorithm(@ByVal
                                                                                                                       GpuMat image,
                                                                                                                       @ByVal
                                                                                                                       GpuMat labels,
                                                                                                                       int connectivity,
                                                                                                                       int ltype,
                                                                                                                       @Cast(value="cv::cuda::ConnectedComponentsAlgorithmsTypes")
                                                                                                                       int ccltype)

connectedComponents

@Namespace(value="cv::cuda")
public static void connectedComponents(@ByVal
                                                                     Mat image,
                                                                     @ByVal
                                                                     Mat labels,
                                                                     int connectivity,
                                                                     int ltype)

\overload

Parameters:: image - The 8-bit single-channel image to be labeled.; labels - Destination labeled image.; connectivity - Connectivity to use for the labeling procedure. 8 for 8-way connectivity is supported.; ltype - Output image label type. Currently CV_32S is supported.

connectedComponents

@Namespace(value="cv::cuda")
public static void connectedComponents(@ByVal
                                                                     Mat image,
                                                                     @ByVal
                                                                     Mat labels)

connectedComponents

@Namespace(value="cv::cuda")
public static void connectedComponents(@ByVal
                                                                     UMat image,
                                                                     @ByVal
                                                                     UMat labels,
                                                                     int connectivity,
                                                                     int ltype)

connectedComponents

@Namespace(value="cv::cuda")
public static void connectedComponents(@ByVal
                                                                     UMat image,
                                                                     @ByVal
                                                                     UMat labels)

connectedComponents

@Namespace(value="cv::cuda")
public static void connectedComponents(@ByVal
                                                                     GpuMat image,
                                                                     @ByVal
                                                                     GpuMat labels,
                                                                     int connectivity,
                                                                     int ltype)

connectedComponents

@Namespace(value="cv::cuda")
public static void connectedComponents(@ByVal
                                                                     GpuMat image,
                                                                     @ByVal
                                                                     GpuMat labels)

numMoments
```
@Namespace(value="cv::cuda")
public static int numMoments(@Cast(value="const cv::cuda::MomentsOrder")
                                                           int order)
```
\brief Returns the number of image moments less than or equal to the largest image moments \a order.

Parameters:

order - Order of largest moments to calculate with lower order moments requiring less computation.

Returns:

number of image moments.

See Also:

cuda::spatialMoments, cuda::moments, cuda::MomentsOrder

convertSpatialMoments

@Namespace(value="cv::cuda")
 @ByVal
public static Moments convertSpatialMoments(@ByVal
                                                                                   Mat spatialMoments,
                                                                                   @Cast(value="const cv::cuda::MomentsOrder")
                                                                                   int order,
                                                                                   int momentsType)

\brief Converts the spatial image moments returned from cuda::spatialMoments to cv::Moments.

Parameters:: spatialMoments - Spatial moments returned from cuda::spatialMoments.; order - Order used when calculating image moments with cuda::spatialMoments.; momentsType - Precision used when calculating image moments with cuda::spatialMoments.
Returns:: cv::Moments.
See Also:: cuda::spatialMoments, cuda::moments, cuda::convertSpatialMoments, cuda::numMoments, cuda::MomentsOrder

spatialMoments

@Namespace(value="cv::cuda")
public static void spatialMoments(@ByVal
                                                                Mat src,
                                                                @ByVal
                                                                Mat moments,
                                                                @Cast(value="const bool")
                                                                boolean binaryImage,
                                                                @Cast(value="const cv::cuda::MomentsOrder")
                                                                int order,
                                                                int momentsType,
                                                                @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                Stream stream)

\brief Calculates all of the spatial moments up to the 3rd order of a rasterized shape.

Asynchronous version of cuda::moments() which only calculates the spatial (not centralized or normalized) moments, up to the 3rd order, of a rasterized shape. Each moment is returned as a column entry in the 1D \a moments array.

Parameters:

src - Raster image (single-channel 2D array).

moments - [out] 1D array with each column entry containing a spatial image moment.

binaryImage - If it is true, all non-zero image pixels are treated as 1's.

order - Order of largest moments to calculate with lower order moments requiring less computation.

momentsType - Precision to use when calculating moments. Available types are \ref CV_32F and \ref CV_64F with the performance of \ref CV_32F an order of magnitude greater than \ref CV_64F. If the image is small the accuracy from \ref CV_32F can be equal or very close to \ref CV_64F.

stream - Stream for the asynchronous version.

\note For maximum performance pre-allocate a 1D GpuMat for \a moments of the correct type and size large enough to store the all the image moments of up to the desired \a order. e.g. With \a order === MomentsOrder::SECOND_ORDER_MOMENTS and \a momentsType == \ref CV_32F \a moments can be allocated as


GpuMat momentsDevice(1,numMoments(MomentsOrder::SECOND_ORDER_MOMENTS),CV_32F)

The central and normalized moments can easily be calculated on the host by downloading the \a moments array and using the cuda::convertSpatialMoments helper function. e.g.


HostMem spatialMomentsHostMem(1, numMoments(MomentsOrder::SECOND_ORDER_MOMENTS), CV_32F);
spatialMomentsDevice.download(spatialMomentsHostMem, stream);
stream.waitForCompletion();
Mat spatialMoments = spatialMomentsHostMem.createMatHeader();
cv::Moments cvMoments = convertSpatialMoments<float>(spatialMoments, order);

see the \a CUDA_TEST_P(Moments, Async) test inside opencv_contrib_source_code/modules/cudaimgproc/test/test_moments.cpp for an example.

See Also:

cuda::moments, cuda::convertSpatialMoments, cuda::numMoments, cuda::MomentsOrder

spatialMoments

@Namespace(value="cv::cuda")
public static void spatialMoments(@ByVal
                                                                Mat src,
                                                                @ByVal
                                                                Mat moments)

spatialMoments

@Namespace(value="cv::cuda")
public static void spatialMoments(@ByVal
                                                                UMat src,
                                                                @ByVal
                                                                UMat moments,
                                                                @Cast(value="const bool")
                                                                boolean binaryImage,
                                                                @Cast(value="const cv::cuda::MomentsOrder")
                                                                int order,
                                                                int momentsType,
                                                                @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                Stream stream)

spatialMoments

@Namespace(value="cv::cuda")
public static void spatialMoments(@ByVal
                                                                UMat src,
                                                                @ByVal
                                                                UMat moments)

spatialMoments

@Namespace(value="cv::cuda")
public static void spatialMoments(@ByVal
                                                                GpuMat src,
                                                                @ByVal
                                                                GpuMat moments,
                                                                @Cast(value="const bool")
                                                                boolean binaryImage,
                                                                @Cast(value="const cv::cuda::MomentsOrder")
                                                                int order,
                                                                int momentsType,
                                                                @ByRef(nullValue="cv::cuda::Stream::Null()")
                                                                Stream stream)

spatialMoments

@Namespace(value="cv::cuda")
public static void spatialMoments(@ByVal
                                                                GpuMat src,
                                                                @ByVal
                                                                GpuMat moments)

moments
```
@Namespace(value="cv::cuda")
 @ByVal
public static Moments moments(@ByVal
                                                                     Mat src,
                                                                     @Cast(value="const bool")
                                                                     boolean binaryImage,
                                                                     @Cast(value="const cv::cuda::MomentsOrder")
                                                                     int order,
                                                                     int momentsType)
```
\brief Calculates all of the moments up to the 3rd order of a rasterized shape.
The function computes moments, up to the 3rd order, of a rasterized shape. The results are returned in the structure cv::Moments.
Parameters:

src - Raster image (single-channel 2D array).

binaryImage - If it is true, all non-zero image pixels are treated as 1's.

order - Order of largest moments to calculate with lower order moments requiring less computation.
momentsType - Precision to use when calculating moments. Available types are \ref CV_32F and \ref CV_64F with the performance of \ref CV_32F an order of magnitude greater than \ref CV_64F. If the image is small the accuracy from \ref CV_32F can be equal or very close to \ref CV_64F.
\note For maximum performance use the asynchronous version cuda::spatialMoments() as this version interally allocates and deallocates both GpuMat and HostMem to respectively perform the calculation on the device and download the result to the host. The costly HostMem allocation cannot be avoided however the GpuMat device allocation can be by using BufferPool, e.g.
```
    setBufferPoolUsage(true);
    setBufferPoolConfig(getDevice(), numMoments(order) * ((momentsType == CV_64F) ? sizeof(double) : sizeof(float)), 1);
```
see the \a CUDA_TEST_P(Moments, Accuracy) test inside opencv_contrib_source_code/modules/cudaimgproc/test/test_moments.cpp for an example.
Returns:

cv::Moments.

See Also:

cuda::spatialMoments, cuda::convertSpatialMoments, cuda::numMoments, cuda::MomentsOrder

moments

@Namespace(value="cv::cuda")
 @ByVal
public static Moments moments(@ByVal
                                                                     Mat src)

moments

@Namespace(value="cv::cuda")
 @ByVal
public static Moments moments(@ByVal
                                                                     UMat src,
                                                                     @Cast(value="const bool")
                                                                     boolean binaryImage,
                                                                     @Cast(value="const cv::cuda::MomentsOrder")
                                                                     int order,
                                                                     int momentsType)

moments

@Namespace(value="cv::cuda")
 @ByVal
public static Moments moments(@ByVal
                                                                     UMat src)

moments

@Namespace(value="cv::cuda")
 @ByVal
public static Moments moments(@ByVal
                                                                     GpuMat src,
                                                                     @Cast(value="const bool")
                                                                     boolean binaryImage,
                                                                     @Cast(value="const cv::cuda::MomentsOrder")
                                                                     int order,
                                                                     int momentsType)

moments

@Namespace(value="cv::cuda")
 @ByVal
public static Moments moments(@ByVal
                                                                     GpuMat src)

Class opencv_cudaimgproc

Field Summary

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Field Detail

COLOR_BayerBG2BGR_MHT

COLOR_BayerGB2BGR_MHT

COLOR_BayerRG2BGR_MHT

COLOR_BayerGR2BGR_MHT

COLOR_BayerBG2RGB_MHT

COLOR_BayerGB2RGB_MHT

COLOR_BayerRG2RGB_MHT

COLOR_BayerGR2RGB_MHT

COLOR_BayerBG2GRAY_MHT

COLOR_BayerGB2GRAY_MHT

COLOR_BayerRG2GRAY_MHT

COLOR_BayerGR2GRAY_MHT

ALPHA_OVER

ALPHA_IN

ALPHA_OUT

ALPHA_ATOP

ALPHA_XOR

ALPHA_PLUS

ALPHA_OVER_PREMUL

ALPHA_IN_PREMUL

ALPHA_OUT_PREMUL

ALPHA_ATOP_PREMUL

ALPHA_XOR_PREMUL

ALPHA_PLUS_PREMUL

ALPHA_PREMUL

CCL_DEFAULT

CCL_BKE

FIRST_ORDER_MOMENTS

SECOND_ORDER_MOMENTS

THIRD_ORDER_MOMENTS

Constructor Detail

opencv_cudaimgproc

Method Detail

cvtColor

cvtColor

cvtColor

cvtColor

cvtColor

cvtColor

demosaicing

demosaicing

demosaicing

demosaicing

demosaicing

demosaicing

swapChannels

swapChannels

swapChannels

swapChannels

swapChannels

swapChannels

swapChannels

swapChannels

swapChannels

swapChannels

swapChannels

swapChannels

swapChannels

swapChannels

swapChannels

swapChannels

swapChannels

swapChannels

gammaCorrection

gammaCorrection

gammaCorrection

gammaCorrection

gammaCorrection

gammaCorrection

alphaComp

alphaComp

alphaComp

alphaComp