cv::cuda Namespace Reference

Classes
class	BackgroundSubtractorFGD
	The class discriminates between foreground and background pixels by building and maintaining a model of the background. More...
class	BackgroundSubtractorGMG
	Background/Foreground Segmentation Algorithm. More...
class	BackgroundSubtractorMOG
	Gaussian Mixture-based Background/Foreground Segmentation Algorithm. More...
class	BackgroundSubtractorMOG2
	Gaussian Mixture-based Background/Foreground Segmentation Algorithm. More...
class	BroxOpticalFlow
	Class computing the optical flow for two images using Brox et al Optical Flow algorithm ([42]). More...
class	BufferPool
	BufferPool for use with CUDA streams. More...
class	CannyEdgeDetector
	Base class for Canny Edge Detector. : More...
class	CascadeClassifier
	Cascade classifier class used for object detection. Supports HAAR and LBP cascades. : More...
class	CLAHE
	Base class for Contrast Limited Adaptive Histogram Equalization. : More...
class	Convolution
	Base class for convolution (or cross-correlation) operator. : More...
class	CornernessCriteria
	Base class for Cornerness Criteria computation. : More...
class	CornersDetector
	Base class for Corners Detector. : More...
class	DenseOpticalFlow
	Base interface for dense optical flow algorithms. More...
class	DensePyrLKOpticalFlow
	Class used for calculating a dense optical flow. More...
class	DescriptorMatcher
	Abstract base class for matching keypoint descriptors. More...
class	DeviceInfo
	Class providing functionality for querying the specified GPU properties. More...
class	DFT
	Base class for DFT operator as a cv::Algorithm. : More...
class	DisparityBilateralFilter
	Class refining a disparity map using joint bilateral filtering. : More...
class	Event
struct	EventAccessor
	Class that enables getting cudaEvent_t from cuda::Event. More...
class	FarnebackOpticalFlow
	Class computing a dense optical flow using the Gunnar Farneback's algorithm. More...
class	FastFeatureDetector
	Wrapping class for feature detection using the FAST method. More...
class	FastOpticalFlowBM
class	Feature2DAsync
	Abstract base class for CUDA asynchronous 2D image feature detectors and descriptor extractors. More...
struct	FGDParams
class	Filter
	Common interface for all CUDA filters : More...
struct	GpuData
class	GpuMat
	Base storage class for GPU memory with reference counting. More...
class	GpuMatND
class	HOG
	The class implements Histogram of Oriented Gradients ([63]) object detector. More...
class	HostMem
	Class with reference counting wrapping special memory type allocation functions from CUDA. More...
class	HoughCirclesDetector
	Base class for circles detector algorithm. : More...
class	HoughLinesDetector
	Base class for lines detector algorithm. : More...
class	HoughSegmentDetector
	Base class for line segments detector algorithm. : More...
class	ImagePyramid
class	LookUpTable
	Base class for transform using lookup table. More...
class	NvidiaHWOpticalFlow
	Base Interface for optical flow algorithms using NVIDIA Optical Flow SDK. More...
class	NvidiaOpticalFlow_1_0
	Class for computing the optical flow vectors between two images using NVIDIA Optical Flow hardware and Optical Flow SDK 1.0. More...
class	NvidiaOpticalFlow_2_0
	Class for computing the optical flow vectors between two images using NVIDIA Optical Flow hardware and Optical Flow SDK 2.0. More...
class	OpticalFlowDual_TVL1
	Implementation of the Zach, Pock and Bischof Dual TV-L1 Optical Flow method. More...
class	ORB
	Class implementing the ORB (oriented BRIEF) keypoint detector and descriptor extractor. More...
class	SparseOpticalFlow
	Base interface for sparse optical flow algorithms. More...
class	SparsePyrLKOpticalFlow
	Class used for calculating a sparse optical flow. More...
class	StereoBeliefPropagation
	Class computing stereo correspondence using the belief propagation algorithm. : More...
class	StereoBM
	Class computing stereo correspondence (disparity map) using the block matching algorithm. : More...
class	StereoConstantSpaceBP
	Class computing stereo correspondence using the constant space belief propagation algorithm. : More...
class	StereoSGM
	The class implements the modified H. Hirschmuller algorithm [126]. Limitation and difference are as follows: More...
class	Stream
	This class encapsulates a queue of asynchronous calls. More...
struct	StreamAccessor
	Class that enables getting cudaStream_t from cuda::Stream. More...
class	SURF_CUDA
	Class used for extracting Speeded Up Robust Features (SURF) from an image. : More...
class	TargetArchs
	Class providing a set of static methods to check what NVIDIA* card architecture the CUDA module was built for. More...
class	TemplateMatching
	Base class for Template Matching. : More...

Enumerations
enum	AlphaCompTypes {   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 }
enum	ConnectedComponentsAlgorithmsTypes {   CCL_DEFAULT = -1 ,   CCL_BKE = 0 }
	Connected Components Algorithm. More...
