cv::gpu Namespace Reference

Namespaces
	detail
	device

Classes
class	BaseColumnFilter_GPU
class	BaseFilter_GPU
class	BaseRowFilter_GPU
class	BFMatcher_GPU
class	BroxOpticalFlow
class	BruteForceMatcher_GPU
class	BruteForceMatcher_GPU< Hamming >
class	BruteForceMatcher_GPU< L1< T > >
class	BruteForceMatcher_GPU< L2< T > >
class	BruteForceMatcher_GPU_base
struct	CannyBuf
class	CascadeClassifier_GPU
class	CLAHE
struct	ConvolveBuf
class	CudaMem
class	DeviceInfo
struct	DevMem2D_
struct	DevPtr
class	DisparityBilateralFilter
class	FarnebackOpticalFlow
class	FAST_GPU
class	FastNonLocalMeansDenoising
	Fast (but approximate)version of non-local means algorith similar to CPU function (running sums technique) More...
class	FastOpticalFlowBM
class	FGDStatModel
class	FilterEngine_GPU
class	GeneralizedHough_GPU
class	GMG_GPU
class	GoodFeaturesToTrackDetector_GPU
class	GpuMat
	Smart pointer for GPU memory with reference counting. Its interface is mostly similar with cv::Mat. More...
struct	HOGConfidence
struct	HOGDescriptor
struct	HoughCirclesBuf
	HoughCircles. More...
struct	HoughLinesBuf
	HoughLines. More...
class	ImagePyramid
struct	MatchTemplateBuf
class	MOG2_GPU
class	MOG_GPU
class	OpticalFlowDual_TVL1_GPU
class	ORB_GPU
struct	PtrElemStep_
struct	PtrStep
struct	PtrStep_
struct	PtrStepSz
struct	PtrSz
class	PyrLKOpticalFlow
struct	StaticAssert
struct	StaticAssert< true >
class	StereoBeliefPropagation
class	StereoBM_GPU
class	StereoConstantSpaceBP
class	Stream
struct	StreamAccessor
class	SURF_GPU
class	TargetArchs
class	VideoReader_GPU
class	VideoWriter_GPU

Typedefs
typedef PtrStepSz< unsigned char >	PtrStepSzb
typedef PtrStepSz< float >	PtrStepSzf
typedef PtrStepSz< int >	PtrStepSzi
typedef PtrStep< unsigned char >	PtrStepb
typedef PtrStep< float >	PtrStepf
typedef PtrStep< int >	PtrStepi
typedef DevMem2D_< unsigned char >	DevMem2Db
typedef DevMem2Db	DevMem2D
typedef DevMem2D_< float >	DevMem2Df
typedef DevMem2D_< int >	DevMem2Di
typedef PtrElemStep_< unsigned char >	PtrElemStep
typedef PtrElemStep_< float >	PtrElemStepf
typedef PtrElemStep_< int >	PtrElemStepi

Enumerations
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_35 = 35,   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 }
enum	{   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	{   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 }

Functions
void	setGlDevice (int device=0)
	set a CUDA device to use OpenGL interoperability More...
int	getCudaEnabledDeviceCount ()
	This is the only function that do not throw exceptions if the library is compiled without Cuda. More...
void	setDevice (int device)
	Functions below throw cv::Expception if the library is compiled without Cuda. More...
int	getDevice ()
void	resetDevice ()
bool	deviceSupports (FeatureSet feature_set)
void	printCudaDeviceInfo (int device)
void	printShortCudaDeviceInfo (int device)
void	createContinuous (int rows, int cols, int type, GpuMat &m)
	Creates continuous GPU matrix. More...
GpuMat	createContinuous (int rows, int cols, int type)
void	createContinuous (Size size, int type, GpuMat &m)
GpuMat	createContinuous (Size size, int type)
void	ensureSizeIsEnough (int rows, int cols, int type, GpuMat &m)
void	ensureSizeIsEnough (Size size, int type, GpuMat &m)
GpuMat	allocMatFromBuf (int rows, int cols, int type, GpuMat &mat)
void	error (const char *error_string, const char *file, const int line, const char *func="")
void	swap (GpuMat &a, GpuMat &b)
void	registerPageLocked (Mat &m)
void	unregisterPageLocked (Mat &m)
Ptr< FilterEngine_GPU >	createFilter2D_GPU (const Ptr< BaseFilter_GPU > &filter2D, int srcType, int dstType)
	returns the non-separable filter engine with the specified filter More...
Ptr< FilterEngine_GPU >	createSeparableFilter_GPU (const Ptr< BaseRowFilter_GPU > &rowFilter, const Ptr< BaseColumnFilter_GPU > &columnFilter, int srcType, int bufType, int dstType)
	returns the separable filter engine with the specified filters More...
Ptr< FilterEngine_GPU >	createSeparableFilter_GPU (const Ptr< BaseRowFilter_GPU > &rowFilter, const Ptr< BaseColumnFilter_GPU > &columnFilter, int srcType, int bufType, int dstType, GpuMat &buf)
Ptr< BaseRowFilter_GPU >	getRowSumFilter_GPU (int srcType, int sumType, int ksize, int anchor=-1)
Ptr< BaseColumnFilter_GPU >	getColumnSumFilter_GPU (int sumType, int dstType, int ksize, int anchor=-1)
Ptr< BaseFilter_GPU >	getBoxFilter_GPU (int srcType, int dstType, const Size &ksize, Point anchor=Point(-1, -1))
Ptr< FilterEngine_GPU >	createBoxFilter_GPU (int srcType, int dstType, const Size &ksize, const Point &anchor=Point(-1,-1))
	returns box filter engine More...
Ptr< BaseFilter_GPU >	getMorphologyFilter_GPU (int op, int type, const Mat &kernel, const Size &ksize, Point anchor=Point(-1,-1))
Ptr< FilterEngine_GPU >	createMorphologyFilter_GPU (int op, int type, const Mat &kernel, const Point &anchor=Point(-1,-1), int iterations=1)
	returns morphological filter engine. Only MORPH_ERODE and MORPH_DILATE are supported. More...
Ptr< FilterEngine_GPU >	createMorphologyFilter_GPU (int op, int type, const Mat &kernel, GpuMat &buf, const Point &anchor=Point(-1,-1), int iterations=1)
Ptr< BaseFilter_GPU >	getLinearFilter_GPU (int srcType, int dstType, const Mat &kernel, Point anchor=Point(-1, -1), int borderType=BORDER_DEFAULT)
Ptr< FilterEngine_GPU >	createLinearFilter_GPU (int srcType, int dstType, const Mat &kernel, Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT)
	returns the non-separable linear filter engine More...
Ptr< BaseRowFilter_GPU >	getLinearRowFilter_GPU (int srcType, int bufType, const Mat &rowKernel, int anchor=-1, int borderType=BORDER_DEFAULT)
Ptr< BaseColumnFilter_GPU >	getLinearColumnFilter_GPU (int bufType, int dstType, const Mat &columnKernel, int anchor=-1, int borderType=BORDER_DEFAULT)
Ptr< FilterEngine_GPU >	createSeparableLinearFilter_GPU (int srcType, int dstType, const Mat &rowKernel, const Mat &columnKernel, const Point &anchor=Point(-1,-1), int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1)
	returns the separable linear filter engine More...
Ptr< FilterEngine_GPU >	createSeparableLinearFilter_GPU (int srcType, int dstType, const Mat &rowKernel, const Mat &columnKernel, GpuMat &buf, const Point &anchor=Point(-1,-1), int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1)
Ptr< FilterEngine_GPU >	createDerivFilter_GPU (int srcType, int dstType, int dx, int dy, int ksize, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1)
	returns filter engine for the generalized Sobel operator More...
Ptr< FilterEngine_GPU >	createDerivFilter_GPU (int srcType, int dstType, int dx, int dy, int ksize, GpuMat &buf, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1)
Ptr< FilterEngine_GPU >	createGaussianFilter_GPU (int type, Size ksize, double sigma1, double sigma2=0, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1)
	returns the Gaussian filter engine More...
Ptr< FilterEngine_GPU >	createGaussianFilter_GPU (int type, Size ksize, GpuMat &buf, double sigma1, double sigma2=0, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1)
Ptr< BaseFilter_GPU >	getMaxFilter_GPU (int srcType, int dstType, const Size &ksize, Point anchor=Point(-1,-1))
	returns maximum filter More...
Ptr< BaseFilter_GPU >	getMinFilter_GPU (int srcType, int dstType, const Size &ksize, Point anchor=Point(-1,-1))
	returns minimum filter More...
void	boxFilter (const GpuMat &src, GpuMat &dst, int ddepth, Size ksize, Point anchor=Point(-1,-1), Stream &stream=Stream::Null())
void	erode (const GpuMat &src, GpuMat &dst, const Mat &kernel, Point anchor=Point(-1, -1), int iterations=1)
	erodes the image (applies the local minimum operator) More...
void	erode (const GpuMat &src, GpuMat &dst, const Mat &kernel, GpuMat &buf, Point anchor=Point(-1, -1), int iterations=1, Stream &stream=Stream::Null())
void	dilate (const GpuMat &src, GpuMat &dst, const Mat &kernel, Point anchor=Point(-1, -1), int iterations=1)
	dilates the image (applies the local maximum operator) More...
void	dilate (const GpuMat &src, GpuMat &dst, const Mat &kernel, GpuMat &buf, Point anchor=Point(-1, -1), int iterations=1, Stream &stream=Stream::Null())
void	morphologyEx (const GpuMat &src, GpuMat &dst, int op, const Mat &kernel, Point anchor=Point(-1, -1), int iterations=1)
	applies an advanced morphological operation to the image More...
void	morphologyEx (const GpuMat &src, GpuMat &dst, int op, const Mat &kernel, GpuMat &buf1, GpuMat &buf2, Point anchor=Point(-1, -1), int iterations=1, Stream &stream=Stream::Null())
void	filter2D (const GpuMat &src, GpuMat &dst, int ddepth, const Mat &kernel, Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT, Stream &stream=Stream::Null())
	applies non-separable 2D linear filter to the image More...
void	sepFilter2D (const GpuMat &src, GpuMat &dst, int ddepth, const Mat &kernelX, const Mat &kernelY, Point anchor=Point(-1,-1), int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1)
	applies separable 2D linear filter to the image More...
void	sepFilter2D (const GpuMat &src, GpuMat &dst, int ddepth, const Mat &kernelX, const Mat &kernelY, GpuMat &buf, Point anchor=Point(-1,-1), int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1, Stream &stream=Stream::Null())
void	Sobel (const GpuMat &src, GpuMat &dst, int ddepth, int dx, int dy, int ksize=3, double scale=1, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1)
	applies generalized Sobel operator to the image More...
void	Sobel (const GpuMat &src, GpuMat &dst, int ddepth, int dx, int dy, GpuMat &buf, int ksize=3, double scale=1, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1, Stream &stream=Stream::Null())
void	Scharr (const GpuMat &src, GpuMat &dst, int ddepth, int dx, int dy, double scale=1, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1)
	applies the vertical or horizontal Scharr operator to the image More...
void	Scharr (const GpuMat &src, GpuMat &dst, int ddepth, int dx, int dy, GpuMat &buf, double scale=1, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1, Stream &stream=Stream::Null())
void	GaussianBlur (const GpuMat &src, GpuMat &dst, Size ksize, double sigma1, double sigma2=0, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1)
	smooths the image using Gaussian filter. More...
void	GaussianBlur (const GpuMat &src, GpuMat &dst, Size ksize, GpuMat &buf, double sigma1, double sigma2=0, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1, Stream &stream=Stream::Null())
void	Laplacian (const GpuMat &src, GpuMat &dst, int ddepth, int ksize=1, double scale=1, int borderType=BORDER_DEFAULT, Stream &stream=Stream::Null())
void	gemm (const GpuMat &src1, const GpuMat &src2, double alpha, const GpuMat &src3, double beta, GpuMat &dst, int flags=0, Stream &stream=Stream::Null())
	implements generalized matrix product algorithm GEMM from BLAS More...
void	transpose (const GpuMat &src1, GpuMat &dst, Stream &stream=Stream::Null())
void	flip (const GpuMat &a, GpuMat &b, int flipCode, Stream &stream=Stream::Null())
void	LUT (const GpuMat &src, const Mat &lut, GpuMat &dst, Stream &stream=Stream::Null())
void	merge (const GpuMat *src, size_t n, GpuMat &dst, Stream &stream=Stream::Null())
	makes multi-channel array out of several single-channel arrays More...
void	merge (const std::vector< GpuMat > &src, GpuMat &dst, Stream &stream=Stream::Null())
	makes multi-channel array out of several single-channel arrays More...
void	split (const GpuMat &src, GpuMat *dst, Stream &stream=Stream::Null())
	copies each plane of a multi-channel array to a dedicated array More...
void	split (const GpuMat &src, std::vector< GpuMat > &dst, Stream &stream=Stream::Null())
	copies each plane of a multi-channel array to a dedicated array More...
void	magnitude (const GpuMat &xy, GpuMat &magnitude, Stream &stream=Stream::Null())
void	magnitudeSqr (const GpuMat &xy, GpuMat &magnitude, Stream &stream=Stream::Null())
void	magnitude (const GpuMat &x, const GpuMat &y, GpuMat &magnitude, Stream &stream=Stream::Null())
void	magnitudeSqr (const GpuMat &x, const GpuMat &y, GpuMat &magnitude, Stream &stream=Stream::Null())
void	phase (const GpuMat &x, const GpuMat &y, GpuMat &angle, bool angleInDegrees=false, Stream &stream=Stream::Null())
void	cartToPolar (const GpuMat &x, const GpuMat &y, GpuMat &magnitude, GpuMat &angle, bool angleInDegrees=false, Stream &stream=Stream::Null())
void	polarToCart (const GpuMat &magnitude, const GpuMat &angle, GpuMat &x, GpuMat &y, bool angleInDegrees=false, Stream &stream=Stream::Null())
void	normalize (const GpuMat &src, GpuMat &dst, double alpha=1, double beta=0, int norm_type=NORM_L2, int dtype=-1, const GpuMat &mask=GpuMat())
	scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values More...
void	normalize (const GpuMat &src, GpuMat &dst, double a, double b, int norm_type, int dtype, const GpuMat &mask, GpuMat &norm_buf, GpuMat &cvt_buf)
void	add (const GpuMat &a, const GpuMat &b, GpuMat &c, const GpuMat &mask=GpuMat(), int dtype=-1, Stream &stream=Stream::Null())
	adds one matrix to another (c = a + b) More...
void	add (const GpuMat &a, const Scalar &sc, GpuMat &c, const GpuMat &mask=GpuMat(), int dtype=-1, Stream &stream=Stream::Null())
	adds scalar to a matrix (c = a + s) More...
void	subtract (const GpuMat &a, const GpuMat &b, GpuMat &c, const GpuMat &mask=GpuMat(), int dtype=-1, Stream &stream=Stream::Null())
	subtracts one matrix from another (c = a - b) More...
void	subtract (const GpuMat &a, const Scalar &sc, GpuMat &c, const GpuMat &mask=GpuMat(), int dtype=-1, Stream &stream=Stream::Null())
	subtracts scalar from a matrix (c = a - s) More...
void	multiply (const GpuMat &a, const GpuMat &b, GpuMat &c, double scale=1, int dtype=-1, Stream &stream=Stream::Null())
	computes element-wise weighted product of the two arrays (c = scale * a * b) More...
void	multiply (const GpuMat &a, const Scalar &sc, GpuMat &c, double scale=1, int dtype=-1, Stream &stream=Stream::Null())
	weighted multiplies matrix to a scalar (c = scale * a * s) More...
void	divide (const GpuMat &a, const GpuMat &b, GpuMat &c, double scale=1, int dtype=-1, Stream &stream=Stream::Null())
	computes element-wise weighted quotient of the two arrays (c = a / b) More...
void	divide (const GpuMat &a, const Scalar &sc, GpuMat &c, double scale=1, int dtype=-1, Stream &stream=Stream::Null())
	computes element-wise weighted quotient of matrix and scalar (c = a / s) More...
void	divide (double scale, const GpuMat &b, GpuMat &c, int dtype=-1, Stream &stream=Stream::Null())
	computes element-wise weighted reciprocal of an array (dst = scale/src2) More...
void	addWeighted (const GpuMat &src1, double alpha, const GpuMat &src2, double beta, double gamma, GpuMat &dst, int dtype=-1, Stream &stream=Stream::Null())
	computes the weighted sum of two arrays (dst = alpha*src1 + beta*src2 + gamma) More...
void	absdiff (const GpuMat &a, const GpuMat &b, GpuMat &c, Stream &stream=Stream::Null())
	computes element-wise absolute difference of two arrays (c = abs(a - b)) More...
void	absdiff (const GpuMat &a, const Scalar &s, GpuMat &c, Stream &stream=Stream::Null())
	computes element-wise absolute difference of array and scalar (c = abs(a - s)) More...
void	abs (const GpuMat &src, GpuMat &dst, Stream &stream=Stream::Null())
void	sqr (const GpuMat &src, GpuMat &dst, Stream &stream=Stream::Null())
void	sqrt (const GpuMat &src, GpuMat &dst, Stream &stream=Stream::Null())
void	exp (const GpuMat &a, GpuMat &b, Stream &stream=Stream::Null())
void	log (const GpuMat &a, GpuMat &b, Stream &stream=Stream::Null())
void	pow (const GpuMat &src, double power, GpuMat &dst, Stream &stream=Stream::Null())
	computes power of each matrix element: More...
void	compare (const GpuMat &a, const GpuMat &b, GpuMat &c, int cmpop, Stream &stream=Stream::Null())
	compares elements of two arrays (c = a <cmpop> b) More...
void	compare (const GpuMat &a, Scalar sc, GpuMat &c, int cmpop, Stream &stream=Stream::Null())
void	bitwise_not (const GpuMat &src, GpuMat &dst, const GpuMat &mask=GpuMat(), Stream &stream=Stream::Null())
	performs per-elements bit-wise inversion More...
void	bitwise_or (const GpuMat &src1, const GpuMat &src2, GpuMat &dst, const GpuMat &mask=GpuMat(), Stream &stream=Stream::Null())
	calculates per-element bit-wise disjunction of two arrays More...
void	bitwise_or (const GpuMat &src1, const Scalar &sc, GpuMat &dst, Stream &stream=Stream::Null())
void	bitwise_and (const GpuMat &src1, const GpuMat &src2, GpuMat &dst, const GpuMat &mask=GpuMat(), Stream &stream=Stream::Null())
	calculates per-element bit-wise conjunction of two arrays More...
void	bitwise_and (const GpuMat &src1, const Scalar &sc, GpuMat &dst, Stream &stream=Stream::Null())
void	bitwise_xor (const GpuMat &src1, const GpuMat &src2, GpuMat &dst, const GpuMat &mask=GpuMat(), Stream &stream=Stream::Null())
	calculates per-element bit-wise "exclusive or" operation More...
void	bitwise_xor (const GpuMat &src1, const Scalar &sc, GpuMat &dst, Stream &stream=Stream::Null())
void	rshift (const GpuMat &src, Scalar_< int > sc, GpuMat &dst, Stream &stream=Stream::Null())
void	lshift (const GpuMat &src, Scalar_< int > sc, GpuMat &dst, Stream &stream=Stream::Null())
void	min (const GpuMat &src1, const GpuMat &src2, GpuMat &dst, Stream &stream=Stream::Null())
	computes per-element minimum of two arrays (dst = min(src1, src2)) More...
void	min (const GpuMat &src1, double src2, GpuMat &dst, Stream &stream=Stream::Null())
	computes per-element minimum of array and scalar (dst = min(src1, src2)) More...
void	max (const GpuMat &src1, const GpuMat &src2, GpuMat &dst, Stream &stream=Stream::Null())
	computes per-element maximum of two arrays (dst = max(src1, src2)) More...
void	max (const GpuMat &src1, double src2, GpuMat &dst, Stream &stream=Stream::Null())
	computes per-element maximum of array and scalar (dst = max(src1, src2)) More...
void	alphaComp (const GpuMat &img1, const GpuMat &img2, GpuMat &dst, int alpha_op, Stream &stream=Stream::Null())
void	remap (const GpuMat &src, GpuMat &dst, const GpuMat &xmap, const GpuMat &ymap, int interpolation, int borderMode=BORDER_CONSTANT, Scalar borderValue=Scalar(), Stream &stream=Stream::Null())
void	meanShiftFiltering (const GpuMat &src, GpuMat &dst, int sp, int sr, TermCriteria criteria=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 5, 1), Stream &stream=Stream::Null())
	Does mean shift filtering on GPU. More...
