| OpenCV 5.0.0alpha Open Source Computer Vision

Loading...
Searching...
No Matches
Classes | Enumerations | Functions
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::BackgroundSubtractorFGD > | createBackgroundSubtractorFGD (const FGDParams &params=FGDParams())
| Creates FGD Background Subtractor.
Ptr< cuda::BackgroundSubtractorGMG > | createBackgroundSubtractorGMG (int initializationFrames=120, double decisionThreshold=0.8)
| Creates GMG Background Subtractor.
Ptr< cuda::BackgroundSubtractorMOG > | createBackgroundSubtractorMOG (int history=200, int nmixtures=5, double backgroundRatio=0.7, double noiseSigma=0)
| Creates mixture-of-gaussian background subtractor.
Ptr< cuda::BackgroundSubtractorMOG2 > | createBackgroundSubtractorMOG2 (int history=500, double varThreshold=16, bool detectShadows=true)
| Creates MOG2 Background Subtractor.
Ptr< Filter > | createBoxFilter (int srcType, int dstType, Size ksize, Point anchor=Point(-1, -1), int borderMode=BORDER_DEFAULT, Scalar borderVal=Scalar::all(0))
| Creates a normalized 2D box filter.
Ptr< Filter > | createBoxMaxFilter (int srcType, Size ksize, Point anchor=Point(-1, -1), int borderMode=BORDER_DEFAULT, Scalar borderVal=Scalar::all(0))
| Creates the maximum filter.
Ptr< Filter > | createBoxMinFilter (int srcType, Size ksize, Point anchor=Point(-1, -1), int borderMode=BORDER_DEFAULT, Scalar borderVal=Scalar::all(0))
| Creates the minimum filter.
Ptr< CannyEdgeDetector > | createCannyEdgeDetector (double low_thresh, double high_thresh, int apperture_size=3, bool L2gradient=false)
| Creates implementation for cuda::CannyEdgeDetector .
Ptr< cuda::CLAHE > | createCLAHE (double clipLimit=40.0, Size tileGridSize=Size(8, 8))
| Creates implementation for cuda::CLAHE .
Ptr< Filter > | createColumnSumFilter (int srcType, int dstType, int ksize, int anchor=-1, int borderMode=BORDER_DEFAULT, Scalar borderVal=Scalar::all(0))
| Creates a vertical 1D box filter.
void | createContinuous (int rows, int cols, int type, OutputArray arr)
| Creates a continuous matrix.
Ptr< Convolution > | createConvolution (Size user_block_size=Size())
| Creates implementation for cuda::Convolution .
Ptr< Filter > | createDerivFilter (int srcType, int dstType, int dx, int dy, int ksize, bool normalize=false, double scale=1, int rowBorderMode=BORDER_DEFAULT, int columnBorderMode=-1)
| Creates a generalized Deriv operator.
Ptr< DFT > | createDFT (Size dft_size, int flags)
| Creates implementation for cuda::DFT.
Ptr< cuda::DisparityBilateralFilter > | createDisparityBilateralFilter (int ndisp=64, int radius=3, int iters=1)
| Creates DisparityBilateralFilter object.
Ptr< Filter > | createGaussianFilter (int srcType, int dstType, Size ksize, double sigma1, double sigma2=0, int rowBorderMode=BORDER_DEFAULT, int columnBorderMode=-1)
| Creates a Gaussian filter.
Ptr< GeneralizedHoughBallard > | createGeneralizedHoughBallard ()
| Creates implementation for generalized hough transform from [15] .
Ptr< GeneralizedHoughGuil > | createGeneralizedHoughGuil ()
| Creates implementation for generalized hough transform from [115] .
Ptr< CornersDetector > | createGoodFeaturesToTrackDetector (int srcType, int maxCorners=1000, double qualityLevel=0.01, double minDistance=0.0, int blockSize=3, bool useHarrisDetector=false, double harrisK=0.04)
| Creates implementation for cuda::CornersDetector .
GpuMat | createGpuMatFromCudaMemory (int rows, int cols, int type, size_t cudaMemoryAddress, size_t step=Mat::AUTO_STEP)
| Bindings overload to create a GpuMat from existing GPU memory.
GpuMat | createGpuMatFromCudaMemory (Size size, int type, size_t cudaMemoryAddress, size_t step=Mat::AUTO_STEP)
Ptr< CornernessCriteria > | createHarrisCorner (int srcType, int blockSize, int ksize, double k, int borderType=BORDER_REFLECT101)
| Creates implementation for Harris cornerness criteria.
Ptr< HoughCirclesDetector > | createHoughCirclesDetector (float dp, float minDist, int cannyThreshold, int votesThreshold, int minRadius, int maxRadius, int maxCircles=4096)
| Creates implementation for cuda::HoughCirclesDetector .
Ptr< HoughLinesDetector > | createHoughLinesDetector (float rho, float theta, int threshold, bool doSort=false, int maxLines=4096)
| Creates implementation for cuda::HoughLinesDetector .
Ptr< HoughSegmentDetector > | createHoughSegmentDetector (float rho, float theta, int minLineLength, int maxLineGap, int maxLines=4096, int threshold=-1)
| Creates implementation for cuda::HoughSegmentDetector .
Ptr< ImagePyramid > | createImagePyramid (InputArray img, int nLayers=-1, Stream &stream=Stream::Null())
Ptr< Filter > | createLaplacianFilter (int srcType, int dstType, int ksize=1, double scale=1, int borderMode=BORDER_DEFAULT, Scalar borderVal=Scalar::all(0))
| Creates a Laplacian operator.
Ptr< Filter > | createLinearFilter (int srcType, int dstType, InputArray kernel, Point anchor=Point(-1, -1), int borderMode=BORDER_DEFAULT, Scalar borderVal=Scalar::all(0))
| Creates a non-separable linear 2D filter.
Ptr< LookUpTable > | createLookUpTable (InputArray lut)
| Creates implementation for cuda::LookUpTable .
Ptr< Filter > | createMedianFilter (int srcType, int windowSize, int partition=128)
| Performs median filtering for each point of the source image.
Ptr< CornernessCriteria > | createMinEigenValCorner (int srcType, int blockSize, int ksize, int borderType=BORDER_REFLECT101)
| Creates implementation for the minimum eigen value of a 2x2 derivative covariation matrix (the cornerness criteria).
Ptr< Filter > | createMorphologyFilter (int op, int srcType, InputArray kernel, Point anchor=Point(-1, -1), int iterations=1)
| Creates a 2D morphological filter.
void | createOpticalFlowNeedleMap (const GpuMat &u, const GpuMat &v, GpuMat &vertex, GpuMat &colors)
Ptr< Filter > | createRowSumFilter (int srcType, int dstType, int ksize, int anchor=-1, int borderMode=BORDER_DEFAULT, Scalar borderVal=Scalar::all(0))
| Creates a horizontal 1D box filter.
Ptr< Filter > | createScharrFilter (int srcType, int dstType, int dx, int dy, double scale=1, int rowBorderMode=BORDER_DEFAULT, int columnBorderMode=-1)
| Creates a vertical or horizontal Scharr operator.
Ptr< Filter > | createSeparableLinearFilter (int srcType, int dstType, InputArray rowKernel, InputArray columnKernel, Point anchor=Point(-1,-1), int rowBorderMode=BORDER_DEFAULT, int columnBorderMode=-1)
| Creates a separable linear filter. In-place processing is supported.
Ptr< Filter > | createSobelFilter (int srcType, int dstType, int dx, int dy, int ksize=3, double scale=1, int rowBorderMode=BORDER_DEFAULT, int columnBorderMode=-1)
| Creates a Sobel operator.
Ptr< cuda::StereoBeliefPropagation > | createStereoBeliefPropagation (int ndisp=64, int iters=5, int levels=5, int msg_type=CV_32F)
| Creates StereoBeliefPropagation object.
Ptr< cuda::StereoBM > | createStereoBM (int numDisparities=64, int blockSize=19)
| Creates StereoBM object.
Ptr< cuda::StereoConstantSpaceBP > | createStereoConstantSpaceBP (int ndisp=128, int iters=8, int levels=4, int nr_plane=4, int msg_type=CV_32F)
| Creates StereoConstantSpaceBP object.
Ptr< cuda::StereoSGM > | createStereoSGM (int minDisparity=0, int numDisparities=128, int P1=10, int P2=120, int uniquenessRatio=5, int mode=cv::cuda::StereoSGM::MODE_HH4)
| Creates StereoSGM object.
Ptr< TemplateMatching > | createTemplateMatching (int srcType, int method, Size user_block_size=Size())
| Creates implementation for cuda::TemplateMatching .
void | cvtColor (InputArray src, OutputArray dst, int code, int dcn=0, Stream &stream=Stream::Null())
| Converts an image from one color space to another.
void | demosaicing (InputArray src, OutputArray dst, int code, int dcn=-1, Stream &stream=Stream::Null())
| Converts an image from Bayer pattern to RGB or grayscale.
bool | deviceSupports (FeatureSet feature_set)
| checks whether current device supports the given feature
void | dft (InputArray src, OutputArray dst, Size dft_size, int flags=0, Stream &stream=Stream::Null())
| Performs a forward or inverse discrete Fourier transform (1D or 2D) of the floating point matrix.
void | divide (InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1, Stream &stream=Stream::Null())
| Computes a matrix-matrix or matrix-scalar division.
void | 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

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

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

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