enum	DemosaicTypes {   COLOR_BayerBG2BGR_MHT = 256 ,   COLOR_BayerGB2BGR_MHT = 257 ,   COLOR_BayerRG2BGR_MHT = 258 ,   COLOR_BayerGR2BGR_MHT = 259 ,   COLOR_BayerBG2RGB_MHT = COLOR_BayerRG2BGR_MHT ,   COLOR_BayerGB2RGB_MHT = COLOR_BayerGR2BGR_MHT ,   COLOR_BayerRG2RGB_MHT = COLOR_BayerBG2BGR_MHT ,   COLOR_BayerGR2RGB_MHT = COLOR_BayerGB2BGR_MHT ,   COLOR_BayerBG2GRAY_MHT = 260 ,   COLOR_BayerGB2GRAY_MHT = 261 ,   COLOR_BayerRG2GRAY_MHT = 262 ,   COLOR_BayerGR2GRAY_MHT = 263 }
enum	FeatureSet {   FEATURE_SET_COMPUTE_10 = 10 ,   FEATURE_SET_COMPUTE_11 = 11 ,   FEATURE_SET_COMPUTE_12 = 12 ,   FEATURE_SET_COMPUTE_13 = 13 ,   FEATURE_SET_COMPUTE_20 = 20 ,   FEATURE_SET_COMPUTE_21 = 21 ,   FEATURE_SET_COMPUTE_30 = 30 ,   FEATURE_SET_COMPUTE_32 = 32 ,   FEATURE_SET_COMPUTE_35 = 35 ,   FEATURE_SET_COMPUTE_50 = 50 ,   GLOBAL_ATOMICS = FEATURE_SET_COMPUTE_11 ,   SHARED_ATOMICS = FEATURE_SET_COMPUTE_12 ,   NATIVE_DOUBLE = FEATURE_SET_COMPUTE_13 ,   WARP_SHUFFLE_FUNCTIONS = FEATURE_SET_COMPUTE_30 ,   DYNAMIC_PARALLELISM = FEATURE_SET_COMPUTE_35 }
	Enumeration providing CUDA computing features. More...
enum	MomentsOrder {   FIRST_ORDER_MOMENTS = 1 ,   SECOND_ORDER_MOMENTS = 2 ,   THIRD_ORDER_MOMENTS = 3 }
	Order of image moments. More...

Functions
void	abs (InputArray src, OutputArray dst, Stream &stream=Stream::Null())
	Computes an absolute value of each matrix element.
void	absdiff (InputArray src1, InputArray src2, OutputArray dst, Stream &stream=Stream::Null())
	Computes per-element absolute difference of two matrices (or of a matrix and scalar).
Scalar	absSum (InputArray src, InputArray mask=noArray())
	Returns the sum of absolute values for matrix elements.
void	add (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1, Stream &stream=Stream::Null())
	Computes a matrix-matrix or matrix-scalar sum.
void	addWeighted (InputArray src1, double alpha, InputArray src2, double beta, double gamma, OutputArray dst, int dtype=-1, Stream &stream=Stream::Null())
	Computes the weighted sum of two arrays.
void	alphaComp (InputArray img1, InputArray img2, OutputArray dst, int alpha_op, Stream &stream=Stream::Null())
	Composites two images using alpha opacity values contained in each image.
void	bilateralFilter (InputArray src, OutputArray dst, int kernel_size, float sigma_color, float sigma_spatial, int borderMode=BORDER_DEFAULT, Stream &stream=Stream::Null())
	Performs bilateral filtering of passed image.
void	bitwise_and (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), Stream &stream=Stream::Null())
	Performs a per-element bitwise conjunction of two matrices (or of matrix and scalar).
void	bitwise_not (InputArray src, OutputArray dst, InputArray mask=noArray(), Stream &stream=Stream::Null())
	Performs a per-element bitwise inversion.
void	bitwise_or (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), Stream &stream=Stream::Null())
	Performs a per-element bitwise disjunction of two matrices (or of matrix and scalar).
void	bitwise_xor (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), Stream &stream=Stream::Null())
	Performs a per-element bitwise exclusive or operation of two matrices (or of matrix and scalar).
void	blendLinear (InputArray img1, InputArray img2, InputArray weights1, InputArray weights2, OutputArray result, Stream &stream=Stream::Null())
	Performs linear blending of two images.
void	buildWarpAffineMaps (InputArray M, bool inverse, Size dsize, OutputArray xmap, OutputArray ymap, Stream &stream=Stream::Null())
	Builds transformation maps for affine transformation.
void	buildWarpAffineMaps (Mat M, bool inverse, Size dsize, GpuMat &xmap, GpuMat &ymap, Stream &stream=Stream::Null())
void	buildWarpAffineMaps (UMat M, bool inverse, Size dsize, GpuMat &xmap, GpuMat &ymap, Stream &stream=Stream::Null())
void	buildWarpPerspectiveMaps (InputArray M, bool inverse, Size dsize, OutputArray xmap, OutputArray ymap, Stream &stream=Stream::Null())
	Builds transformation maps for perspective transformation.