void	meanShiftProc (const GpuMat &src, GpuMat &dstr, GpuMat &dstsp, int sp, int sr, TermCriteria criteria=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 5, 1), Stream &stream=Stream::Null())
	Does mean shift procedure on GPU. More...
void	meanShiftSegmentation (const GpuMat &src, Mat &dst, int sp, int sr, int minsize, TermCriteria criteria=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 5, 1))
	Does mean shift segmentation with elimination of small regions. More...
void	drawColorDisp (const GpuMat &src_disp, GpuMat &dst_disp, int ndisp, Stream &stream=Stream::Null())
void	reprojectImageTo3D (const GpuMat &disp, GpuMat &xyzw, const Mat &Q, int dst_cn=4, Stream &stream=Stream::Null())
void	cvtColor (const GpuMat &src, GpuMat &dst, int code, int dcn=0, Stream &stream=Stream::Null())
	converts image from one color space to another More...
void	demosaicing (const GpuMat &src, GpuMat &dst, int code, int dcn=-1, Stream &stream=Stream::Null())
void	swapChannels (GpuMat &image, const int dstOrder[4], Stream &stream=Stream::Null())
void	gammaCorrection (const GpuMat &src, GpuMat &dst, bool forward=true, Stream &stream=Stream::Null())
	Routines for correcting image color gamma. More...
double	threshold (const GpuMat &src, GpuMat &dst, double thresh, double maxval, int type, Stream &stream=Stream::Null())
	applies fixed threshold to the image More...
void	resize (const GpuMat &src, GpuMat &dst, Size dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR, Stream &stream=Stream::Null())
void	warpAffine (const GpuMat &src, GpuMat &dst, const Mat &M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, Scalar borderValue=Scalar(), Stream &stream=Stream::Null())
void	buildWarpAffineMaps (const Mat &M, bool inverse, Size dsize, GpuMat &xmap, GpuMat &ymap, Stream &stream=Stream::Null())
void	warpPerspective (const GpuMat &src, GpuMat &dst, const Mat &M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, Scalar borderValue=Scalar(), Stream &stream=Stream::Null())
void	buildWarpPerspectiveMaps (const Mat &M, bool inverse, Size dsize, GpuMat &xmap, GpuMat &ymap, Stream &stream=Stream::Null())
void	buildWarpPlaneMaps (Size src_size, Rect dst_roi, const Mat &K, const Mat &R, const Mat &T, float scale, GpuMat &map_x, GpuMat &map_y, Stream &stream=Stream::Null())
	builds plane warping maps More...
void	buildWarpCylindricalMaps (Size src_size, Rect dst_roi, const Mat &K, const Mat &R, float scale, GpuMat &map_x, GpuMat &map_y, Stream &stream=Stream::Null())
	builds cylindrical warping maps More...
void	buildWarpSphericalMaps (Size src_size, Rect dst_roi, const Mat &K, const Mat &R, float scale, GpuMat &map_x, GpuMat &map_y, Stream &stream=Stream::Null())
	builds spherical warping maps More...
void	rotate (const GpuMat &src, GpuMat &dst, Size dsize, double angle, double xShift=0, double yShift=0, int interpolation=INTER_LINEAR, Stream &stream=Stream::Null())
void	copyMakeBorder (const GpuMat &src, GpuMat &dst, int top, int bottom, int left, int right, int borderType, const Scalar &value=Scalar(), Stream &stream=Stream::Null())
	copies 2D array to a larger destination array and pads borders with user-specifiable constant More...
