opencv_cudaimgproc (JavaCPP Presets for OpenCV 4.3.0-1.5.3 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`	`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

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 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)` \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 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

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)

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

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)

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

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

alphaComp

alphaComp

calcHist

calcHist

calcHist