void	buildWarpPerspectiveMaps (Mat M, bool inverse, Size dsize, GpuMat &xmap, GpuMat &ymap, Stream &stream=Stream::Null())
void	buildWarpPerspectiveMaps (UMat M, bool inverse, Size dsize, GpuMat &xmap, GpuMat &ymap, Stream &stream=Stream::Null())
void	calcAbsSum (InputArray src, OutputArray dst, InputArray mask=noArray(), Stream &stream=Stream::Null())
void	calcHist (InputArray src, InputArray mask, OutputArray hist, Stream &stream=Stream::Null())
	Calculates histogram for one channel 8-bit image confined in given mask.
void	calcHist (InputArray src, OutputArray hist, Stream &stream=Stream::Null())
	Calculates histogram for one channel 8-bit image.
void	calcNorm (InputArray src, OutputArray dst, int normType, InputArray mask=noArray(), Stream &stream=Stream::Null())
void	calcNormDiff (InputArray src1, InputArray src2, OutputArray dst, int normType=NORM_L2, Stream &stream=Stream::Null())
void	calcOpticalFlowBM (const GpuMat &prev, const GpuMat &curr, Size block_size, Size shift_size, Size max_range, bool use_previous, GpuMat &velx, GpuMat &vely, GpuMat &buf, Stream &stream=Stream::Null())
	Calculates optical flow for 2 images using block matching algorithm *‍/.
void	calcSqrSum (InputArray src, OutputArray dst, InputArray mask=noArray(), Stream &stream=Stream::Null())
void	calcSum (InputArray src, OutputArray dst, InputArray mask=noArray(), Stream &stream=Stream::Null())
void	cartToPolar (InputArray x, InputArray y, OutputArray magnitude, OutputArray angle, bool angleInDegrees=false, Stream &stream=Stream::Null())
	Converts Cartesian coordinates into polar.
void	compare (InputArray src1, InputArray src2, OutputArray dst, int cmpop, Stream &stream=Stream::Null())
	Compares elements of two matrices (or of a matrix and scalar).
void	connectedComponents (InputArray image, OutputArray labels, int connectivity, int ltype, cv::cuda::ConnectedComponentsAlgorithmsTypes ccltype)
	Computes the Connected Components Labeled image of a binary image.
void	connectedComponents (InputArray image, OutputArray labels, int connectivity=8, int ltype=CV_32S)
void	connectivityMask (const GpuMat &image, GpuMat &mask, const cv::Scalar &lo, const cv::Scalar &hi, Stream &stream=Stream::Null())
	compute mask for Generalized Flood fill componetns labeling.
void	convertFp16 (InputArray _src, OutputArray _dst, Stream &stream=Stream::Null())
	Converts an array to half precision floating number.
Moments	convertSpatialMoments (Mat spatialMoments, const MomentsOrder order, const int momentsType)
	Converts the spatial image moments returned from cuda::spatialMoments to cv::Moments.
void	copyMakeBorder (InputArray src, OutputArray dst, int top, int bottom, int left, int right, int borderType, Scalar value=Scalar(), Stream &stream=Stream::Null())
	Forms a border around an image.
int	countNonZero (InputArray src)
	Counts non-zero matrix elements.
void	countNonZero (InputArray src, OutputArray dst, Stream &stream=Stream::Null())
Ptr< cuda::BackgroundSubtractorFGD >	createBackgroundSubtractorFGD (const FGDParams &params=FGDParams())
	Creates FGD Background Subtractor.
Ptr< cuda::BackgroundSubtractorGMG >	createBackgroundSubtractorGMG (int initializationFrames=120, double decisionThreshold=0.8)
	Creates GMG Background Subtractor.
Ptr< cuda::BackgroundSubtractorMOG >	createBackgroundSubtractorMOG (int history=200, int nmixtures=5, double backgroundRatio=0.7, double noiseSigma=0)
	Creates mixture-of-gaussian background subtractor.
Ptr< cuda::BackgroundSubtractorMOG2 >	createBackgroundSubtractorMOG2 (int history=500, double varThreshold=16, bool detectShadows=true)
	Creates MOG2 Background Subtractor.
Ptr< Filter >	createBoxFilter (int srcType, int dstType, Size ksize, Point anchor=Point(-1, -1), int borderMode=BORDER_DEFAULT, Scalar borderVal=Scalar::all(0))
	Creates a normalized 2D box filter.
Ptr< Filter >	createBoxMaxFilter (int srcType, Size ksize, Point anchor=Point(-1, -1), int borderMode=BORDER_DEFAULT, Scalar borderVal=Scalar::all(0))
	Creates the maximum filter.
Ptr< Filter >	createBoxMinFilter (int srcType, Size ksize, Point anchor=Point(-1, -1), int borderMode=BORDER_DEFAULT, Scalar borderVal=Scalar::all(0))
	Creates the minimum filter.
Ptr< CannyEdgeDetector >	createCannyEdgeDetector (double low_thresh, double high_thresh, int apperture_size=3, bool L2gradient=false)
	Creates implementation for cuda::CannyEdgeDetector .