void	integral (const GpuMat &src, GpuMat &sum, Stream &stream=Stream::Null())
void	integralBuffered (const GpuMat &src, GpuMat &sum, GpuMat &buffer, Stream &stream=Stream::Null())
	buffered version More...
void	sqrIntegral (const GpuMat &src, GpuMat &sqsum, Stream &stream=Stream::Null())
void	columnSum (const GpuMat &src, GpuMat &sum)
	computes vertical sum, supports only CV_32FC1 images More...
void	rectStdDev (const GpuMat &src, const GpuMat &sqr, GpuMat &dst, const Rect &rect, Stream &stream=Stream::Null())
void	cornerHarris (const GpuMat &src, GpuMat &dst, int blockSize, int ksize, double k, int borderType=BORDER_REFLECT101)
	computes Harris cornerness criteria at each image pixel More...
void	cornerHarris (const GpuMat &src, GpuMat &dst, GpuMat &Dx, GpuMat &Dy, int blockSize, int ksize, double k, int borderType=BORDER_REFLECT101)
void	cornerHarris (const GpuMat &src, GpuMat &dst, GpuMat &Dx, GpuMat &Dy, GpuMat &buf, int blockSize, int ksize, double k, int borderType=BORDER_REFLECT101, Stream &stream=Stream::Null())
void	cornerMinEigenVal (const GpuMat &src, GpuMat &dst, int blockSize, int ksize, int borderType=BORDER_REFLECT101)
	computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness criteria More...
void	cornerMinEigenVal (const GpuMat &src, GpuMat &dst, GpuMat &Dx, GpuMat &Dy, int blockSize, int ksize, int borderType=BORDER_REFLECT101)
void	cornerMinEigenVal (const GpuMat &src, GpuMat &dst, GpuMat &Dx, GpuMat &Dy, GpuMat &buf, int blockSize, int ksize, int borderType=BORDER_REFLECT101, Stream &stream=Stream::Null())
void	mulSpectrums (const GpuMat &a, const GpuMat &b, GpuMat &c, int flags, bool conjB=false, Stream &stream=Stream::Null())
void	mulAndScaleSpectrums (const GpuMat &a, const GpuMat &b, GpuMat &c, int flags, float scale, bool conjB=false, Stream &stream=Stream::Null())
void	dft (const GpuMat &src, GpuMat &dst, Size dft_size, int flags=0, Stream &stream=Stream::Null())
void	convolve (const GpuMat &image, const GpuMat &templ, GpuMat &result, bool ccorr=false)
void	convolve (const GpuMat &image, const GpuMat &templ, GpuMat &result, bool ccorr, ConvolveBuf &buf, Stream &stream=Stream::Null())
void	matchTemplate (const GpuMat &image, const GpuMat &templ, GpuMat &result, int method, Stream &stream=Stream::Null())
	computes the proximity map for the raster template and the image where the template is searched for More...
void	matchTemplate (const GpuMat &image, const GpuMat &templ, GpuMat &result, int method, MatchTemplateBuf &buf, Stream &stream=Stream::Null())
	computes the proximity map for the raster template and the image where the template is searched for More...
void	pyrDown (const GpuMat &src, GpuMat &dst, Stream &stream=Stream::Null())
	smoothes the source image and downsamples it More...
void	pyrUp (const GpuMat &src, GpuMat &dst, Stream &stream=Stream::Null())
	upsamples the source image and then smoothes it More...
void	blendLinear (const GpuMat &img1, const GpuMat &img2, const GpuMat &weights1, const GpuMat &weights2, GpuMat &result, Stream &stream=Stream::Null())
void	bilateralFilter (const GpuMat &src, GpuMat &dst, int kernel_size, float sigma_color, float sigma_spatial, int borderMode=BORDER_DEFAULT, Stream &stream=Stream::Null())
	Performa bilateral filtering of passsed image. More...
void	nonLocalMeans (const GpuMat &src, GpuMat &dst, float h, int search_window=21, int block_size=7, int borderMode=BORDER_DEFAULT, Stream &s=Stream::Null())
	Brute force non-local means algorith (slow but universal) More...
void	Canny (const GpuMat &image, GpuMat &edges, double low_thresh, double high_thresh, int apperture_size=3, bool L2gradient=false)
void	Canny (const GpuMat &image, CannyBuf &buf, GpuMat &edges, double low_thresh, double high_thresh, int apperture_size=3, bool L2gradient=false)
void	Canny (const GpuMat &dx, const GpuMat &dy, GpuMat &edges, double low_thresh, double high_thresh, bool L2gradient=false)
void	Canny (const GpuMat &dx, const GpuMat &dy, CannyBuf &buf, GpuMat &edges, double low_thresh, double high_thresh, bool L2gradient=false)
void	HoughLines (const GpuMat &src, GpuMat &lines, float rho, float theta, int threshold, bool doSort=false, int maxLines=4096)
void	HoughLines (const GpuMat &src, GpuMat &lines, HoughLinesBuf &buf, float rho, float theta, int threshold, bool doSort=false, int maxLines=4096)
void	HoughLinesDownload (const GpuMat &d_lines, OutputArray h_lines, OutputArray h_votes=noArray())
void	HoughLinesP (const GpuMat &image, GpuMat &lines, HoughLinesBuf &buf, float rho, float theta, int minLineLength, int maxLineGap, int maxLines=4096)
	HoughLinesP. More...
void	HoughCircles (const GpuMat &src, GpuMat &circles, int method, float dp, float minDist, int cannyThreshold, int votesThreshold, int minRadius, int maxRadius, int maxCircles=4096)
void	HoughCircles (const GpuMat &src, GpuMat &circles, HoughCirclesBuf &buf, int method, float dp, float minDist, int cannyThreshold, int votesThreshold, int minRadius, int maxRadius, int maxCircles=4096)
void	HoughCirclesDownload (const GpuMat &d_circles, OutputArray h_circles)
void	meanStdDev (const GpuMat &mtx, Scalar &mean, Scalar &stddev)
void	meanStdDev (const GpuMat &mtx, Scalar &mean, Scalar &stddev, GpuMat &buf)
	buffered version More...
double	norm (const GpuMat &src1, int normType=NORM_L2)
double	norm (const GpuMat &src1, int normType, GpuMat &buf)
double	norm (const GpuMat &src1, int normType, const GpuMat &mask, GpuMat &buf)
double	norm (const GpuMat &src1, const GpuMat &src2, int normType=NORM_L2)
Scalar	sum (const GpuMat &src)
Scalar	sum (const GpuMat &src, GpuMat &buf)
Scalar	sum (const GpuMat &src, const GpuMat &mask, GpuMat &buf)
Scalar	absSum (const GpuMat &src)
Scalar	absSum (const GpuMat &src, GpuMat &buf)
Scalar	absSum (const GpuMat &src, const GpuMat &mask, GpuMat &buf)
Scalar	sqrSum (const GpuMat &src)
Scalar	sqrSum (const GpuMat &src, GpuMat &buf)
Scalar	sqrSum (const GpuMat &src, const GpuMat &mask, GpuMat &buf)
void	minMax (const GpuMat &src, double *minVal, double *maxVal=0, const GpuMat &mask=GpuMat())
	finds global minimum and maximum array elements and returns their values More...
void	minMax (const GpuMat &src, double *minVal, double *maxVal, const GpuMat &mask, GpuMat &buf)
void	minMaxLoc (const GpuMat &src, double *minVal, double *maxVal=0, Point *minLoc=0, Point *maxLoc=0, const GpuMat &mask=GpuMat())
	finds global minimum and maximum array elements and returns their values with locations More...
void	minMaxLoc (const GpuMat &src, double *minVal, double *maxVal, Point *minLoc, Point *maxLoc, const GpuMat &mask, GpuMat &valbuf, GpuMat &locbuf)
int	countNonZero (const GpuMat &src)
	counts non-zero array elements More...
int	countNonZero (const GpuMat &src, GpuMat &buf)
void	reduce (const GpuMat &mtx, GpuMat &vec, int dim, int reduceOp, int dtype=-1, Stream &stream=Stream::Null())
	reduces a matrix to a vector More...
void	transformPoints (const GpuMat &src, const Mat &rvec, const Mat &tvec, GpuMat &dst, Stream &stream=Stream::Null())
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	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)
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. More...
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. More...
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. More...
void	labelComponents (const GpuMat &mask, GpuMat &components, int flags=0, Stream &stream=Stream::Null())
	performs connected componnents labeling. More...
void	evenLevels (GpuMat &levels, int nLevels, int lowerLevel, int upperLevel)
	Compute levels with even distribution. levels will have 1 row and nLevels cols and CV_32SC1 type. More...
void	histEven (const GpuMat &src, GpuMat &hist, int histSize, int lowerLevel, int upperLevel, Stream &stream=Stream::Null())
void	histEven (const GpuMat &src, GpuMat &hist, GpuMat &buf, int histSize, int lowerLevel, int upperLevel, Stream &stream=Stream::Null())
void	histEven (const GpuMat &src, GpuMat hist[4], int histSize[4], int lowerLevel[4], int upperLevel[4], Stream &stream=Stream::Null())
void	histEven (const GpuMat &src, GpuMat hist[4], GpuMat &buf, int histSize[4], int lowerLevel[4], int upperLevel[4], Stream &stream=Stream::Null())
void	histRange (const GpuMat &src, GpuMat &hist, const GpuMat &levels, Stream &stream=Stream::Null())
void	histRange (const GpuMat &src, GpuMat &hist, const GpuMat &levels, GpuMat &buf, Stream &stream=Stream::Null())
void	histRange (const GpuMat &src, GpuMat hist[4], const GpuMat levels[4], Stream &stream=Stream::Null())
void	histRange (const GpuMat &src, GpuMat hist[4], const GpuMat levels[4], GpuMat &buf, Stream &stream=Stream::Null())
void	calcHist (const GpuMat &src, GpuMat &hist, Stream &stream=Stream::Null())
void	calcHist (const GpuMat &src, GpuMat &hist, GpuMat &buf, Stream &stream=Stream::Null())
void	equalizeHist (const GpuMat &src, GpuMat &dst, Stream &stream=Stream::Null())
	normalizes the grayscale image brightness and contrast by normalizing its histogram More...
void	equalizeHist (const GpuMat &src, GpuMat &dst, GpuMat &hist, Stream &stream=Stream::Null())
void	equalizeHist (const GpuMat &src, GpuMat &dst, GpuMat &hist, GpuMat &buf, Stream &stream=Stream::Null())
Ptr< cv::gpu::CLAHE >	createCLAHE (double clipLimit=40.0, Size tileGridSize=Size(8, 8))
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 */. More...
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())
void	createOpticalFlowNeedleMap (const GpuMat &u, const GpuMat &v, GpuMat &vertex, GpuMat &colors)
void	compactPoints (GpuMat &points0, GpuMat &points1, const GpuMat &mask)
	removes points (CV_32FC2, single row matrix) with zero mask value More...
void	calcWobbleSuppressionMaps (int left, int idx, int right, Size size, const Mat &ml, const Mat &mr, GpuMat &mapx, GpuMat &mapy)
__host__ __device__ __forceinline__ int	divUp (int total, int grain)

Typedef Documentation

DevMem2D

typedef DevMem2Db cv::gpu::DevMem2D

DevMem2Db

typedef DevMem2D_<unsigned char> cv::gpu::DevMem2Db

DevMem2Df

typedef DevMem2D_<float> cv::gpu::DevMem2Df

DevMem2Di

typedef DevMem2D_<int> cv::gpu::DevMem2Di

PtrElemStep

typedef PtrElemStep_<unsigned char> cv::gpu::PtrElemStep

PtrElemStepf

typedef PtrElemStep_<float> cv::gpu::PtrElemStepf

PtrElemStepi

typedef PtrElemStep_<int> cv::gpu::PtrElemStepi

PtrStepb

typedef PtrStep<unsigned char> cv::gpu::PtrStepb

PtrStepf

typedef PtrStep<float> cv::gpu::PtrStepf

PtrStepi

typedef PtrStep<int> cv::gpu::PtrStepi

PtrStepSzb

typedef PtrStepSz<unsigned char> cv::gpu::PtrStepSzb

