OpenCV  2.4.13.6
Open Source Computer Vision
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< intPtrStepSzi
 
typedef PtrStep< unsigned char > PtrStepb
 
typedef PtrStep< float > PtrStepf
 
typedef PtrStep< intPtrStepi
 
typedef DevMem2D_< unsigned char > DevMem2Db
 
typedef DevMem2Db DevMem2D
 
typedef DevMem2D_< float > DevMem2Df
 
typedef DevMem2D_< intDevMem2Di
 
typedef PtrElemStep_< unsigned char > PtrElemStep
 
typedef PtrElemStep_< float > PtrElemStepf
 
typedef PtrElemStep_< intPtrElemStepi
 

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_GPUcreateFilter2D_GPU (const Ptr< BaseFilter_GPU > &filter2D, int srcType, int dstType)
 returns the non-separable filter engine with the specified filter More...
 
Ptr< FilterEngine_GPUcreateSeparableFilter_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_GPUcreateSeparableFilter_GPU (const Ptr< BaseRowFilter_GPU > &rowFilter, const Ptr< BaseColumnFilter_GPU > &columnFilter, int srcType, int bufType, int dstType, GpuMat &buf)
 
Ptr< BaseRowFilter_GPUgetRowSumFilter_GPU (int srcType, int sumType, int ksize, int anchor=-1)
 
Ptr< BaseColumnFilter_GPUgetColumnSumFilter_GPU (int sumType, int dstType, int ksize, int anchor=-1)
 
Ptr< BaseFilter_GPUgetBoxFilter_GPU (int srcType, int dstType, const Size &ksize, Point anchor=Point(-1, -1))
 
Ptr< FilterEngine_GPUcreateBoxFilter_GPU (int srcType, int dstType, const Size &ksize, const Point &anchor=Point(-1,-1))
 returns box filter engine More...
 
Ptr< BaseFilter_GPUgetMorphologyFilter_GPU (int op, int type, const Mat &kernel, const Size &ksize, Point anchor=Point(-1,-1))
 
Ptr< FilterEngine_GPUcreateMorphologyFilter_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_GPUcreateMorphologyFilter_GPU (int op, int type, const Mat &kernel, GpuMat &buf, const Point &anchor=Point(-1,-1), int iterations=1)
 
Ptr< BaseFilter_GPUgetLinearFilter_GPU (int srcType, int dstType, const Mat &kernel, Point anchor=Point(-1, -1), int borderType=BORDER_DEFAULT)
 
Ptr< FilterEngine_GPUcreateLinearFilter_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_GPUgetLinearRowFilter_GPU (int srcType, int bufType, const Mat &rowKernel, int anchor=-1, int borderType=BORDER_DEFAULT)
 
Ptr< BaseColumnFilter_GPUgetLinearColumnFilter_GPU (int bufType, int dstType, const Mat &columnKernel, int anchor=-1, int borderType=BORDER_DEFAULT)
 
Ptr< FilterEngine_GPUcreateSeparableLinearFilter_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_GPUcreateSeparableLinearFilter_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_GPUcreateDerivFilter_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_GPUcreateDerivFilter_GPU (int srcType, int dstType, int dx, int dy, int ksize, GpuMat &buf, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1)
 
Ptr< FilterEngine_GPUcreateGaussianFilter_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_GPUcreateGaussianFilter_GPU (int type, Size ksize, GpuMat &buf, double sigma1, double sigma2=0, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1)
 
Ptr< BaseFilter_GPUgetMaxFilter_GPU (int srcType, int dstType, const Size &ksize, Point anchor=Point(-1,-1))
 returns maximum filter More...
 
Ptr< BaseFilter_GPUgetMinFilter_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::CLAHEcreateCLAHE (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

§ DevMem2Db

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

§ DevMem2Df

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

§ DevMem2Di

§ PtrElemStep

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

§ PtrElemStepf

§ PtrElemStepi

§ PtrStepb

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

§ PtrStepf

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

§ PtrStepi

§ PtrStepSzb

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

§ PtrStepSzf

§ 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

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