Ptr< cuda::CLAHE >	createCLAHE (double clipLimit=40.0, Size tileGridSize=Size(8, 8))
	Creates implementation for cuda::CLAHE .
Ptr< Filter >	createColumnSumFilter (int srcType, int dstType, int ksize, int anchor=-1, int borderMode=BORDER_DEFAULT, Scalar borderVal=Scalar::all(0))
	Creates a vertical 1D box filter.
void	createContinuous (int rows, int cols, int type, OutputArray arr)
	Creates a continuous matrix.
Ptr< Convolution >	createConvolution (Size user_block_size=Size())
	Creates implementation for cuda::Convolution .
Ptr< Filter >	createDerivFilter (int srcType, int dstType, int dx, int dy, int ksize, bool normalize=false, double scale=1, int rowBorderMode=BORDER_DEFAULT, int columnBorderMode=-1)
	Creates a generalized Deriv operator.
Ptr< DFT >	createDFT (Size dft_size, int flags)
	Creates implementation for cuda::DFT.
Ptr< cuda::DisparityBilateralFilter >	createDisparityBilateralFilter (int ndisp=64, int radius=3, int iters=1)
	Creates DisparityBilateralFilter object.
Ptr< Filter >	createGaussianFilter (int srcType, int dstType, Size ksize, double sigma1, double sigma2=0, int rowBorderMode=BORDER_DEFAULT, int columnBorderMode=-1)
	Creates a Gaussian filter.
Ptr< GeneralizedHoughBallard >	createGeneralizedHoughBallard ()
	Creates implementation for generalized hough transform from [15] .
Ptr< GeneralizedHoughGuil >	createGeneralizedHoughGuil ()
	Creates implementation for generalized hough transform from [114] .
Ptr< CornersDetector >	createGoodFeaturesToTrackDetector (int srcType, int maxCorners=1000, double qualityLevel=0.01, double minDistance=0.0, int blockSize=3, bool useHarrisDetector=false, double harrisK=0.04)
	Creates implementation for cuda::CornersDetector .
GpuMat	createGpuMatFromCudaMemory (int rows, int cols, int type, size_t cudaMemoryAddress, size_t step=Mat::AUTO_STEP)
	Bindings overload to create a GpuMat from existing GPU memory.
GpuMat	createGpuMatFromCudaMemory (Size size, int type, size_t cudaMemoryAddress, size_t step=Mat::AUTO_STEP)
Ptr< CornernessCriteria >	createHarrisCorner (int srcType, int blockSize, int ksize, double k, int borderType=BORDER_REFLECT101)
	Creates implementation for Harris cornerness criteria.
Ptr< HoughCirclesDetector >	createHoughCirclesDetector (float dp, float minDist, int cannyThreshold, int votesThreshold, int minRadius, int maxRadius, int maxCircles=4096)
	Creates implementation for cuda::HoughCirclesDetector .
Ptr< HoughLinesDetector >	createHoughLinesDetector (float rho, float theta, int threshold, bool doSort=false, int maxLines=4096)
	Creates implementation for cuda::HoughLinesDetector .
Ptr< HoughSegmentDetector >	createHoughSegmentDetector (float rho, float theta, int minLineLength, int maxLineGap, int maxLines=4096, int threshold=-1)
	Creates implementation for cuda::HoughSegmentDetector .
Ptr< ImagePyramid >	createImagePyramid (InputArray img, int nLayers=-1, Stream &stream=Stream::Null())
Ptr< Filter >	createLaplacianFilter (int srcType, int dstType, int ksize=1, double scale=1, int borderMode=BORDER_DEFAULT, Scalar borderVal=Scalar::all(0))
	Creates a Laplacian operator.
Ptr< Filter >	createLinearFilter (int srcType, int dstType, InputArray kernel, Point anchor=Point(-1, -1), int borderMode=BORDER_DEFAULT, Scalar borderVal=Scalar::all(0))
	Creates a non-separable linear 2D filter.
Ptr< LookUpTable >	createLookUpTable (InputArray lut)
	Creates implementation for cuda::LookUpTable .
Ptr< Filter >	createMedianFilter (int srcType, int windowSize, int partition=128)
	Performs median filtering for each point of the source image.
Ptr< CornernessCriteria >	createMinEigenValCorner (int srcType, int blockSize, int ksize, int borderType=BORDER_REFLECT101)
	Creates implementation for the minimum eigen value of a 2x2 derivative covariation matrix (the cornerness criteria).
Ptr< Filter >	createMorphologyFilter (int op, int srcType, InputArray kernel, Point anchor=Point(-1, -1), int iterations=1)
	Creates a 2D morphological filter.
void	createOpticalFlowNeedleMap (const GpuMat &u, const GpuMat &v, GpuMat &vertex, GpuMat &colors)
Ptr< Filter >	createRowSumFilter (int srcType, int dstType, int ksize, int anchor=-1, int borderMode=BORDER_DEFAULT, Scalar borderVal=Scalar::all(0))
	Creates a horizontal 1D box filter.