PtrStepSzf

typedef PtrStepSz<float> cv::gpu::PtrStepSzf

PtrStepSzi

typedef PtrStepSz<int> cv::gpu::PtrStepSzi

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
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

anonymous enum

anonymous enum

Enumerator
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

FeatureSet

enum cv::gpu::FeatureSet

Enumerator
FEATURE_SET_COMPUTE_10
FEATURE_SET_COMPUTE_11
FEATURE_SET_COMPUTE_12
FEATURE_SET_COMPUTE_13
FEATURE_SET_COMPUTE_20
FEATURE_SET_COMPUTE_21
FEATURE_SET_COMPUTE_30
FEATURE_SET_COMPUTE_35
GLOBAL_ATOMICS
SHARED_ATOMICS
NATIVE_DOUBLE
WARP_SHUFFLE_FUNCTIONS
DYNAMIC_PARALLELISM

Function Documentation

abs()

void cv::gpu::abs	(	const GpuMat &	src,
		GpuMat &	dst,
		Stream &	stream = Stream::Null()
	)

computes absolute value of each matrix element supports CV_16S and CV_32F depth

absdiff() [1/2]

void cv::gpu::absdiff	(	const GpuMat &	a,
		const GpuMat &	b,
		GpuMat &	c,
		Stream &	stream = Stream::Null()
	)

computes element-wise absolute difference of two arrays (c = abs(a - b))

absdiff() [2/2]

void cv::gpu::absdiff	(	const GpuMat &	a,
		const Scalar &	s,
		GpuMat &	c,
		Stream &	stream = Stream::Null()
	)

computes element-wise absolute difference of array and scalar (c = abs(a - s))

absSum() [1/3]

Scalar cv::gpu::absSum

(

const GpuMat &

src

)

computes sum of array elements absolute values supports only single channel images

absSum() [2/3]

Scalar cv::gpu::absSum	(	const GpuMat &	src,
		GpuMat &	buf
	)

absSum() [3/3]

Scalar cv::gpu::absSum	(	const GpuMat &	src,
		const GpuMat &	mask,
		GpuMat &	buf
	)

add() [1/2]

void cv::gpu::add	(	const GpuMat &	a,
		const GpuMat &	b,
		GpuMat &	c,
		const GpuMat &	mask = GpuMat(),
		int	dtype = -1,
		Stream &	stream = Stream::Null()
	)

adds one matrix to another (c = a + b)

add() [2/2]

void cv::gpu::add	(	const GpuMat &	a,
		const Scalar &	sc,
		GpuMat &	c,
		const GpuMat &	mask = GpuMat(),
		int	dtype = -1,
		Stream &	stream = Stream::Null()
	)

adds scalar to a matrix (c = a + s)

addWeighted()

void cv::gpu::addWeighted	(	const GpuMat &	src1,
		double	alpha,
		const GpuMat &	src2,
		double	beta,
		double	gamma,
		GpuMat &	dst,
		int	dtype = -1,
		Stream &	stream = Stream::Null()
	)

computes the weighted sum of two arrays (dst = alpha*src1 + beta*src2 + gamma)

allocMatFromBuf()

GpuMat cv::gpu::allocMatFromBuf	(	int	rows,
		int	cols,
		int	type,
		GpuMat &	mat
	)

alphaComp()

void cv::gpu::alphaComp	(	const GpuMat &	img1,
		const GpuMat &	img2,
		GpuMat &	dst,
		int	alpha_op,
		Stream &	stream = Stream::Null()
	)

Composite two images using alpha opacity values contained in each image Supports CV_8UC4, CV_16UC4, CV_32SC4 and CV_32FC4 types

bilateralFilter()

void cv::gpu::bilateralFilter	(	const GpuMat &	src,
		GpuMat &	dst,
		int	kernel_size,
		float	sigma_color,
		float	sigma_spatial,
		int	borderMode = BORDER_DEFAULT,
		Stream &	stream = Stream::Null()
	)

Performa bilateral filtering of passsed image.

bitwise_and() [1/2]

void cv::gpu::bitwise_and	(	const GpuMat &	src1,
		const GpuMat &	src2,
		GpuMat &	dst,
		const GpuMat &	mask = GpuMat(),
		Stream &	stream = Stream::Null()
	)

calculates per-element bit-wise conjunction of two arrays

bitwise_and() [2/2]

void cv::gpu::bitwise_and	(	const GpuMat &	src1,
		const Scalar &	sc,
		GpuMat &	dst,
		Stream &	stream = Stream::Null()
	)

calculates per-element bit-wise conjunction of array and scalar supports 1, 3 and 4 channels images with CV_8U, CV_16U or CV_32S depth

bitwise_not()

void cv::gpu::bitwise_not	(	const GpuMat &	src,
		GpuMat &	dst,
		const GpuMat &	mask = GpuMat(),
		Stream &	stream = Stream::Null()
	)

performs per-elements bit-wise inversion

bitwise_or() [1/2]

void cv::gpu::bitwise_or	(	const GpuMat &	src1,
		const GpuMat &	src2,
		GpuMat &	dst,
		const GpuMat &	mask = GpuMat(),
		Stream &	stream = Stream::Null()
	)

calculates per-element bit-wise disjunction of two arrays

bitwise_or() [2/2]

void cv::gpu::bitwise_or	(	const GpuMat &	src1,
		const Scalar &	sc,
		GpuMat &	dst,
		Stream &	stream = Stream::Null()
	)

calculates per-element bit-wise disjunction of array and scalar supports 1, 3 and 4 channels images with CV_8U, CV_16U or CV_32S depth

bitwise_xor() [1/2]

void cv::gpu::bitwise_xor	(	const GpuMat &	src1,
		const GpuMat &	src2,
		GpuMat &	dst,
		const GpuMat &	mask = GpuMat(),
		Stream &	stream = Stream::Null()
	)

calculates per-element bit-wise "exclusive or" operation

bitwise_xor() [2/2]

void cv::gpu::bitwise_xor	(	const GpuMat &	src1,
		const Scalar &	sc,
		GpuMat &	dst,
		Stream &	stream = Stream::Null()
	)

calculates per-element bit-wise "exclusive or" of array and scalar supports 1, 3 and 4 channels images with CV_8U, CV_16U or CV_32S depth

blendLinear()

void cv::gpu::blendLinear	(	const GpuMat &	img1,
		const GpuMat &	img2,
		const GpuMat &	weights1,
		const GpuMat &	weights2,
		GpuMat &	result,
		Stream &	stream = Stream::Null()
	)

performs linear blending of two images to avoid accuracy errors sum of weigths shouldn't be very close to zero

boxFilter()

void cv::gpu::boxFilter	(	const GpuMat &	src,
		GpuMat &	dst,
		int	ddepth,
		Size	ksize,
		Point	anchor = Point(-1,-1),
		Stream &	stream = Stream::Null()
	)

smooths the image using the normalized box filter supports CV_8UC1, CV_8UC4 types

buildWarpAffineMaps()

void cv::gpu::buildWarpAffineMaps	(	const Mat &	M,
		bool	inverse,
		Size	dsize,
		GpuMat &	xmap,
		GpuMat &	ymap,
		Stream &	stream = Stream::Null()
	)

buildWarpCylindricalMaps()

void cv::gpu::buildWarpCylindricalMaps	(	Size	src_size,
		Rect	dst_roi,
		const Mat &	K,
		const Mat &	R,
		float	scale,
		GpuMat &	map_x,
		GpuMat &	map_y,
		Stream &	stream = Stream::Null()
	)

builds cylindrical warping maps

buildWarpPerspectiveMaps()

void cv::gpu::buildWarpPerspectiveMaps	(	const Mat &	M,
		bool	inverse,
		Size	dsize,
		GpuMat &	xmap,
		GpuMat &	ymap,
		Stream &	stream = Stream::Null()
	)

buildWarpPlaneMaps()

void cv::gpu::buildWarpPlaneMaps	(	Size	src_size,
		Rect	dst_roi,
		const Mat &	K,
		const Mat &	R,
		const Mat &	T,
		float	scale,
		GpuMat &	map_x,
		GpuMat &	map_y,
		Stream &	stream = Stream::Null()
	)

builds plane warping maps

buildWarpSphericalMaps()

void cv::gpu::buildWarpSphericalMaps	(	Size	src_size,
		Rect	dst_roi,
		const Mat &	K,
		const Mat &	R,
		float	scale,
		GpuMat &	map_x,
		GpuMat &	map_y,
		Stream &	stream = Stream::Null()
	)

builds spherical warping maps

calcHist() [1/2]

void cv::gpu::calcHist	(	const GpuMat &	src,
		GpuMat &	hist,
		Stream &	stream = Stream::Null()
	)

Calculates histogram for 8u one channel image Output hist will have one row, 256 cols and CV32SC1 type.

calcHist() [2/2]

void cv::gpu::calcHist	(	const GpuMat &	src,
		GpuMat &	hist,
		GpuMat &	buf,
		Stream &	stream = Stream::Null()
	)

calcOpticalFlowBM()

void cv::gpu::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 */.

calcWobbleSuppressionMaps()

void cv::gpu::calcWobbleSuppressionMaps	(	int	left,
		int	idx,
		int	right,
		Size	size,
		const Mat &	ml,
		const Mat &	mr,
		GpuMat &	mapx,
		GpuMat &	mapy
	)

Canny() [1/4]

void cv::gpu::Canny	(	const GpuMat &	image,
		GpuMat &	edges,
		double	low_thresh,
		double	high_thresh,
		int	apperture_size = 3,
		bool	L2gradient = false
	)

Canny() [2/4]

void cv::gpu::Canny	(	const GpuMat &	image,
		CannyBuf &	buf,
		GpuMat &	edges,
		double	low_thresh,
		double	high_thresh,
		int	apperture_size = 3,
		bool	L2gradient = false
	)

Canny() [3/4]

void cv::gpu::Canny	(	const GpuMat &	dx,
		const GpuMat &	dy,
		GpuMat &	edges,
		double	low_thresh,
		double	high_thresh,
		bool	L2gradient = false
	)

Canny() [4/4]

void cv::gpu::Canny	(	const GpuMat &	dx,
		const GpuMat &	dy,
		CannyBuf &	buf,
		GpuMat &	edges,
		double	low_thresh,
		double	high_thresh,
		bool	L2gradient = false
	)

cartToPolar()

void cv::gpu::cartToPolar	(	const GpuMat &	x,
		const GpuMat &	y,
		GpuMat &	magnitude,
		GpuMat &	angle,
		bool	angleInDegrees = false,
		Stream &	stream = Stream::Null()
	)

converts Cartesian coordinates to polar supports only floating-point source

columnSum()

void cv::gpu::columnSum	(	const GpuMat &	src,
		GpuMat &	sum
	)

computes vertical sum, supports only CV_32FC1 images

compactPoints()

void cv::gpu::compactPoints	(	GpuMat &	points0,
		GpuMat &	points1,
		const GpuMat &	mask
	)

removes points (CV_32FC2, single row matrix) with zero mask value

compare() [1/2]

void cv::gpu::compare	(	const GpuMat &	a,
		const GpuMat &	b,
		GpuMat &	c,
		int	cmpop,
		Stream &	stream = Stream::Null()
	)

compares elements of two arrays (c = a <cmpop> b)

compare() [2/2]

void cv::gpu::compare	(	const GpuMat &	a,
		Scalar	sc,
		GpuMat &	c,
		int	cmpop,
		Stream &	stream = Stream::Null()
	)

connectivityMask()

void cv::gpu::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.

convolve() [1/2]

void cv::gpu::convolve	(	const GpuMat &	image,
		const GpuMat &	templ,
		GpuMat &	result,
		bool	ccorr = false
	)

computes convolution (or cross-correlation) of two images using discrete Fourier transform supports source images of 32FC1 type only result matrix will have 32FC1 type

convolve() [2/2]

void cv::gpu::convolve	(	const GpuMat &	image,
		const GpuMat &	templ,
		GpuMat &	result,
		bool	ccorr,
		ConvolveBuf &	buf,
		Stream &	stream = Stream::Null()
	)

copyMakeBorder()

