OpenCV 4.11.0-pre
Open Source Computer Vision
Loading...
Searching...
No Matches
cv::cuda Namespace Reference

Classes

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

Enumerations

enum  AlphaCompTypes {
  ALPHA_OVER ,
  ALPHA_IN ,
  ALPHA_OUT ,
  ALPHA_ATOP ,
  ALPHA_XOR ,
  ALPHA_PLUS ,
  ALPHA_OVER_PREMUL ,
  ALPHA_IN_PREMUL ,
  ALPHA_OUT_PREMUL ,
  ALPHA_ATOP_PREMUL ,
  ALPHA_XOR_PREMUL ,
  ALPHA_PLUS_PREMUL ,
  ALPHA_PREMUL
}
 
enum  ConnectedComponentsAlgorithmsTypes {
  CCL_DEFAULT = -1 ,
  CCL_BKE = 0
}
 Connected Components Algorithm. More...
 
enum  DemosaicTypes {
  COLOR_BayerBG2BGR_MHT = 256 ,
  COLOR_BayerGB2BGR_MHT = 257 ,
  COLOR_BayerRG2BGR_MHT = 258 ,
  COLOR_BayerGR2BGR_MHT = 259 ,
  COLOR_BayerBG2RGB_MHT = COLOR_BayerRG2BGR_MHT ,
  COLOR_BayerGB2RGB_MHT = COLOR_BayerGR2BGR_MHT ,
  COLOR_BayerRG2RGB_MHT = COLOR_BayerBG2BGR_MHT ,
  COLOR_BayerGR2RGB_MHT = COLOR_BayerGB2BGR_MHT ,
  COLOR_BayerBG2GRAY_MHT = 260 ,
  COLOR_BayerGB2GRAY_MHT = 261 ,
  COLOR_BayerRG2GRAY_MHT = 262 ,
  COLOR_BayerGR2GRAY_MHT = 263
}
 
enum  FeatureSet {
  FEATURE_SET_COMPUTE_10 = 10 ,
  FEATURE_SET_COMPUTE_11 = 11 ,
  FEATURE_SET_COMPUTE_12 = 12 ,
  FEATURE_SET_COMPUTE_13 = 13 ,
  FEATURE_SET_COMPUTE_20 = 20 ,
  FEATURE_SET_COMPUTE_21 = 21 ,
  FEATURE_SET_COMPUTE_30 = 30 ,
  FEATURE_SET_COMPUTE_32 = 32 ,
  FEATURE_SET_COMPUTE_35 = 35 ,
  FEATURE_SET_COMPUTE_50 = 50 ,
  GLOBAL_ATOMICS = FEATURE_SET_COMPUTE_11 ,
  SHARED_ATOMICS = FEATURE_SET_COMPUTE_12 ,
  NATIVE_DOUBLE = FEATURE_SET_COMPUTE_13 ,
  WARP_SHUFFLE_FUNCTIONS = FEATURE_SET_COMPUTE_30 ,
  DYNAMIC_PARALLELISM = FEATURE_SET_COMPUTE_35
}
 Enumeration providing CUDA computing features. More...
 
enum  MomentsOrder {
  FIRST_ORDER_MOMENTS = 1 ,
  SECOND_ORDER_MOMENTS = 2 ,
  THIRD_ORDER_MOMENTS = 3
}
 Order of image moments. More...
 

Functions

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

Function Documentation

◆ createMedianFilter()

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

Performs median filtering for each point of the source image.

Parameters
srcTypetype of of source image. Only CV_8UC1 images are supported for now.
windowSizeSize of the kernerl used for the filtering. Uses a (windowSize x windowSize) filter.
partitionSpecifies the parallel granularity of the workload. This parameter should be used GPU experts when optimizing performance.

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

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