Ptr< Filter >	createScharrFilter (int srcType, int dstType, int dx, int dy, double scale=1, int rowBorderMode=BORDER_DEFAULT, int columnBorderMode=-1)
	Creates a vertical or horizontal Scharr operator.
Ptr< Filter >	createSeparableLinearFilter (int srcType, int dstType, InputArray rowKernel, InputArray columnKernel, Point anchor=Point(-1,-1), int rowBorderMode=BORDER_DEFAULT, int columnBorderMode=-1)
	Creates a separable linear filter.
Ptr< Filter >	createSobelFilter (int srcType, int dstType, int dx, int dy, int ksize=3, double scale=1, int rowBorderMode=BORDER_DEFAULT, int columnBorderMode=-1)
	Creates a Sobel operator.
Ptr< cuda::StereoBeliefPropagation >	createStereoBeliefPropagation (int ndisp=64, int iters=5, int levels=5, int msg_type=CV_32F)
	Creates StereoBeliefPropagation object.
Ptr< cuda::StereoBM >	createStereoBM (int numDisparities=64, int blockSize=19)
	Creates StereoBM object.
Ptr< cuda::StereoConstantSpaceBP >	createStereoConstantSpaceBP (int ndisp=128, int iters=8, int levels=4, int nr_plane=4, int msg_type=CV_32F)
	Creates StereoConstantSpaceBP object.
Ptr< cuda::StereoSGM >	createStereoSGM (int minDisparity=0, int numDisparities=128, int P1=10, int P2=120, int uniquenessRatio=5, int mode=cv::cuda::StereoSGM::MODE_HH4)
	Creates StereoSGM object.
Ptr< TemplateMatching >	createTemplateMatching (int srcType, int method, Size user_block_size=Size())
	Creates implementation for cuda::TemplateMatching .
void	cvtColor (InputArray src, OutputArray dst, int code, int dcn=0, Stream &stream=Stream::Null())
	Converts an image from one color space to another.
void	demosaicing (InputArray src, OutputArray dst, int code, int dcn=-1, Stream &stream=Stream::Null())
	Converts an image from Bayer pattern to RGB or grayscale.
bool	deviceSupports (FeatureSet feature_set)
	checks whether current device supports the given feature
void	dft (InputArray src, OutputArray dst, Size dft_size, int flags=0, Stream &stream=Stream::Null())
	Performs a forward or inverse discrete Fourier transform (1D or 2D) of the floating point matrix.
void	divide (InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1, Stream &stream=Stream::Null())
	Computes a matrix-matrix or matrix-scalar division.
void	drawColorDisp (InputArray src_disp, OutputArray dst_disp, int ndisp, Stream &stream=Stream::Null())
	Colors a disparity image.
void	ensureSizeIsEnough (int rows, int cols, int type, OutputArray arr)
	Ensures that the size of a matrix is big enough and the matrix has a proper type.
void	equalizeHist (InputArray src, OutputArray dst, Stream &stream=Stream::Null())
	Equalizes the histogram of a grayscale image.
void	evenLevels (OutputArray levels, int nLevels, int lowerLevel, int upperLevel, Stream &stream=Stream::Null())
	Computes levels with even distribution.
void	exp (InputArray src, OutputArray dst, Stream &stream=Stream::Null())
	Computes an exponent of each matrix element.
void	fastNlMeansDenoising (const GpuMat &src, GpuMat &dst, float h, int search_window=21, int block_size=7, Stream &stream=Stream::Null())
void	fastNlMeansDenoising (InputArray src, OutputArray dst, float h, int search_window=21, int block_size=7, Stream &stream=Stream::Null())
	Perform image denoising using Non-local Means Denoising algorithm http://www.ipol.im/pub/algo/bcm_non_local_means_denoising with several computational optimizations. Noise expected to be a gaussian white noise.
void	fastNlMeansDenoisingColored (const GpuMat &src, GpuMat &dst, float h_luminance, float photo_render, int search_window=21, int block_size=7, Stream &stream=Stream::Null())
void	fastNlMeansDenoisingColored (InputArray src, OutputArray dst, float h_luminance, float photo_render, int search_window=21, int block_size=7, Stream &stream=Stream::Null())
	Modification of fastNlMeansDenoising function for colored images.
void	findMinMax (InputArray src, OutputArray dst, InputArray mask=noArray(), Stream &stream=Stream::Null())
void	findMinMaxLoc (InputArray src, OutputArray minMaxVals, OutputArray loc, InputArray mask=noArray(), Stream &stream=Stream::Null())
void	flip (InputArray src, OutputArray dst, int flipCode, Stream &stream=Stream::Null())
	Flips a 2D matrix around vertical, horizontal, or both axes.
void	gammaCorrection (InputArray src, OutputArray dst, bool forward=true, Stream &stream=Stream::Null())
	Routines for correcting image color gamma.