void cv::gpu::copyMakeBorder	(	const GpuMat &	src,
		GpuMat &	dst,
		int	top,
		int	bottom,
		int	left,
		int	right,
		int	borderType,
		const Scalar &	value = Scalar(),
		Stream &	stream = Stream::Null()
	)

copies 2D array to a larger destination array and pads borders with user-specifiable constant

cornerHarris() [1/3]

void cv::gpu::cornerHarris	(	const GpuMat &	src,
		GpuMat &	dst,
		int	blockSize,
		int	ksize,
		double	k,
		int	borderType = BORDER_REFLECT101
	)

computes Harris cornerness criteria at each image pixel

cornerHarris() [2/3]

void cv::gpu::cornerHarris	(	const GpuMat &	src,
		GpuMat &	dst,
		GpuMat &	Dx,
		GpuMat &	Dy,
		int	blockSize,
		int	ksize,
		double	k,
		int	borderType = BORDER_REFLECT101
	)

cornerHarris() [3/3]

void cv::gpu::cornerHarris	(	const GpuMat &	src,
		GpuMat &	dst,
		GpuMat &	Dx,
		GpuMat &	Dy,
		GpuMat &	buf,
		int	blockSize,
		int	ksize,
		double	k,
		int	borderType = BORDER_REFLECT101,
		Stream &	stream = Stream::Null()
	)

cornerMinEigenVal() [1/3]

void cv::gpu::cornerMinEigenVal	(	const GpuMat &	src,
		GpuMat &	dst,
		int	blockSize,
		int	ksize,
		int	borderType = BORDER_REFLECT101
	)

computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness criteria

cornerMinEigenVal() [2/3]

void cv::gpu::cornerMinEigenVal	(	const GpuMat &	src,
		GpuMat &	dst,
		GpuMat &	Dx,
		GpuMat &	Dy,
		int	blockSize,
		int	ksize,
		int	borderType = BORDER_REFLECT101
	)

cornerMinEigenVal() [3/3]

void cv::gpu::cornerMinEigenVal	(	const GpuMat &	src,
		GpuMat &	dst,
		GpuMat &	Dx,
		GpuMat &	Dy,
		GpuMat &	buf,
		int	blockSize,
		int	ksize,
		int	borderType = BORDER_REFLECT101,
		Stream &	stream = Stream::Null()
	)

countNonZero() [1/2]

int cv::gpu::countNonZero

(

const GpuMat &

src

)

counts non-zero array elements

countNonZero() [2/2]

int cv::gpu::countNonZero	(	const GpuMat &	src,
		GpuMat &	buf
	)

createBoxFilter_GPU()

Ptr<FilterEngine_GPU> cv::gpu::createBoxFilter_GPU	(	int	srcType,
		int	dstType,
		const Size &	ksize,
		const Point &	anchor = Point(-1,-1)
	)

returns box filter engine

createCLAHE()

Ptr<cv::gpu::CLAHE> cv::gpu::createCLAHE	(	double	clipLimit = 40.0,
		Size	tileGridSize = Size(8, 8)
	)

createContinuous() [1/4]

void cv::gpu::createContinuous	(	int	rows,
		int	cols,
		int	type,
		GpuMat &	m
	)

Creates continuous GPU matrix.

createContinuous() [2/4]

GpuMat cv::gpu::createContinuous ( int  rows, int  cols, int  type  )

inline

createContinuous() [3/4]

void cv::gpu::createContinuous ( Size  size, int  type, GpuMat &  m  )

inline

createContinuous() [4/4]

GpuMat cv::gpu::createContinuous ( Size  size, int  type  )

inline

createDerivFilter_GPU() [1/2]

Ptr<FilterEngine_GPU> cv::gpu::createDerivFilter_GPU	(	int	srcType,
		int	dstType,
		int	dx,
		int	dy,
		int	ksize,
		int	rowBorderType = BORDER_DEFAULT,
		int	columnBorderType = -1
	)

returns filter engine for the generalized Sobel operator

createDerivFilter_GPU() [2/2]

Ptr<FilterEngine_GPU> cv::gpu::createDerivFilter_GPU	(	int	srcType,
		int	dstType,
		int	dx,
		int	dy,
		int	ksize,
		GpuMat &	buf,
		int	rowBorderType = BORDER_DEFAULT,
		int	columnBorderType = -1
	)

createFilter2D_GPU()

Ptr<FilterEngine_GPU> cv::gpu::createFilter2D_GPU	(	const Ptr< BaseFilter_GPU > &	filter2D,
		int	srcType,
		int	dstType
	)

returns the non-separable filter engine with the specified filter

createGaussianFilter_GPU() [1/2]

Ptr<FilterEngine_GPU> cv::gpu::createGaussianFilter_GPU	(	int	type,
		Size	ksize,
		double	sigma1,
		double	sigma2 = 0,
		int	rowBorderType = BORDER_DEFAULT,
		int	columnBorderType = -1
	)

returns the Gaussian filter engine

createGaussianFilter_GPU() [2/2]

Ptr<FilterEngine_GPU> cv::gpu::createGaussianFilter_GPU	(	int	type,
		Size	ksize,
		GpuMat &	buf,
		double	sigma1,
		double	sigma2 = 0,
		int	rowBorderType = BORDER_DEFAULT,
		int	columnBorderType = -1
	)

createLinearFilter_GPU()

Ptr<FilterEngine_GPU> cv::gpu::createLinearFilter_GPU	(	int	srcType,
		int	dstType,
		const Mat &	kernel,
		Point	anchor = Point(-1,-1),
		int	borderType = BORDER_DEFAULT
	)

returns the non-separable linear filter engine

createMorphologyFilter_GPU() [1/2]

Ptr<FilterEngine_GPU> cv::gpu::createMorphologyFilter_GPU	(	int	op,
		int	type,
		const Mat &	kernel,
		const Point &	anchor = Point(-1,-1),
		int	iterations = 1
	)

returns morphological filter engine. Only MORPH_ERODE and MORPH_DILATE are supported.

createMorphologyFilter_GPU() [2/2]

Ptr<FilterEngine_GPU> cv::gpu::createMorphologyFilter_GPU	(	int	op,
		int	type,
		const Mat &	kernel,
		GpuMat &	buf,
		const Point &	anchor = Point(-1,-1),
		int	iterations = 1
	)

createOpticalFlowNeedleMap()

void cv::gpu::createOpticalFlowNeedleMap	(	const GpuMat &	u,
		const GpuMat &	v,
		GpuMat &	vertex,
		GpuMat &	colors
	)

createSeparableFilter_GPU() [1/2]

Ptr<FilterEngine_GPU> cv::gpu::createSeparableFilter_GPU	(	const Ptr< BaseRowFilter_GPU > &	rowFilter,
		const Ptr< BaseColumnFilter_GPU > &	columnFilter,
		int	srcType,
		int	bufType,
		int	dstType
	)

returns the separable filter engine with the specified filters

createSeparableFilter_GPU() [2/2]

Ptr<FilterEngine_GPU> cv::gpu::createSeparableFilter_GPU	(	const Ptr< BaseRowFilter_GPU > &	rowFilter,
		const Ptr< BaseColumnFilter_GPU > &	columnFilter,
		int	srcType,
		int	bufType,
		int	dstType,
		GpuMat &	buf
	)

createSeparableLinearFilter_GPU() [1/2]

Ptr<FilterEngine_GPU> cv::gpu::createSeparableLinearFilter_GPU	(	int	srcType,
		int	dstType,
		const Mat &	rowKernel,
		const Mat &	columnKernel,
		const Point &	anchor = Point(-1,-1),
		int	rowBorderType = BORDER_DEFAULT,
		int	columnBorderType = -1
	)

returns the separable linear filter engine

createSeparableLinearFilter_GPU() [2/2]

Ptr<FilterEngine_GPU> cv::gpu::createSeparableLinearFilter_GPU	(	int	srcType,
		int	dstType,
		const Mat &	rowKernel,
		const Mat &	columnKernel,
		GpuMat &	buf,
		const Point &	anchor = Point(-1,-1),
		int	rowBorderType = BORDER_DEFAULT,
		int	columnBorderType = -1
	)

cvtColor()

void cv::gpu::cvtColor	(	const GpuMat &	src,
		GpuMat &	dst,
		int	code,
		int	dcn = 0,
		Stream &	stream = Stream::Null()
	)

converts image from one color space to another

demosaicing()

void cv::gpu::demosaicing	(	const GpuMat &	src,
		GpuMat &	dst,
		int	code,
		int	dcn = -1,
		Stream &	stream = Stream::Null()
	)

deviceSupports()

bool cv::gpu::deviceSupports

(

FeatureSet

feature_set

)

dft()

void cv::gpu::dft	(	const GpuMat &	src,
		GpuMat &	dst,
		Size	dft_size,
		int	flags = 0,
		Stream &	stream = Stream::Null()
	)

Performs a forward or inverse discrete Fourier transform (1D or 2D) of floating point matrix. Param dft_size is the size of DFT transform.

If the source matrix is not continous, then additional copy will be done, so to avoid copying ensure the source matrix is continous one. If you want to use preallocated output ensure it is continuous too, otherwise it will be reallocated.

Being implemented via CUFFT real-to-complex transform result contains only non-redundant values in CUFFT's format. Result as full complex matrix for such kind of transform cannot be retrieved.

For complex-to-real transform it is assumed that the source matrix is packed in CUFFT's format.

dilate() [1/2]

void cv::gpu::dilate	(	const GpuMat &	src,
		GpuMat &	dst,
		const Mat &	kernel,
		Point	anchor = Point(-1, -1),
		int	iterations = 1
	)

dilates the image (applies the local maximum operator)

dilate() [2/2]

void cv::gpu::dilate	(	const GpuMat &	src,
		GpuMat &	dst,
		const Mat &	kernel,
		GpuMat &	buf,
		Point	anchor = Point(-1, -1),
		int	iterations = 1,
		Stream &	stream = Stream::Null()
	)

divide() [1/3]

void cv::gpu::divide	(	const GpuMat &	a,
		const GpuMat &	b,
		GpuMat &	c,
		double	scale = 1,
		int	dtype = -1,
		Stream &	stream = Stream::Null()
	)

computes element-wise weighted quotient of the two arrays (c = a / b)

divide() [2/3]

void cv::gpu::divide	(	const GpuMat &	a,
		const Scalar &	sc,
		GpuMat &	c,
		double	scale = 1,
		int	dtype = -1,
		Stream &	stream = Stream::Null()
	)

computes element-wise weighted quotient of matrix and scalar (c = a / s)

divide() [3/3]

void cv::gpu::divide	(	double	scale,
		const GpuMat &	b,
		GpuMat &	c,
		int	dtype = -1,
		Stream &	stream = Stream::Null()
	)

computes element-wise weighted reciprocal of an array (dst = scale/src2)

divUp()

__host__ __device__ __forceinline__ int cv::gpu::divUp	(	int	total,
		int	grain
	)

drawColorDisp()

void cv::gpu::drawColorDisp	(	const GpuMat &	src_disp,
		GpuMat &	dst_disp,
		int	ndisp,
		Stream &	stream = Stream::Null()
	)

Does coloring of disparity image: [0..ndisp) -> [0..240, 1, 1] in HSV. Supported types of input disparity: CV_8U, CV_16S. Output disparity has CV_8UC4 type in BGRA format (alpha = 255).

ensureSizeIsEnough() [1/2]

void cv::gpu::ensureSizeIsEnough	(	int	rows,
		int	cols,
		int	type,
		GpuMat &	m
	)

Ensures that size of the given matrix is not less than (rows, cols) size and matrix type is match specified one too

ensureSizeIsEnough() [2/2]

void cv::gpu::ensureSizeIsEnough ( Size  size, int  type, GpuMat &  m  )

inline

equalizeHist() [1/3]

void cv::gpu::equalizeHist	(	const GpuMat &	src,
		GpuMat &	dst,
		Stream &	stream = Stream::Null()
	)

normalizes the grayscale image brightness and contrast by normalizing its histogram

equalizeHist() [2/3]

void cv::gpu::equalizeHist	(	const GpuMat &	src,
		GpuMat &	dst,
		GpuMat &	hist,
		Stream &	stream = Stream::Null()
	)