void	gemm (InputArray src1, InputArray src2, double alpha, InputArray src3, double beta, OutputArray dst, int flags=0, Stream &stream=Stream::Null())
	Performs generalized matrix multiplication.
int	getCudaEnabledDeviceCount ()
	Returns the number of installed CUDA-enabled devices.
int	getDevice ()
	Returns the current device index set by cuda::setDevice or initialized by default.
void	graphcut (GpuMat &terminals, GpuMat &leftTransp, GpuMat &rightTransp, GpuMat &top, GpuMat &bottom, GpuMat &labels, GpuMat &buf, Stream &stream=Stream::Null())
	performs labeling via graph cuts of a 2D regular 4-connected graph.
void	graphcut (GpuMat &terminals, GpuMat &leftTransp, GpuMat &rightTransp, GpuMat &top, GpuMat &topLeft, GpuMat &topRight, GpuMat &bottom, GpuMat &bottomLeft, GpuMat &bottomRight, GpuMat &labels, GpuMat &buf, Stream &stream=Stream::Null())
	performs labeling via graph cuts of a 2D regular 8-connected graph.
void	histEven (InputArray src, GpuMat hist[4], int histSize[4], int lowerLevel[4], int upperLevel[4], Stream &stream=Stream::Null())
void	histEven (InputArray src, OutputArray hist, int histSize, int lowerLevel, int upperLevel, Stream &stream=Stream::Null())
	Calculates a histogram with evenly distributed bins.
void	histRange (InputArray src, GpuMat hist[4], const GpuMat levels[4], Stream &stream=Stream::Null())
void	histRange (InputArray src, OutputArray hist, InputArray levels, Stream &stream=Stream::Null())
	Calculates a histogram with bins determined by the levels array.
void	inRange (InputArray src, const Scalar &lowerb, const Scalar &upperb, OutputArray dst, Stream &stream=Stream::Null())
	Checks if array elements lie between two scalars.
void	integral (InputArray src, OutputArray sum, Stream &stream=Stream::Null())
	Computes an integral image.
void	interpolateFrames (const GpuMat &frame0, const GpuMat &frame1, const GpuMat &fu, const GpuMat &fv, const GpuMat &bu, const GpuMat &bv, float pos, GpuMat &newFrame, GpuMat &buf, Stream &stream=Stream::Null())
	Interpolates frames (images) using provided optical flow (displacement field).
void	labelComponents (const GpuMat &mask, GpuMat &components, int flags=0, Stream &stream=Stream::Null())
	performs connected componnents labeling.
void	log (InputArray src, OutputArray dst, Stream &stream=Stream::Null())
	Computes a natural logarithm of absolute value of each matrix element.
void	lshift (InputArray src, Scalar val, OutputArray dst, Stream &stream=Stream::Null())
void	lshift (InputArray src, Scalar_< int > val, OutputArray dst, Stream &stream=Stream::Null())
	Performs pixel by pixel right left of an image by a constant value.
void	magnitude (InputArray x, InputArray y, OutputArray magnitude, Stream &stream=Stream::Null())
void	magnitude (InputArray xy, OutputArray magnitude, Stream &stream=Stream::Null())
	Computes magnitudes of complex matrix elements.
void	magnitudeSqr (InputArray x, InputArray y, OutputArray magnitude, Stream &stream=Stream::Null())
void	magnitudeSqr (InputArray xy, OutputArray magnitude, Stream &stream=Stream::Null())
	Computes squared magnitudes of complex matrix elements.
void	max (InputArray src1, InputArray src2, OutputArray dst, Stream &stream=Stream::Null())
	Computes the per-element maximum of two matrices (or a matrix and a scalar).
void	meanShiftFiltering (InputArray src, OutputArray dst, int sp, int sr, TermCriteria criteria=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 5, 1), Stream &stream=Stream::Null())
	Performs mean-shift filtering for each point of the source image.
void	meanShiftProc (InputArray src, OutputArray dstr, OutputArray dstsp, int sp, int sr, TermCriteria criteria=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 5, 1), Stream &stream=Stream::Null())
	Performs a mean-shift procedure and stores information about processed points (their colors and positions) in two images.
void	meanShiftSegmentation (InputArray src, OutputArray dst, int sp, int sr, int minsize, TermCriteria criteria=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 5, 1), Stream &stream=Stream::Null())
	Performs a mean-shift segmentation of the source image and eliminates small segments.
void	meanStdDev (InputArray mtx, OutputArray dst, Stream &stream=Stream::Null())
void	meanStdDev (InputArray mtx, Scalar &mean, Scalar &stddev)
void	meanStdDev (InputArray src, OutputArray dst, InputArray mask, Stream &stream=Stream::Null())
	Computes a mean value and a standard deviation of matrix elements.
void	meanStdDev (InputArray src, Scalar &mean, Scalar &stddev, InputArray mask)
void	merge (const GpuMat *src, size_t n, OutputArray dst, Stream &stream=Stream::Null())
	Makes a multi-channel matrix out of several single-channel matrices.
void	merge (const std::vector< GpuMat > &src, OutputArray dst, Stream &stream=Stream::Null())
void	min (InputArray src1, InputArray src2, OutputArray dst, Stream &stream=Stream::Null())
	Computes the per-element minimum of two matrices (or a matrix and a scalar).
void	minMax (InputArray src, double *minVal, double *maxVal, InputArray mask=noArray())
	Finds global minimum and maximum matrix elements and returns their values.
void	minMaxLoc (InputArray src, double *minVal, double *maxVal, Point *minLoc, Point *maxLoc, InputArray mask=noArray())
	Finds global minimum and maximum matrix elements and returns their values with locations.
Moments	moments (InputArray src, const bool binaryImage=false, const MomentsOrder order=MomentsOrder::THIRD_ORDER_MOMENTS, const int momentsType=CV_64F)
	Calculates all of the moments up to the 3rd order of a rasterized shape.
void	mulAndScaleSpectrums (InputArray src1, InputArray src2, OutputArray dst, int flags, float scale, bool conjB=false, Stream &stream=Stream::Null())
	Performs a per-element multiplication of two Fourier spectrums and scales the result.
void	mulSpectrums (InputArray src1, InputArray src2, OutputArray dst, int flags, bool conjB=false, Stream &stream=Stream::Null())
	Performs a per-element multiplication of two Fourier spectrums.
void	multiply (InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1, Stream &stream=Stream::Null())
	Computes a matrix-matrix or matrix-scalar per-element product.
void	nonLocalMeans (const GpuMat &src, GpuMat &dst, float h, int search_window=21, int block_size=7, int borderMode=BORDER_DEFAULT, Stream &stream=Stream::Null())
void	nonLocalMeans (InputArray src, OutputArray dst, float h, int search_window=21, int block_size=7, int borderMode=BORDER_DEFAULT, Stream &stream=Stream::Null())
	Performs pure non local means denoising without any simplification, and thus it is not fast.
double	norm (InputArray src1, InputArray src2, int normType=NORM_L2)
	Returns the difference of two matrices.
double	norm (InputArray src1, int normType, InputArray mask=noArray())
	Returns the norm of a matrix (or difference of two matrices).
void	normalize (InputArray src, OutputArray dst, double alpha, double beta, int norm_type, int dtype, InputArray mask=noArray(), Stream &stream=Stream::Null())
	Normalizes the norm or value range of an array.
int	numMoments (const MomentsOrder order)
	Returns the number of image moments less than or equal to the largest image moments order.
void	phase (InputArray x, InputArray y, OutputArray angle, bool angleInDegrees=false, Stream &stream=Stream::Null())
	Computes polar angles of complex matrix elements.
void	polarToCart (InputArray magnitude, InputArray angle, OutputArray x, OutputArray y, bool angleInDegrees=false, Stream &stream=Stream::Null())
	Converts polar coordinates into Cartesian.
void	pow (InputArray src, double power, OutputArray dst, Stream &stream=Stream::Null())
	Raises every matrix element to a power.
void	printCudaDeviceInfo (int device)
void	printShortCudaDeviceInfo (int device)
void	projectPoints (const GpuMat &src, const Mat &rvec, const Mat &tvec, const Mat &camera_mat, const Mat &dist_coef, GpuMat &dst, Stream &stream=Stream::Null())
void	pyrDown (InputArray src, OutputArray dst, Stream &stream=Stream::Null())
	Smoothes an image and downsamples it.
void	pyrUp (InputArray src, OutputArray dst, Stream &stream=Stream::Null())
	Upsamples an image and then smoothes it.
void	rectStdDev (InputArray src, InputArray sqr, OutputArray dst, Rect rect, Stream &stream=Stream::Null())
	Computes a standard deviation of integral images.
void	reduce (InputArray mtx, OutputArray vec, int dim, int reduceOp, int dtype=-1, Stream &stream=Stream::Null())
	Reduces a matrix to a vector.
void	registerPageLocked (Mat &m)
	Page-locks the memory of matrix and maps it for the device(s).
void	remap (InputArray src, OutputArray dst, InputArray xmap, InputArray ymap, int interpolation, int borderMode=BORDER_CONSTANT, Scalar borderValue=Scalar(), Stream &stream=Stream::Null())
	Applies a generic geometrical transformation to an image.
void	reprojectImageTo3D (GpuMat disp, GpuMat &xyzw, Mat Q, int dst_cn=4, Stream &stream=Stream::Null())
void	reprojectImageTo3D (InputArray disp, OutputArray xyzw, InputArray Q, int dst_cn=4, Stream &stream=Stream::Null())
	Reprojects a disparity image to 3D space.
void	resetDevice ()
	Explicitly destroys and cleans up all resources associated with the current device in the current process.
void	resize (InputArray src, OutputArray dst, Size dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR, Stream &stream=Stream::Null())
	Resizes an image.
void	rotate (InputArray src, OutputArray dst, Size dsize, double angle, double xShift=0, double yShift=0, int interpolation=INTER_LINEAR, Stream &stream=Stream::Null())
	Rotates an image around the origin (0,0) and then shifts it.