equalizeHist() [3/3]

void cv::gpu::equalizeHist	(	const GpuMat &	src,
		GpuMat &	dst,
		GpuMat &	hist,
		GpuMat &	buf,
		Stream &	stream = Stream::Null()
	)

erode() [1/2]

void cv::gpu::erode	(	const GpuMat &	src,
		GpuMat &	dst,
		const Mat &	kernel,
		Point	anchor = Point(-1, -1),
		int	iterations = 1
	)

erodes the image (applies the local minimum operator)

erode() [2/2]

void cv::gpu::erode	(	const GpuMat &	src,
		GpuMat &	dst,
		const Mat &	kernel,
		GpuMat &	buf,
		Point	anchor = Point(-1, -1),
		int	iterations = 1,
		Stream &	stream = Stream::Null()
	)

error()

void cv::gpu::error	(	const char *	error_string,
		const char *	file,
		const int	line,
		const char *	func = ""
	)

evenLevels()

void cv::gpu::evenLevels	(	GpuMat &	levels,
		int	nLevels,
		int	lowerLevel,
		int	upperLevel
	)

Compute levels with even distribution. levels will have 1 row and nLevels cols and CV_32SC1 type.

exp()

void cv::gpu::exp	(	const GpuMat &	a,
		GpuMat &	b,
		Stream &	stream = Stream::Null()
	)

computes exponent of each matrix element (b = e**a) supports CV_8U, CV_16U, CV_16S and CV_32F depth

filter2D()

void cv::gpu::filter2D	(	const GpuMat &	src,
		GpuMat &	dst,
		int	ddepth,
		const Mat &	kernel,
		Point	anchor = Point(-1,-1),
		int	borderType = BORDER_DEFAULT,
		Stream &	stream = Stream::Null()
	)

applies non-separable 2D linear filter to the image

flip()

void cv::gpu::flip	(	const GpuMat &	a,
		GpuMat &	b,
		int	flipCode,
		Stream &	stream = Stream::Null()
	)

reverses the order of the rows, columns or both in a matrix supports 1, 3 and 4 channels images with CV_8U, CV_16U, CV_32S or CV_32F depth

gammaCorrection()

void cv::gpu::gammaCorrection	(	const GpuMat &	src,
		GpuMat &	dst,
		bool	forward = true,
		Stream &	stream = Stream::Null()
	)

Routines for correcting image color gamma.

GaussianBlur() [1/2]

void cv::gpu::GaussianBlur	(	const GpuMat &	src,
		GpuMat &	dst,
		Size	ksize,
		double	sigma1,
		double	sigma2 = 0,
		int	rowBorderType = BORDER_DEFAULT,
		int	columnBorderType = -1
	)

smooths the image using Gaussian filter.

GaussianBlur() [2/2]

void cv::gpu::GaussianBlur	(	const GpuMat &	src,
		GpuMat &	dst,
		Size	ksize,
		GpuMat &	buf,
		double	sigma1,
		double	sigma2 = 0,
		int	rowBorderType = BORDER_DEFAULT,
		int	columnBorderType = -1,
		Stream &	stream = Stream::Null()
	)

gemm()

void cv::gpu::gemm	(	const GpuMat &	src1,
		const GpuMat &	src2,
		double	alpha,
		const GpuMat &	src3,
		double	beta,
		GpuMat &	dst,
		int	flags = 0,
		Stream &	stream = Stream::Null()
	)

implements generalized matrix product algorithm GEMM from BLAS

getBoxFilter_GPU()

Ptr<BaseFilter_GPU> cv::gpu::getBoxFilter_GPU	(	int	srcType,
		int	dstType,
		const Size &	ksize,
		Point	anchor = Point(-1, -1)
	)

returns 2D box filter supports CV_8UC1 and CV_8UC4 source type, dst type must be the same as source type

getColumnSumFilter_GPU()

Ptr<BaseColumnFilter_GPU> cv::gpu::getColumnSumFilter_GPU	(	int	sumType,
		int	dstType,
		int	ksize,
		int	anchor = -1
	)

returns vertical 1D box filter supports only CV_8UC1 sum type and CV_32FC1 dst type

getCudaEnabledDeviceCount()

int cv::gpu::getCudaEnabledDeviceCount

(

)

This is the only function that do not throw exceptions if the library is compiled without Cuda.

getDevice()

int cv::gpu::getDevice

(

)

getLinearColumnFilter_GPU()

Ptr<BaseColumnFilter_GPU> cv::gpu::getLinearColumnFilter_GPU	(	int	bufType,
		int	dstType,
		const Mat &	columnKernel,
		int	anchor = -1,
		int	borderType = BORDER_DEFAULT
	)

returns the primitive column filter with the specified kernel. supports only CV_8UC1, CV_8UC4, CV_16SC1, CV_16SC2, CV_32SC1, CV_32FC1 dst type. there are two version of algorithm: NPP and OpenCV. NPP calls when dstType == CV_8UC1 or dstType == CV_8UC4 and bufType == dstType, otherwise calls OpenCV version. NPP supports only BORDER_CONSTANT border type. OpenCV version supports only CV_32F as buffer depth and BORDER_REFLECT101, BORDER_REPLICATE and BORDER_CONSTANT border types.

getLinearFilter_GPU()

Ptr<BaseFilter_GPU> cv::gpu::getLinearFilter_GPU	(	int	srcType,
		int	dstType,
		const Mat &	kernel,
		Point	anchor = Point(-1, -1),
		int	borderType = BORDER_DEFAULT
	)

returns 2D filter with the specified kernel supports CV_8U, CV_16U and CV_32F one and four channel image

getLinearRowFilter_GPU()

Ptr<BaseRowFilter_GPU> cv::gpu::getLinearRowFilter_GPU	(	int	srcType,
		int	bufType,
		const Mat &	rowKernel,
		int	anchor = -1,
		int	borderType = BORDER_DEFAULT
	)

returns the primitive row filter with the specified kernel. supports only CV_8UC1, CV_8UC4, CV_16SC1, CV_16SC2, CV_32SC1, CV_32FC1 source type. there are two version of algorithm: NPP and OpenCV. NPP calls when srcType == CV_8UC1 or srcType == CV_8UC4 and bufType == srcType, otherwise calls OpenCV version. NPP supports only BORDER_CONSTANT border type. OpenCV version supports only CV_32F as buffer depth and BORDER_REFLECT101, BORDER_REPLICATE and BORDER_CONSTANT border types.

getMaxFilter_GPU()

Ptr<BaseFilter_GPU> cv::gpu::getMaxFilter_GPU	(	int	srcType,
		int	dstType,
		const Size &	ksize,
		Point	anchor = Point(-1,-1)
	)

returns maximum filter

getMinFilter_GPU()

Ptr<BaseFilter_GPU> cv::gpu::getMinFilter_GPU	(	int	srcType,
		int	dstType,
		const Size &	ksize,
		Point	anchor = Point(-1,-1)
	)

returns minimum filter

getMorphologyFilter_GPU()

Ptr<BaseFilter_GPU> cv::gpu::getMorphologyFilter_GPU	(	int	op,
		int	type,
		const Mat &	kernel,
		const Size &	ksize,
		Point	anchor = Point(-1,-1)
	)

returns 2D morphological filter only MORPH_ERODE and MORPH_DILATE are supported supports CV_8UC1 and CV_8UC4 types kernel must have CV_8UC1 type, one rows and cols == ksize.width * ksize.height

getRowSumFilter_GPU()

Ptr<BaseRowFilter_GPU> cv::gpu::getRowSumFilter_GPU	(	int	srcType,
		int	sumType,
		int	ksize,
		int	anchor = -1
	)

returns horizontal 1D box filter supports only CV_8UC1 source type and CV_32FC1 sum type

graphcut() [1/2]

void cv::gpu::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.

graphcut() [2/2]

void cv::gpu::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.

histEven() [1/4]

void cv::gpu::histEven	(	const GpuMat &	src,
		GpuMat &	hist,
		int	histSize,
		int	lowerLevel,
		int	upperLevel,
		Stream &	stream = Stream::Null()
	)

Calculates histogram with evenly distributed bins for signle channel source. Supports CV_8UC1, CV_16UC1 and CV_16SC1 source types. Output hist will have one row and histSize cols and CV_32SC1 type.

histEven() [2/4]

void cv::gpu::histEven	(	const GpuMat &	src,
		GpuMat &	hist,
		GpuMat &	buf,
		int	histSize,
		int	lowerLevel,
		int	upperLevel,
		Stream &	stream = Stream::Null()
	)

histEven() [3/4]

void cv::gpu::histEven	(	const GpuMat &	src,
		GpuMat	hist[4],
		int	histSize[4],
		int	lowerLevel[4],
		int	upperLevel[4],
		Stream &	stream = Stream::Null()
	)

Calculates histogram with evenly distributed bins for four-channel source. All channels of source are processed separately. Supports CV_8UC4, CV_16UC4 and CV_16SC4 source types. Output hist[i] will have one row and histSize[i] cols and CV_32SC1 type.

histEven() [4/4]

void cv::gpu::histEven	(	const GpuMat &	src,
		GpuMat	hist[4],
		GpuMat &	buf,
		int	histSize[4],
		int	lowerLevel[4],
		int	upperLevel[4],
		Stream &	stream = Stream::Null()
	)

histRange() [1/4]

void cv::gpu::histRange	(	const GpuMat &	src,
		GpuMat &	hist,
		const GpuMat &	levels,
		Stream &	stream = Stream::Null()
	)

Calculates histogram with bins determined by levels array. levels must have one row and CV_32SC1 type if source has integer type or CV_32FC1 otherwise. Supports CV_8UC1, CV_16UC1, CV_16SC1 and CV_32FC1 source types. Output hist will have one row and (levels.cols-1) cols and CV_32SC1 type.

histRange() [2/4]

void cv::gpu::histRange	(	const GpuMat &	src,
		GpuMat &	hist,
		const GpuMat &	levels,
		GpuMat &	buf,
		Stream &	stream = Stream::Null()
	)

histRange() [3/4]

void cv::gpu::histRange	(	const GpuMat &	src,
		GpuMat	hist[4],
		const GpuMat	levels[4],
		Stream &	stream = Stream::Null()
	)

Calculates histogram with bins determined by levels array. All levels must have one row and CV_32SC1 type if source has integer type or CV_32FC1 otherwise. All channels of source are processed separately. Supports CV_8UC4, CV_16UC4, CV_16SC4 and CV_32FC4 source types. Output hist[i] will have one row and (levels[i].cols-1) cols and CV_32SC1 type.

histRange() [4/4]

void cv::gpu::histRange	(	const GpuMat &	src,
		GpuMat	hist[4],
		const GpuMat	levels[4],
		GpuMat &	buf,
		Stream &	stream = Stream::Null()
	)

HoughCircles() [1/2]

void cv::gpu::HoughCircles	(	const GpuMat &	src,
		GpuMat &	circles,
		int	method,
		float	dp,
		float	minDist,
		int	cannyThreshold,
		int	votesThreshold,
		int	minRadius,
		int	maxRadius,
		int	maxCircles = 4096
	)

HoughCircles() [2/2]

void cv::gpu::HoughCircles	(	const GpuMat &	src,
		GpuMat &	circles,
		HoughCirclesBuf &	buf,
		int	method,
		float	dp,
		float	minDist,
		int	cannyThreshold,
		int	votesThreshold,
		int	minRadius,
		int	maxRadius,
		int	maxCircles = 4096
	)

HoughCirclesDownload()

void cv::gpu::HoughCirclesDownload	(	const GpuMat &	d_circles,
		OutputArray	h_circles
	)

HoughLines() [1/2]

void cv::gpu::HoughLines	(	const GpuMat &	src,
		GpuMat &	lines,
		float	rho,
		float	theta,
		int	threshold,
		bool	doSort = false,
		int	maxLines = 4096
	)

HoughLines() [2/2]

void cv::gpu::HoughLines	(	const GpuMat &	src,
		GpuMat &	lines,
		HoughLinesBuf &	buf,
		float	rho,
		float	theta,
		int	threshold,
		bool	doSort = false,
		int	maxLines = 4096
	)

HoughLinesDownload()

void cv::gpu::HoughLinesDownload	(	const GpuMat &	d_lines,
		OutputArray	h_lines,
		OutputArray	h_votes = noArray()
	)

HoughLinesP()

void cv::gpu::HoughLinesP	(	const GpuMat &	image,
		GpuMat &	lines,
		HoughLinesBuf &	buf,
		float	rho,
		float	theta,
		int	minLineLength,
		int	maxLineGap,
		int	maxLines = 4096
	)

HoughLinesP.

finds line segments in the black-n-white image using probabalistic Hough transform

integral()

void cv::gpu::integral	(	const GpuMat &	src,
		GpuMat &	sum,
		Stream &	stream = Stream::Null()
	)

computes the integral image sum will have CV_32S type, but will contain unsigned int values supports only CV_8UC1 source type

integralBuffered()

void cv::gpu::integralBuffered	(	const GpuMat &	src,
		GpuMat &	sum,
		GpuMat &	buffer,
		Stream &	stream = Stream::Null()
	)

buffered version

interpolateFrames()

void cv::gpu::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()
	)

Interpolate frames (images) using provided optical flow (displacement field). frame0 - frame 0 (32-bit floating point images, single channel) frame1 - frame 1 (the same type and size) fu - forward horizontal displacement fv - forward vertical displacement bu - backward horizontal displacement bv - backward vertical displacement pos - new frame position newFrame - new frame buf - temporary buffer, will have width x 6*height size, CV_32FC1 type and contain 6 GpuMat; occlusion masks 0, occlusion masks 1, interpolated forward flow 0, interpolated forward flow 1, interpolated backward flow 0, interpolated backward flow 1

labelComponents()

void cv::gpu::labelComponents	(	const GpuMat &	mask,
		GpuMat &	components,
		int	flags = 0,
		Stream &	stream = Stream::Null()
	)

performs connected componnents labeling.

Laplacian()

void cv::gpu::Laplacian	(	const GpuMat &	src,
		GpuMat &	dst,
		int	ddepth,
		int	ksize = 1,
		double	scale = 1,
		int	borderType = BORDER_DEFAULT,
		Stream &	stream = Stream::Null()
	)

applies Laplacian operator to the image supports only ksize = 1 and ksize = 3

log()

void cv::gpu::log	(	const GpuMat &	a,
		GpuMat &	b,
		Stream &	stream = Stream::Null()
	)

computes natural logarithm of absolute value of each matrix element: b = log(abs(a)) supports CV_8U, CV_16U, CV_16S and CV_32F depth

lshift()

void cv::gpu::lshift	(	const GpuMat &	src,
		Scalar_< int >	sc,
		GpuMat &	dst,
		Stream &	stream = Stream::Null()
	)

pixel by pixel left shift of an image by a constant value supports 1, 3 and 4 channels images with CV_8U, CV_16U or CV_32S depth

LUT()

void cv::gpu::LUT	(	const GpuMat &	src,
		const Mat &	lut,
		GpuMat &	dst,
		Stream &	stream = Stream::Null()
	)

transforms 8-bit unsigned integers using lookup table: dst(i)=lut(src(i)) destination array will have the depth type as lut and the same channels number as source supports CV_8UC1, CV_8UC3 types

magnitude() [1/2]

void cv::gpu::magnitude	(	const GpuMat &	xy,
		GpuMat &	magnitude,
		Stream &	stream = Stream::Null()
	)

computes magnitude of complex (x(i).re, x(i).im) vector supports only CV_32FC2 type

magnitude() [2/2]

void cv::gpu::magnitude	(	const GpuMat &	x,
		const GpuMat &	y,
		GpuMat &	magnitude,
		Stream &	stream = Stream::Null()
	)

computes magnitude of each (x(i), y(i)) vector supports only floating-point source

magnitudeSqr() [1/2]

void cv::gpu::magnitudeSqr	(	const GpuMat &	xy,
		GpuMat &	magnitude,
		Stream &	stream = Stream::Null()
	)

computes squared magnitude of complex (x(i).re, x(i).im) vector supports only CV_32FC2 type

magnitudeSqr() [2/2]

void cv::gpu::magnitudeSqr	(	const GpuMat &	x,
		const GpuMat &	y,
		GpuMat &	magnitude,
		Stream &	stream = Stream::Null()
	)

computes squared magnitude of each (x(i), y(i)) vector supports only floating-point source

matchTemplate() [1/2]

void cv::gpu::matchTemplate	(	const GpuMat &	image,
		const GpuMat &	templ,
		GpuMat &	result,
		int	method,
		Stream &	stream = Stream::Null()
	)

computes the proximity map for the raster template and the image where the template is searched for

matchTemplate() [2/2]

void cv::gpu::matchTemplate	(	const GpuMat &	image,
		const GpuMat &	templ,
		GpuMat &	result,
		int	method,
		MatchTemplateBuf &	buf,
		Stream &	stream = Stream::Null()
	)

computes the proximity map for the raster template and the image where the template is searched for

max() [1/2]

void cv::gpu::max	(	const GpuMat &	src1,
		const GpuMat &	src2,
		GpuMat &	dst,
		Stream &	stream = Stream::Null()
	)

computes per-element maximum of two arrays (dst = max(src1, src2))

max() [2/2]

void cv::gpu::max	(	const GpuMat &	src1,
		double	src2,
		GpuMat &	dst,
		Stream &	stream = Stream::Null()
	)

computes per-element maximum of array and scalar (dst = max(src1, src2))

meanShiftFiltering()

void cv::gpu::meanShiftFiltering	(	const GpuMat &	src,
		GpuMat &	dst,
		int	sp,
		int	sr,
		TermCriteria	criteria = TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 5, 1),
		Stream &	stream = Stream::Null()
	)

Does mean shift filtering on GPU.

meanShiftProc()

void cv::gpu::meanShiftProc	(	const GpuMat &	src,
		GpuMat &	dstr,
		GpuMat &	dstsp,
		int	sp,
		int	sr,
		TermCriteria	criteria = TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 5, 1),
		Stream &	stream = Stream::Null()
	)

Does mean shift procedure on GPU.

meanShiftSegmentation()

void cv::gpu::meanShiftSegmentation	(	const GpuMat &	src,
		Mat &	dst,
		int	sp,
		int	sr,
		int	minsize,
		TermCriteria	criteria = TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 5, 1)
	)

Does mean shift segmentation with elimination of small regions.

meanStdDev() [1/2]

void cv::gpu::meanStdDev	(	const GpuMat &	mtx,
		Scalar &	mean,
		Scalar &	stddev
	)

computes mean value and standard deviation of all or selected array elements supports only CV_8UC1 type

meanStdDev() [2/2]

void cv::gpu::meanStdDev	(	const GpuMat &	mtx,
		Scalar &	mean,
		Scalar &	stddev,
		GpuMat &	buf
	)

buffered version

merge() [1/2]

void cv::gpu::merge	(	const GpuMat *	src,
		size_t	n,
		GpuMat &	dst,
		Stream &	stream = Stream::Null()
	)

makes multi-channel array out of several single-channel arrays

merge() [2/2]

void cv::gpu::merge	(	const std::vector< GpuMat > &	src,
		GpuMat &	dst,
		Stream &	stream = Stream::Null()
	)

makes multi-channel array out of several single-channel arrays

min() [1/2]

void cv::gpu::min	(	const GpuMat &	src1,
		const GpuMat &	src2,
		GpuMat &	dst,
		Stream &	stream = Stream::Null()
	)

computes per-element minimum of two arrays (dst = min(src1, src2))

min() [2/2]

void cv::gpu::min	(	const GpuMat &	src1,
		double	src2,
		GpuMat &	dst,
		Stream &	stream = Stream::Null()
	)

computes per-element minimum of array and scalar (dst = min(src1, src2))

minMax() [1/2]

void cv::gpu::minMax	(	const GpuMat &	src,
		double *	minVal,
		double *	maxVal = 0,
		const GpuMat &	mask = GpuMat()
	)

finds global minimum and maximum array elements and returns their values

minMax() [2/2]

void cv::gpu::minMax	(	const GpuMat &	src,
		double *	minVal,
		double *	maxVal,
		const GpuMat &	mask,
		GpuMat &	buf
	)

minMaxLoc() [1/2]

void cv::gpu::minMaxLoc	(	const GpuMat &	src,
		double *	minVal,
		double *	maxVal = 0,
		Point *	minLoc = 0,
		Point *	maxLoc = 0,
		const GpuMat &	mask = GpuMat()
	)

finds global minimum and maximum array elements and returns their values with locations

minMaxLoc() [2/2]

void cv::gpu::minMaxLoc	(	const GpuMat &	src,
		double *	minVal,
		double *	maxVal,
		Point *	minLoc,
		Point *	maxLoc,
		const GpuMat &	mask,
		GpuMat &	valbuf,
		GpuMat &	locbuf
	)

morphologyEx() [1/2]

void cv::gpu::morphologyEx	(	const GpuMat &	src,
		GpuMat &	dst,
		int	op,
		const Mat &	kernel,
		Point	anchor = Point(-1, -1),
		int	iterations = 1
	)

applies an advanced morphological operation to the image

morphologyEx() [2/2]

void cv::gpu::morphologyEx	(	const GpuMat &	src,
		GpuMat &	dst,
		int	op,
		const Mat &	kernel,
		GpuMat &	buf1,
		GpuMat &	buf2,
		Point	anchor = Point(-1, -1),
		int	iterations = 1,
		Stream &	stream = Stream::Null()
	)

mulAndScaleSpectrums()

void cv::gpu::mulAndScaleSpectrums	(	const GpuMat &	a,
		const GpuMat &	b,
		GpuMat &	c,
		int	flags,
		float	scale,
		bool	conjB = false,
		Stream &	stream = Stream::Null()
	)

performs per-element multiplication of two full (not packed) Fourier spectrums supports 32FC2 matrices only (interleaved format)

mulSpectrums()

void cv::gpu::mulSpectrums	(	const GpuMat &	a,
		const GpuMat &	b,
		GpuMat &	c,
		int	flags,
		bool	conjB = false,
		Stream &	stream = Stream::Null()
	)

performs per-element multiplication of two full (not packed) Fourier spectrums supports 32FC2 matrices only (interleaved format)

multiply() [1/2]

void cv::gpu::multiply	(	const GpuMat &	a,
		const GpuMat &	b,
		GpuMat &	c,
		double	scale = 1,
		int	dtype = -1,
		Stream &	stream = Stream::Null()
	)

computes element-wise weighted product of the two arrays (c = scale * a * b)

multiply() [2/2]

void cv::gpu::multiply	(	const GpuMat &	a,
		const Scalar &	sc,
		GpuMat &	c,
		double	scale = 1,
		int	dtype = -1,
		Stream &	stream = Stream::Null()
	)

weighted multiplies matrix to a scalar (c = scale * a * s)

nonLocalMeans()

void cv::gpu::nonLocalMeans	(	const GpuMat &	src,
		GpuMat &	dst,
		float	h,
		int	search_window = 21,
		int	block_size = 7,
		int	borderMode = BORDER_DEFAULT,
		Stream &	s = Stream::Null()
	)

Brute force non-local means algorith (slow but universal)

norm() [1/4]

double cv::gpu::norm	(	const GpuMat &	src1,
		int	normType = NORM_L2
	)

computes norm of array supports NORM_INF, NORM_L1, NORM_L2 supports all matrices except 64F

norm() [2/4]

double cv::gpu::norm	(	const GpuMat &	src1,
		int	normType,
		GpuMat &	buf
	)

norm() [3/4]

double cv::gpu::norm	(	const GpuMat &	src1,
		int	normType,
		const GpuMat &	mask,
		GpuMat &	buf
	)

norm() [4/4]

double cv::gpu::norm	(	const GpuMat &	src1,
		const GpuMat &	src2,
		int	normType = NORM_L2
	)

computes norm of the difference between two arrays supports NORM_INF, NORM_L1, NORM_L2 supports only CV_8UC1 type

normalize() [1/2]