void	rshift (InputArray src, Scalar val, OutputArray dst, Stream &stream=Stream::Null())
void	rshift (InputArray src, Scalar_< int > val, OutputArray dst, Stream &stream=Stream::Null())
	Performs pixel by pixel right shift of an image by a constant value.
static void	scaleAdd (InputArray src1, double alpha, InputArray src2, OutputArray dst, Stream &stream=Stream::Null())
	adds scaled array to another one (dst = alpha*src1 + src2)
void	setBufferPoolConfig (int deviceId, size_t stackSize, int stackCount)
void	setBufferPoolUsage (bool on)
	BufferPool management (must be called before Stream creation)
void	setDevice (int device)
	Sets a device and initializes it for the current thread.
void	setGlDevice (int device=0)
	Sets a CUDA device and initializes it for the current thread with OpenGL interoperability.
void	solvePnPRansac (const Mat &object, const Mat &image, const Mat &camera_mat, const Mat &dist_coef, Mat &rvec, Mat &tvec, bool use_extrinsic_guess=false, int num_iters=100, float max_dist=8.0, int min_inlier_count=100, std::vector< int > *inliers=NULL)
	Finds the object pose from 3D-2D point correspondences.
void	spatialMoments (InputArray src, OutputArray moments, const bool binaryImage=false, const MomentsOrder order=MomentsOrder::THIRD_ORDER_MOMENTS, const int momentsType=CV_64F, Stream &stream=Stream::Null())
	Calculates all of the spatial moments up to the 3rd order of a rasterized shape.
void	split (InputArray src, GpuMat *dst, Stream &stream=Stream::Null())
	Copies each plane of a multi-channel matrix into an array.
void	split (InputArray src, std::vector< GpuMat > &dst, Stream &stream=Stream::Null())
void	sqr (InputArray src, OutputArray dst, Stream &stream=Stream::Null())
	Computes a square value of each matrix element.
void	sqrIntegral (InputArray src, OutputArray sqsum, Stream &stream=Stream::Null())
	Computes a squared integral image.
Scalar	sqrSum (InputArray src, InputArray mask=noArray())
	Returns the squared sum of matrix elements.
void	sqrt (InputArray src, OutputArray dst, Stream &stream=Stream::Null())
	Computes a square root of each matrix element.
void	subtract (InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1, Stream &stream=Stream::Null())
	Computes a matrix-matrix or matrix-scalar difference.
Scalar	sum (InputArray src, InputArray mask=noArray())
	Returns the sum of matrix elements.
void	swapChannels (InputOutputArray image, const int dstOrder[4], Stream &stream=Stream::Null())
	Exchanges the color channels of an image in-place.
double	threshold (InputArray src, OutputArray dst, double thresh, double maxval, int type, Stream &stream=Stream::Null())
	Applies a fixed-level threshold to each array element.
void	transformPoints (const GpuMat &src, const Mat &rvec, const Mat &tvec, GpuMat &dst, Stream &stream=Stream::Null())
void	transpose (InputArray src1, OutputArray dst, Stream &stream=Stream::Null())
	Transposes a matrix.
void	unregisterPageLocked (Mat &m)
	Unmaps the memory of matrix and makes it pageable again.
void	warpAffine (InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, Scalar borderValue=Scalar(), Stream &stream=Stream::Null())
	Applies an affine transformation to an image.
void	warpAffine (InputArray src, OutputArray dst, Mat M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, Scalar borderValue=Scalar(), Stream &stream=Stream::Null())
void	warpAffine (InputArray src, OutputArray dst, UMat M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, Scalar borderValue=Scalar(), Stream &stream=Stream::Null())
void	warpPerspective (InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, Scalar borderValue=Scalar(), Stream &stream=Stream::Null())
	Applies a perspective transformation to an image.
void	warpPerspective (InputArray src, OutputArray dst, Mat M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, Scalar borderValue=Scalar(), Stream &stream=Stream::Null())
void	warpPerspective (InputArray src, OutputArray dst, UMat M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, Scalar borderValue=Scalar(), Stream &stream=Stream::Null())
Stream	wrapStream (size_t cudaStreamMemoryAddress)
	Bindings overload to create a Stream object from the address stored in an existing CUDA Runtime API stream pointer (cudaStream_t).

Function Documentation

createMedianFilter()

Ptr< Filter > cv::cuda::createMedianFilter	(	int	srcType,
		int	windowSize,
		int	partition = 128
	)

Performs median filtering for each point of the source image.

Parameters

srcType	type of of source image. Only CV_8UC1 images are supported for now.
windowSize	Size of the kernerl used for the filtering. Uses a (windowSize x windowSize) filter.
partition	Specifies the parallel granularity of the workload. This parameter should be used GPU experts when optimizing performance.

Outputs an image that has been filtered using a median-filtering formulation.

Details on this algorithm can be found in: Green, O., 2017. "Efficient scalable median filtering using histogram-based operations", IEEE Transactions on Image Processing, 27(5), pp.2217-2228.