void cv::gpu::normalize	(	const GpuMat &	src,
		GpuMat &	dst,
		double	alpha = 1,
		double	beta = 0,
		int	norm_type = NORM_L2,
		int	dtype = -1,
		const GpuMat &	mask = GpuMat()
	)

scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values

normalize() [2/2]

void cv::gpu::normalize	(	const GpuMat &	src,
		GpuMat &	dst,
		double	a,
		double	b,
		int	norm_type,
		int	dtype,
		const GpuMat &	mask,
		GpuMat &	norm_buf,
		GpuMat &	cvt_buf
	)

phase()

void cv::gpu::phase	(	const GpuMat &	x,
		const GpuMat &	y,
		GpuMat &	angle,
		bool	angleInDegrees = false,
		Stream &	stream = Stream::Null()
	)

computes angle (angle(i)) of each (x(i), y(i)) vector supports only floating-point source

polarToCart()

void cv::gpu::polarToCart	(	const GpuMat &	magnitude,
		const GpuMat &	angle,
		GpuMat &	x,
		GpuMat &	y,
		bool	angleInDegrees = false,
		Stream &	stream = Stream::Null()
	)

converts polar coordinates to Cartesian supports only floating-point source

pow()

void cv::gpu::pow	(	const GpuMat &	src,
		double	power,
		GpuMat &	dst,
		Stream &	stream = Stream::Null()
	)

computes power of each matrix element:

supports all, except depth == CV_64F

printCudaDeviceInfo()

void cv::gpu::printCudaDeviceInfo

(

int

device

)

printShortCudaDeviceInfo()

void cv::gpu::printShortCudaDeviceInfo

(

int

device

)

projectPoints()

void cv::gpu::projectPoints	(	const GpuMat &	src,
		const Mat &	rvec,
		const Mat &	tvec,
		const Mat &	camera_mat,
		const Mat &	dist_coef,
		GpuMat &	dst,
		Stream &	stream = Stream::Null()
	)

pyrDown()

void cv::gpu::pyrDown	(	const GpuMat &	src,
		GpuMat &	dst,
		Stream &	stream = Stream::Null()
	)

smoothes the source image and downsamples it

pyrUp()

void cv::gpu::pyrUp	(	const GpuMat &	src,
		GpuMat &	dst,
		Stream &	stream = Stream::Null()
	)

upsamples the source image and then smoothes it

rectStdDev()

void cv::gpu::rectStdDev	(	const GpuMat &	src,
		const GpuMat &	sqr,
		GpuMat &	dst,
		const Rect &	rect,
		Stream &	stream = Stream::Null()
	)

computes the standard deviation of integral images supports only CV_32SC1 source type and CV_32FC1 sqr type output will have CV_32FC1 type

reduce()

void cv::gpu::reduce	(	const GpuMat &	mtx,
		GpuMat &	vec,
		int	dim,
		int	reduceOp,
		int	dtype = -1,
		Stream &	stream = Stream::Null()
	)

reduces a matrix to a vector

registerPageLocked()

void cv::gpu::registerPageLocked

(

Mat &

m

)

remap()

void cv::gpu::remap	(	const GpuMat &	src,
		GpuMat &	dst,
		const GpuMat &	xmap,
		const GpuMat &	ymap,
		int	interpolation,
		int	borderMode = BORDER_CONSTANT,
		Scalar	borderValue = Scalar(),
		Stream &	stream = Stream::Null()
	)

DST[x,y] = SRC[xmap[x,y],ymap[x,y]] supports only CV_32FC1 map type

reprojectImageTo3D()

void cv::gpu::reprojectImageTo3D	(	const GpuMat &	disp,
		GpuMat &	xyzw,
		const Mat &	Q,
		int	dst_cn = 4,
		Stream &	stream = Stream::Null()
	)

Reprojects disparity image to 3D space. Supports CV_8U and CV_16S types of input disparity. The output is a 3- or 4-channel floating-point matrix. Each element of this matrix will contain the 3D coordinates of the point (x,y,z,1), computed from the disparity map. Q is the 4x4 perspective transformation matrix that can be obtained with cvStereoRectify.

resetDevice()

void cv::gpu::resetDevice

(

)

Explicitly destroys and cleans up all resources associated with the current device in the current process. Any subsequent API call to this device will reinitialize the device.

resize()

void cv::gpu::resize	(	const GpuMat &	src,
		GpuMat &	dst,
		Size	dsize,
		double	fx = 0,
		double	fy = 0,
		int	interpolation = INTER_LINEAR,
		Stream &	stream = Stream::Null()
	)

resizes the image Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, INTER_AREA

rotate()

void cv::gpu::rotate	(	const GpuMat &	src,
		GpuMat &	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 supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC supports 1, 3 or 4 channels images with CV_8U, CV_16U or CV_32F depth

rshift()

void cv::gpu::rshift	(	const GpuMat &	src,
		Scalar_< int >	sc,
		GpuMat &	dst,
		Stream &	stream = Stream::Null()
	)

pixel by pixel right shift of an image by a constant value supports 1, 3 and 4 channels images with integers elements

Scharr() [1/2]

void cv::gpu::Scharr	(	const GpuMat &	src,
		GpuMat &	dst,
		int	ddepth,
		int	dx,
		int	dy,
		double	scale = 1,
		int	rowBorderType = BORDER_DEFAULT,
		int	columnBorderType = -1
	)

applies the vertical or horizontal Scharr operator to the image

Scharr() [2/2]

void cv::gpu::Scharr	(	const GpuMat &	src,
		GpuMat &	dst,
		int	ddepth,
		int	dx,
		int	dy,
		GpuMat &	buf,
		double	scale = 1,
		int	rowBorderType = BORDER_DEFAULT,
		int	columnBorderType = -1,
		Stream &	stream = Stream::Null()
	)

sepFilter2D() [1/2]

void cv::gpu::sepFilter2D	(	const GpuMat &	src,
		GpuMat &	dst,
		int	ddepth,
		const Mat &	kernelX,
		const Mat &	kernelY,
		Point	anchor = Point(-1,-1),
		int	rowBorderType = BORDER_DEFAULT,
		int	columnBorderType = -1
	)

applies separable 2D linear filter to the image

sepFilter2D() [2/2]

void cv::gpu::sepFilter2D	(	const GpuMat &	src,
		GpuMat &	dst,
		int	ddepth,
		const Mat &	kernelX,
		const Mat &	kernelY,
		GpuMat &	buf,
		Point	anchor = Point(-1,-1),
		int	rowBorderType = BORDER_DEFAULT,
		int	columnBorderType = -1,
		Stream &	stream = Stream::Null()
	)

setDevice()

void cv::gpu::setDevice

(

int

device

)

Functions below throw cv::Expception if the library is compiled without Cuda.

setGlDevice()

void cv::gpu::setGlDevice

(

int

device = 0

)

set a CUDA device to use OpenGL interoperability

Sobel() [1/2]

void cv::gpu::Sobel	(	const GpuMat &	src,
		GpuMat &	dst,
		int	ddepth,
		int	dx,
		int	dy,
		int	ksize = 3,
		double	scale = 1,
		int	rowBorderType = BORDER_DEFAULT,
		int	columnBorderType = -1
	)

applies generalized Sobel operator to the image

Sobel() [2/2]

void cv::gpu::Sobel	(	const GpuMat &	src,
		GpuMat &	dst,
		int	ddepth,
		int	dx,
		int	dy,
		GpuMat &	buf,
		int	ksize = 3,
		double	scale = 1,
		int	rowBorderType = BORDER_DEFAULT,
		int	columnBorderType = -1,
		Stream &	stream = Stream::Null()
	)

solvePnPRansac()

void cv::gpu::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
	)

split() [1/2]

void cv::gpu::split	(	const GpuMat &	src,
		GpuMat *	dst,
		Stream &	stream = Stream::Null()
	)

copies each plane of a multi-channel array to a dedicated array

split() [2/2]

void cv::gpu::split	(	const GpuMat &	src,
		std::vector< GpuMat > &	dst,
		Stream &	stream = Stream::Null()
	)

copies each plane of a multi-channel array to a dedicated array

sqr()

void cv::gpu::sqr	(	const GpuMat &	src,
		GpuMat &	dst,
		Stream &	stream = Stream::Null()
	)

computes square of each pixel in an image supports CV_8U, CV_16U, CV_16S and CV_32F depth

sqrIntegral()

void cv::gpu::sqrIntegral	(	const GpuMat &	src,
		GpuMat &	sqsum,
		Stream &	stream = Stream::Null()
	)

computes squared integral image result matrix will have 64F type, but will contain 64U values supports source images of 8UC1 type only

sqrSum() [1/3]

Scalar cv::gpu::sqrSum

(

const GpuMat &

src

)

computes squared sum of array elements supports only single channel images

sqrSum() [2/3]

Scalar cv::gpu::sqrSum	(	const GpuMat &	src,
		GpuMat &	buf
	)

sqrSum() [3/3]

Scalar cv::gpu::sqrSum	(	const GpuMat &	src,
		const GpuMat &	mask,
		GpuMat &	buf
	)

sqrt()

void cv::gpu::sqrt	(	const GpuMat &	src,
		GpuMat &	dst,
		Stream &	stream = Stream::Null()
	)

computes square root of each pixel in an image supports CV_8U, CV_16U, CV_16S and CV_32F depth

subtract() [1/2]

void cv::gpu::subtract	(	const GpuMat &	a,
		const GpuMat &	b,
		GpuMat &	c,
		const GpuMat &	mask = GpuMat(),
		int	dtype = -1,
		Stream &	stream = Stream::Null()
	)

subtracts one matrix from another (c = a - b)

subtract() [2/2]

void cv::gpu::subtract	(	const GpuMat &	a,
		const Scalar &	sc,
		GpuMat &	c,
		const GpuMat &	mask = GpuMat(),
		int	dtype = -1,
		Stream &	stream = Stream::Null()
	)

subtracts scalar from a matrix (c = a - s)

sum() [1/3]

Scalar cv::gpu::sum

(

const GpuMat &

src

)

computes sum of array elements supports only single channel images

sum() [2/3]

Scalar cv::gpu::sum	(	const GpuMat &	src,
		GpuMat &	buf
	)

sum() [3/3]

Scalar cv::gpu::sum	(	const GpuMat &	src,
		const GpuMat &	mask,
		GpuMat &	buf
	)

swap()

void cv::gpu::swap ( GpuMat &  a, GpuMat &  b  )

inline

swapChannels()

void cv::gpu::swapChannels	(	GpuMat &	image,
		const int	dstOrder[4],
		Stream &	stream = Stream::Null()
	)

swap channels 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.

threshold()

double cv::gpu::threshold	(	const GpuMat &	src,
		GpuMat &	dst,
		double	thresh,
		double	maxval,
		int	type,
		Stream &	stream = Stream::Null()
	)

applies fixed threshold to the image

transformPoints()

void cv::gpu::transformPoints	(	const GpuMat &	src,
		const Mat &	rvec,
		const Mat &	tvec,
		GpuMat &	dst,
		Stream &	stream = Stream::Null()
	)

transpose()

void cv::gpu::transpose	(	const GpuMat &	src1,
		GpuMat &	dst,
		Stream &	stream = Stream::Null()
	)

transposes the matrix supports matrix with element size = 1, 4 and 8 bytes (CV_8UC1, CV_8UC4, CV_16UC2, CV_32FC1, etc)

unregisterPageLocked()

void cv::gpu::unregisterPageLocked

(

Mat &

m

)

warpAffine()

void cv::gpu::warpAffine	(	const GpuMat &	src,
		GpuMat &	dst,
		const Mat &	M,
		Size	dsize,
		int	flags = INTER_LINEAR,
		int	borderMode = BORDER_CONSTANT,
		Scalar	borderValue = Scalar(),
		Stream &	stream = Stream::Null()
	)

warps the image using affine transformation Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC

warpPerspective()

void cv::gpu::warpPerspective	(	const GpuMat &	src,
		GpuMat &	dst,
		const Mat &	M,
		Size	dsize,
		int	flags = INTER_LINEAR,
		int	borderMode = BORDER_CONSTANT,
		Scalar	borderValue = Scalar(),
		Stream &	stream = Stream::Null()
	)

warps the image using perspective transformation Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC