Legacy support#

Topics#

Detailed Description#

Namespaces#

NcvCTprep namespace

Classes#

Name	Description
`class` `cv::cuda::BackgroundSubtractorFGD`	The class discriminates between foreground and background pixels by building and maintaining a model of the background. View details
`class` `cv::cuda::BackgroundSubtractorGMG`	Background/Foreground Segmentation Algorithm. View details
`class` `cv::cuda::FastOpticalFlowBM`	View details
`struct` `cv::cuda::FGDParams`	View details
`struct HaarClassifierCascadeDescriptor`
`struct HaarClassifierNode128`
`struct HaarClassifierNodeDescriptor32`
`struct HaarFeature64`
`struct HaarFeatureDescriptor32`
`struct HaarStage64`
`class` `cv::cuda::ImagePyramid`	View details
`class INCVMemAllocator`
`struct NCVBroxOpticalFlowDescriptor`	Model and solver parameters.
`class NCVMatrix`
`class NCVMatrixAlloc`
`class NCVMatrixReuse`
`class NCVMemNativeAllocator`
`struct NCVMemPtr`
`struct NCVMemSegment`
`class NCVMemStackAllocator`
`struct NcvPoint2D32s`
`struct NcvPoint2D32u`
`struct NcvRect32s`
`struct NcvRect32u`
`struct NcvRect8u`
`struct NcvSize32s`
`struct NcvSize32u`
`class NCVVector`
`class NCVVectorAlloc`
`class NCVVectorReuse`

Enumerations#

enum {
    NCV_SUCCESS,
    NCV_UNKNOWN_ERROR,
    NCV_CUDA_ERROR,
    NCV_NPP_ERROR,
    NCV_FILE_ERROR,
    NCV_NULL_PTR,
    NCV_INCONSISTENT_INPUT,
    NCV_TEXTURE_BIND_ERROR,
    NCV_DIMENSIONS_INVALID,
    NCV_INVALID_ROI,
    NCV_INVALID_STEP,
    NCV_INVALID_SCALE,
    NCV_ALLOCATOR_NOT_INITIALIZED,
    NCV_ALLOCATOR_BAD_ALLOC,
    NCV_ALLOCATOR_BAD_DEALLOC,
    NCV_ALLOCATOR_INSUFFICIENT_CAPACITY,
    NCV_ALLOCATOR_DEALLOC_ORDER,
    NCV_ALLOCATOR_BAD_REUSE,
    NCV_MEM_COPY_ERROR,
    NCV_MEM_RESIDENCE_ERROR,
    NCV_MEM_INSUFFICIENT_CAPACITY,
    NCV_HAAR_INVALID_PIXEL_STEP,
    NCV_HAAR_TOO_MANY_FEATURES_IN_CLASSIFIER,
    NCV_HAAR_TOO_MANY_FEATURES_IN_CASCADE,
    NCV_HAAR_TOO_LARGE_FEATURES,
    NCV_HAAR_XML_LOADING_EXCEPTION,
    NCV_NOIMPL_HAAR_TILTED_FEATURES,
    NCV_NOT_IMPLEMENTED,
    NCV_WARNING_HAAR_DETECTIONS_VECTOR_OVERFLOW,
    NPPST_SUCCESS = NCV_SUCCESS,
    NPPST_ERROR,
    NPPST_CUDA_KERNEL_EXECUTION_ERROR,
    NPPST_NULL_POINTER_ERROR,
    NPPST_TEXTURE_BIND_ERROR,
    NPPST_MEMCPY_ERROR,
    NPPST_MEM_ALLOC_ERR,
    NPPST_MEMFREE_ERR,
    NPPST_INVALID_ROI,
    NPPST_INVALID_STEP,
    NPPST_INVALID_SCALE,
    NPPST_MEM_INSUFFICIENT_BUFFER,
    NPPST_MEM_RESIDENCE_ERROR,
    NPPST_MEM_INTERNAL_ERROR,
    NCV_LAST_STATUS
}

View details

enum {
    NCVPipeObjDet_Default = 0x000,
    NCVPipeObjDet_UseFairImageScaling = 0x001,
    NCVPipeObjDet_FindLargestObject = 0x002,
    NCVPipeObjDet_VisualizeInPlace = 0x004
}

View details

enum NCVMemoryType {
    NCVMemoryTypeNone,
    NCVMemoryTypeHostPageable,
    NCVMemoryTypeHostPinned,
    NCVMemoryTypeDevice
}

View details

Functions#

Return	Name	Description
	`cv::~INCVMemAllocator()`
`Ncv32u`	`cv::alignUp( Ncv32u what, Ncv32u alignment )`
`void`	`cv::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`	`cv::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.
`Ptr< cuda::BackgroundSubtractorFGD >`	`cv::createBackgroundSubtractorFGD(const FGDParams & params = FGDParams())`	Creates FGD Background Subtractor.
`Ptr< cuda::BackgroundSubtractorGMG >`	`cv::createBackgroundSubtractorGMG( int initializationFrames = 120, double decisionThreshold = 0.8 )`	Creates GMG Background Subtractor.
`Ptr< ImagePyramid >`	`cv::createImagePyramid( InputArray img, int nLayers = -1, Stream & stream = Stream::Null() )`
`void`	`cv::createOpticalFlowNeedleMap( const GpuMat & u, const GpuMat & v, GpuMat & vertex, GpuMat & colors )`
`void`	`cv::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`	`cv::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`	`cv::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`	`cv::labelComponents( const GpuMat & mask, GpuMat & components, int flags = 0, Stream & stream = Stream::Null() )`	performs connected componnents labeling.
`NCVStatus`	`cv::memSegCopyHelper( void * dst, NCVMemoryType dstType, const void * src, NCVMemoryType srcType, size_t sz, cudaStream_t cuStream )`
`NCVStatus`	`cv::memSegCopyHelper2D( void * dst, Ncv32u dstPitch, NCVMemoryType dstType, const void * src, Ncv32u srcPitch, NCVMemoryType srcType, Ncv32u widthbytes, Ncv32u height, cudaStream_t cuStream )`
	`cv::NCV_CT_ASSERT(sizeof(HaarClassifierNode128) = =16)`
	`cv::NCV_CT_ASSERT(sizeof(HaarClassifierNodeDescriptor32) = =4)`
	`cv::NCV_CT_ASSERT(sizeof(HaarFeature64) = =8)`
	`cv::NCV_CT_ASSERT(sizeof(HaarFeatureDescriptor32) = =4)`
	`cv::NCV_CT_ASSERT(sizeof(HaarStage64) = =8)`
`NCVStatus`	cv::ncvApplyHaarClassifierCascade_device( NCVMatrix< Ncv32u > & d_integralImage, NCVMatrix< Ncv32f > & d_weights, NCVMatrixAlloc< Ncv32u > & d_pixelMask, Ncv32u & numDetections, HaarClassifierCascadeDescriptor & haar, NCVVector< HaarStage64 > & h_HaarStages, NCVVector< HaarStage64 > & d_HaarStages, NCVVector< HaarClassifierNode128 > & d_HaarNodes, NCVVector< HaarFeature64 > & d_HaarFeatures, NcvBool bMaskElements, NcvSize32u anchorsRoi, Ncv32u pixelStep, Ncv32f scaleArea, INCVMemAllocator & gpuAllocator, INCVMemAllocator & cpuAllocator, cudaDeviceProp & devProp, cudaStream_t cuStream )
`NCVStatus`	`cv::ncvApplyHaarClassifierCascade_host( NCVMatrix< Ncv32u > & h_integralImage, NCVMatrix< Ncv32f > & h_weights, NCVMatrixAlloc< Ncv32u > & h_pixelMask, Ncv32u & numDetections, HaarClassifierCascadeDescriptor & haar, NCVVector< HaarStage64 > & h_HaarStages, NCVVector< HaarClassifierNode128 > & h_HaarNodes, NCVVector< HaarFeature64 > & h_HaarFeatures, NcvBool bMaskElements, NcvSize32u anchorsRoi, Ncv32u pixelStep, Ncv32f scaleArea )`
`NCVStatus`	`cv::NCVBroxOpticalFlow( const NCVBroxOpticalFlowDescriptor desc, INCVMemAllocator & gpu_mem_allocator, const NCVMatrix< Ncv32f > & frame0, const NCVMatrix< Ncv32f > & frame1, NCVMatrix< Ncv32f > & u, NCVMatrix< Ncv32f > & v, cudaStream_t stream )`	Compute optical flow.
`void`	`cv::ncvDebugOutput(const cv::String & msg)`
`NCVStatus`	cv::ncvDetectObjectsMultiScale_device( NCVMatrix< Ncv8u > & d_srcImg, NcvSize32u srcRoi, NCVVector< NcvRect32u > & d_dstRects, Ncv32u & dstNumRects, HaarClassifierCascadeDescriptor & haar, NCVVector< HaarStage64 > & h_HaarStages, NCVVector< HaarStage64 > & d_HaarStages, NCVVector< HaarClassifierNode128 > & d_HaarNodes, NCVVector< HaarFeature64 > & d_HaarFeatures, NcvSize32u minObjSize, Ncv32u minNeighbors, Ncv32f scaleStep, Ncv32u pixelStep, Ncv32u flags, INCVMemAllocator & gpuAllocator, INCVMemAllocator & cpuAllocator, cudaDeviceProp & devProp, cudaStream_t cuStream )
`NCVStatus`	`cv::ncvDrawRects_32u_device( Ncv32u * d_dst, Ncv32u dstStride, Ncv32u dstWidth, Ncv32u dstHeight, NcvRect32u * d_rects, Ncv32u numRects, Ncv32u color, cudaStream_t cuStream )`
`NCVStatus`	`cv::ncvDrawRects_32u_host( Ncv32u * h_dst, Ncv32u dstStride, Ncv32u dstWidth, Ncv32u dstHeight, NcvRect32u * h_rects, Ncv32u numRects, Ncv32u color )`
`NCVStatus`	`cv::ncvDrawRects_8u_device( Ncv8u * d_dst, Ncv32u dstStride, Ncv32u dstWidth, Ncv32u dstHeight, NcvRect32u * d_rects, Ncv32u numRects, Ncv8u color, cudaStream_t cuStream )`
`NCVStatus`	`cv::ncvDrawRects_8u_host( Ncv8u * h_dst, Ncv32u dstStride, Ncv32u dstWidth, Ncv32u dstHeight, NcvRect32u * h_rects, Ncv32u numRects, Ncv8u color )`
`double`	`cv::ncvEndQueryTimerMs(NcvTimer t)`
`double`	`cv::ncvEndQueryTimerUs(NcvTimer t)`
`NCVStatus`	`cv::ncvGroupRectangles_host( NCVVector< NcvRect32u > & hypotheses, Ncv32u & numHypotheses, Ncv32u minNeighbors, Ncv32f intersectEps, NCVVector< Ncv32u > * hypothesesWeights )`
`NCVStatus`	`cv::ncvGrowDetectionsVector_device( NCVVector< Ncv32u > & pixelMask, Ncv32u numPixelMaskDetections, NCVVector< NcvRect32u > & hypotheses, Ncv32u & totalDetections, Ncv32u totalMaxDetections, Ncv32u rectWidth, Ncv32u rectHeight, Ncv32f curScale, cudaStream_t cuStream )`
`NCVStatus`	`cv::ncvGrowDetectionsVector_host( NCVVector< Ncv32u > & pixelMask, Ncv32u numPixelMaskDetections, NCVVector< NcvRect32u > & hypotheses, Ncv32u & totalDetections, Ncv32u totalMaxDetections, Ncv32u rectWidth, Ncv32u rectHeight, Ncv32f curScale )`
`NCVStatus`	`cv::ncvHaarGetClassifierSize( const cv::String & filename, Ncv32u & numStages, Ncv32u & numNodes, Ncv32u & numFeatures )`
`NCVStatus`	`cv::ncvHaarLoadFromFile_host( const cv::String & filename, HaarClassifierCascadeDescriptor & haar, NCVVector< HaarStage64 > & h_HaarStages, NCVVector< HaarClassifierNode128 > & h_HaarNodes, NCVVector< HaarFeature64 > & h_HaarFeatures )`
`NCVStatus`	`cv::ncvHaarStoreNVBIN_host( const cv::String & filename, HaarClassifierCascadeDescriptor haar, NCVVector< HaarStage64 > & h_HaarStages, NCVVector< HaarClassifierNode128 > & h_HaarNodes, NCVVector< HaarFeature64 > & h_HaarFeatures )`
`void`	`cv::ncvSetDebugOutputHandler(NCVDebugOutputHandler * func)`
`NcvTimer`	`cv::ncvStartTimer(void )`
`void`	`cv::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`	`cv::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`	`cv::transformPoints( const GpuMat & src, const Mat & rvec, const Mat & tvec, GpuMat & dst, Stream & stream = Stream::Null() )`

Typedef Documentation#

Ncv16s#

typedef short Ncv16s

#include <opencv2/cudalegacy/NCV.hpp>

Ncv16u#

typedef unsigned short Ncv16u

#include <opencv2/cudalegacy/NCV.hpp>

Ncv32f#

typedef float Ncv32f

#include <opencv2/cudalegacy/NCV.hpp>

Ncv32f_a#

typedef Ncv32f Ncv32f_a

#include <opencv2/cudalegacy/NCVHaarObjectDetection.hpp>

Ncv32s#

typedef int Ncv32s

#include <opencv2/cudalegacy/NCV.hpp>

Ncv32u#

typedef unsigned int Ncv32u

#include <opencv2/cudalegacy/NCV.hpp>

Ncv32u_a#

typedef Ncv32u Ncv32u_a

#include <opencv2/cudalegacy/NCVHaarObjectDetection.hpp>

Ncv64f#

typedef double Ncv64f

#include <opencv2/cudalegacy/NCV.hpp>

Ncv64s#

typedef long long Ncv64s

#include <opencv2/cudalegacy/NCV.hpp>

Ncv64u#

typedef uint64 Ncv64u

#include <opencv2/cudalegacy/NCV.hpp>

Ncv8s#

typedef signed char Ncv8s

#include <opencv2/cudalegacy/NCV.hpp>

Ncv8u#

typedef unsigned char Ncv8u

#include <opencv2/cudalegacy/NCV.hpp>

NcvBool#

typedef bool NcvBool

#include <opencv2/cudalegacy/NCV.hpp>

NCVDebugOutputHandler#

typedef void NCVDebugOutputHandler(const cv::String &msg)

#include <opencv2/cudalegacy/NCV.hpp>

NCVStatus#

typedef Ncv32u NCVStatus

#include <opencv2/cudalegacy/NCV.hpp>

NcvTimer#

typedef struct _NcvTimer * NcvTimer

#include <opencv2/cudalegacy/NCV.hpp>

Enumeration Type Documentation#

enum#

#include <opencv2/cudalegacy/NCV.hpp>

Return-codes for status notification, errors and warnings

Enumerator:

`NCV_SUCCESS`
`NCV_UNKNOWN_ERROR`
`NCV_CUDA_ERROR`
`NCV_NPP_ERROR`
`NCV_FILE_ERROR`
`NCV_NULL_PTR`
`NCV_INCONSISTENT_INPUT`
`NCV_TEXTURE_BIND_ERROR`
`NCV_DIMENSIONS_INVALID`
`NCV_INVALID_ROI`
`NCV_INVALID_STEP`
`NCV_INVALID_SCALE`
`NCV_ALLOCATOR_NOT_INITIALIZED`
`NCV_ALLOCATOR_BAD_ALLOC`
`NCV_ALLOCATOR_BAD_DEALLOC`
`NCV_ALLOCATOR_INSUFFICIENT_CAPACITY`
`NCV_ALLOCATOR_DEALLOC_ORDER`
`NCV_ALLOCATOR_BAD_REUSE`
`NCV_MEM_COPY_ERROR`
`NCV_MEM_RESIDENCE_ERROR`
`NCV_MEM_INSUFFICIENT_CAPACITY`
`NCV_HAAR_INVALID_PIXEL_STEP`
`NCV_HAAR_TOO_MANY_FEATURES_IN_CLASSIFIER`
`NCV_HAAR_TOO_MANY_FEATURES_IN_CASCADE`
`NCV_HAAR_TOO_LARGE_FEATURES`
`NCV_HAAR_XML_LOADING_EXCEPTION`
`NCV_NOIMPL_HAAR_TILTED_FEATURES`
`NCV_NOT_IMPLEMENTED`
`NCV_WARNING_HAAR_DETECTIONS_VECTOR_OVERFLOW`
`NPPST_SUCCESS`	Successful operation (same as NPP_NO_ERROR)
`NPPST_ERROR`	Unknown error.
`NPPST_CUDA_KERNEL_EXECUTION_ERROR`	CUDA kernel execution error.
`NPPST_NULL_POINTER_ERROR`	NULL pointer argument error.
`NPPST_TEXTURE_BIND_ERROR`	CUDA texture binding error or non-zero offset returned.
`NPPST_MEMCPY_ERROR`	CUDA memory copy error.
`NPPST_MEM_ALLOC_ERR`	CUDA memory allocation error.
`NPPST_MEMFREE_ERR`	CUDA memory deallocation error.
`NPPST_INVALID_ROI`	Invalid region of interest argument.
`NPPST_INVALID_STEP`	Invalid image lines step argument (check sign, alignment, relation to image width)
`NPPST_INVALID_SCALE`	Invalid scale parameter passed.
`NPPST_MEM_INSUFFICIENT_BUFFER`	Insufficient user-allocated buffer.
`NPPST_MEM_RESIDENCE_ERROR`	Memory residence error detected (check if pointers should be device or pinned)
`NPPST_MEM_INTERNAL_ERROR`	Internal memory management error.
`NCV_LAST_STATUS`	Marker to continue error numeration in other files.

enum#

#include <opencv2/cudalegacy/NCVHaarObjectDetection.hpp>

Enumerator:

NCVPipeObjDet_Default

NCVPipeObjDet_UseFairImageScaling

NCVPipeObjDet_FindLargestObject

NCVPipeObjDet_VisualizeInPlace

NCVMemoryType#

enum NCVMemoryType

#include <opencv2/cudalegacy/NCV.hpp>

NCVMemoryType

Enumerator:

NCVMemoryTypeNone

NCVMemoryTypeHostPageable

NCVMemoryTypeHostPinned

NCVMemoryTypeDevice

Function Documentation#

alignUp()#

Ncv32u alignUp(
Ncv32u what,
Ncv32u alignment )

#include <opencv2/cudalegacy/NCV.hpp>

Calculates the aligned top bound value

calcOpticalFlowBM()#

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

#include <opencv2/cudalegacy.hpp>

Calculates optical flow for 2 images using block matching algorithm */.

connectivityMask()#

void cv::cuda::connectivityMask(
const GpuMat & image,
GpuMat & mask,
const cv::Scalar & lo,
const cv::Scalar & hi,
Stream & stream = Stream::Null() )

#include <opencv2/cudalegacy.hpp>

compute mask for Generalized Flood fill componetns labeling.

createBackgroundSubtractorFGD()#

Ptr< cuda::BackgroundSubtractorFGD > cv::cuda::createBackgroundSubtractorFGD(const FGDParams & params = FGDParams())

#include <opencv2/cudalegacy.hpp>

Creates FGD Background Subtractor.

Parameters

params — Algorithm’s parameters. See [179] for explanation.

createBackgroundSubtractorGMG()#

Ptr< cuda::BackgroundSubtractorGMG > cv::cuda::createBackgroundSubtractorGMG(
int initializationFrames = 120,
double decisionThreshold = 0.8 )

#include <opencv2/cudalegacy.hpp>

Creates GMG Background Subtractor.

Parameters

initializationFrames — Number of frames of video to use to initialize histograms.
decisionThreshold — Value above which pixel is determined to be FG.

createImagePyramid()#

Ptr< ImagePyramid > cv::cuda::createImagePyramid(
InputArray img,
int nLayers = -1,
Stream & stream = Stream::Null() )

#include <opencv2/cudalegacy.hpp>

createOpticalFlowNeedleMap()#

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

#include <opencv2/cudalegacy.hpp>

graphcut()#

void cv::cuda::graphcut(
GpuMat & terminals,
GpuMat & leftTransp,
GpuMat & rightTransp,
GpuMat & top,
GpuMat & bottom,
GpuMat & labels,
GpuMat & buf,
Stream & stream = Stream::Null() )

#include <opencv2/cudalegacy.hpp>

performs labeling via graph cuts of a 2D regular 4-connected graph.

graphcut()#

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

#include <opencv2/cudalegacy.hpp>

performs labeling via graph cuts of a 2D regular 8-connected graph.

interpolateFrames()#

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

#include <opencv2/cudalegacy.hpp>

Interpolates frames (images) using provided optical flow (displacement field).

Parameters

frame0 — First frame (32-bit floating point images, single channel).
frame1 — Second frame. Must have the same type and size as frame0 .
fu — Forward horizontal displacement.
fv — Forward vertical displacement.
bu — Backward horizontal displacement.
bv — Backward vertical displacement.
pos — New frame position.
newFrame — Output image.
buf — Temporary buffer, will have width x 6*height size, CV_32FC1 type and contain 6 GpuMat: occlusion masks for first frame, occlusion masks for second, interpolated forward horizontal flow, interpolated forward vertical flow, interpolated backward horizontal flow, interpolated backward vertical flow.
stream — Stream for the asynchronous version.

labelComponents()#

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

#include <opencv2/cudalegacy.hpp>

performs connected componnents labeling.

memSegCopyHelper()#

NCVStatus memSegCopyHelper(
void * dst,
NCVMemoryType dstType,
const void * src,
NCVMemoryType srcType,
size_t sz,
cudaStream_t cuStream )

#include <opencv2/cudalegacy/NCV.hpp>

Copy dispatchers

memSegCopyHelper2D()#

NCVStatus memSegCopyHelper2D(
void * dst,
Ncv32u dstPitch,
NCVMemoryType dstType,
const void * src,
Ncv32u srcPitch,
NCVMemoryType srcType,
Ncv32u widthbytes,
Ncv32u height,
cudaStream_t cuStream )

#include <opencv2/cudalegacy/NCV.hpp>

NCV_CT_ASSERT()#

NCV_CT_ASSERT(sizeof(HaarClassifierNode128) = =16)

#include <opencv2/cudalegacy/NCVHaarObjectDetection.hpp>

NCV_CT_ASSERT()#

NCV_CT_ASSERT(sizeof(HaarClassifierNodeDescriptor32) = =4)

#include <opencv2/cudalegacy/NCVHaarObjectDetection.hpp>

NCV_CT_ASSERT()#

NCV_CT_ASSERT(sizeof(HaarFeature64) = =8)

#include <opencv2/cudalegacy/NCVHaarObjectDetection.hpp>

NCV_CT_ASSERT()#

NCV_CT_ASSERT(sizeof(HaarFeatureDescriptor32) = =4)

#include <opencv2/cudalegacy/NCVHaarObjectDetection.hpp>

NCV_CT_ASSERT()#

NCV_CT_ASSERT(sizeof(HaarStage64) = =8)

#include <opencv2/cudalegacy/NCVHaarObjectDetection.hpp>

ncvApplyHaarClassifierCascade_device()#

NCVStatus ncvApplyHaarClassifierCascade_device(
NCVMatrix< Ncv32u > & d_integralImage,
NCVMatrix< Ncv32f > & d_weights,
NCVMatrixAlloc< Ncv32u > & d_pixelMask,
Ncv32u & numDetections,
HaarClassifierCascadeDescriptor & haar,
NCVVector< HaarStage64 > & h_HaarStages,
NCVVector< HaarStage64 > & d_HaarStages,
NCVVector< HaarClassifierNode128 > & d_HaarNodes,
NCVVector< HaarFeature64 > & d_HaarFeatures,
NcvBool bMaskElements,
NcvSize32u anchorsRoi,
Ncv32u pixelStep,
Ncv32f scaleArea,
INCVMemAllocator & gpuAllocator,
INCVMemAllocator & cpuAllocator,
cudaDeviceProp & devProp,
cudaStream_t cuStream )

#include <opencv2/cudalegacy/NCVHaarObjectDetection.hpp>

ncvApplyHaarClassifierCascade_host()#

NCVStatus ncvApplyHaarClassifierCascade_host(
NCVMatrix< Ncv32u > & h_integralImage,
NCVMatrix< Ncv32f > & h_weights,
NCVMatrixAlloc< Ncv32u > & h_pixelMask,
Ncv32u & numDetections,
HaarClassifierCascadeDescriptor & haar,
NCVVector< HaarStage64 > & h_HaarStages,
NCVVector< HaarClassifierNode128 > & h_HaarNodes,
NCVVector< HaarFeature64 > & h_HaarFeatures,
NcvBool bMaskElements,
NcvSize32u anchorsRoi,
Ncv32u pixelStep,
Ncv32f scaleArea )

#include <opencv2/cudalegacy/NCVHaarObjectDetection.hpp>

NCVBroxOpticalFlow()#

NCVStatus NCVBroxOpticalFlow(
const NCVBroxOpticalFlowDescriptor desc,
INCVMemAllocator & gpu_mem_allocator,
const NCVMatrix< Ncv32f > & frame0,
const NCVMatrix< Ncv32f > & frame1,
NCVMatrix< Ncv32f > & u,
NCVMatrix< Ncv32f > & v,
cudaStream_t stream )

#include <opencv2/cudalegacy/NCVBroxOpticalFlow.hpp>

Compute optical flow.

Based on method by Brox et al [2004]

Parameters

desc — model and solver parameters
gpu_mem_allocator — GPU memory allocator
frame0 — source frame
frame1 — frame to track
u — flow horizontal component (along x axis)
v — flow vertical component (along y axis)
stream

Returns

computation status

ncvDebugOutput()#

void ncvDebugOutput(const cv::String & msg)

#include <opencv2/cudalegacy/NCV.hpp>

ncvDetectObjectsMultiScale_device()#

NCVStatus ncvDetectObjectsMultiScale_device(
NCVMatrix< Ncv8u > & d_srcImg,
NcvSize32u srcRoi,
NCVVector< NcvRect32u > & d_dstRects,
Ncv32u & dstNumRects,
HaarClassifierCascadeDescriptor & haar,
NCVVector< HaarStage64 > & h_HaarStages,
NCVVector< HaarStage64 > & d_HaarStages,
NCVVector< HaarClassifierNode128 > & d_HaarNodes,
NCVVector< HaarFeature64 > & d_HaarFeatures,
NcvSize32u minObjSize,
Ncv32u minNeighbors,
Ncv32f scaleStep,
Ncv32u pixelStep,
Ncv32u flags,
INCVMemAllocator & gpuAllocator,
INCVMemAllocator & cpuAllocator,
cudaDeviceProp & devProp,
cudaStream_t cuStream )

#include <opencv2/cudalegacy/NCVHaarObjectDetection.hpp>

ncvDrawRects_32u_device()#

NCVStatus ncvDrawRects_32u_device(
Ncv32u * d_dst,
Ncv32u dstStride,
Ncv32u dstWidth,
Ncv32u dstHeight,
NcvRect32u * d_rects,
Ncv32u numRects,
Ncv32u color,
cudaStream_t cuStream )

#include <opencv2/cudalegacy/NCV.hpp>

ncvDrawRects_32u_host()#

NCVStatus ncvDrawRects_32u_host(
Ncv32u * h_dst,
Ncv32u dstStride,
Ncv32u dstWidth,
Ncv32u dstHeight,
NcvRect32u * h_rects,
Ncv32u numRects,
Ncv32u color )

#include <opencv2/cudalegacy/NCV.hpp>

ncvDrawRects_8u_device()#

NCVStatus ncvDrawRects_8u_device(
Ncv8u * d_dst,
Ncv32u dstStride,
Ncv32u dstWidth,
Ncv32u dstHeight,
NcvRect32u * d_rects,
Ncv32u numRects,
Ncv8u color,
cudaStream_t cuStream )

#include <opencv2/cudalegacy/NCV.hpp>

ncvDrawRects_8u_host()#

NCVStatus ncvDrawRects_8u_host(
Ncv8u * h_dst,
Ncv32u dstStride,
Ncv32u dstWidth,
Ncv32u dstHeight,
NcvRect32u * h_rects,
Ncv32u numRects,
Ncv8u color )

#include <opencv2/cudalegacy/NCV.hpp>

ncvEndQueryTimerMs()#

double ncvEndQueryTimerMs(NcvTimer t)

#include <opencv2/cudalegacy/NCV.hpp>

ncvEndQueryTimerUs()#

double ncvEndQueryTimerUs(NcvTimer t)

#include <opencv2/cudalegacy/NCV.hpp>

ncvGroupRectangles_host()#

NCVStatus ncvGroupRectangles_host(
NCVVector< NcvRect32u > & hypotheses,
Ncv32u & numHypotheses,
Ncv32u minNeighbors,
Ncv32f intersectEps,
NCVVector< Ncv32u > * hypothesesWeights )

#include <opencv2/cudalegacy/NCV.hpp>

Operations with rectangles

ncvGrowDetectionsVector_device()#

NCVStatus ncvGrowDetectionsVector_device(
NCVVector< Ncv32u > & pixelMask,
Ncv32u numPixelMaskDetections,
NCVVector< NcvRect32u > & hypotheses,
Ncv32u & totalDetections,
Ncv32u totalMaxDetections,
Ncv32u rectWidth,
Ncv32u rectHeight,
Ncv32f curScale,
cudaStream_t cuStream )

#include <opencv2/cudalegacy/NCVHaarObjectDetection.hpp>

ncvGrowDetectionsVector_host()#

NCVStatus ncvGrowDetectionsVector_host(
NCVVector< Ncv32u > & pixelMask,
Ncv32u numPixelMaskDetections,
NCVVector< NcvRect32u > & hypotheses,
Ncv32u & totalDetections,
Ncv32u totalMaxDetections,
Ncv32u rectWidth,
Ncv32u rectHeight,
Ncv32f curScale )

#include <opencv2/cudalegacy/NCVHaarObjectDetection.hpp>

ncvHaarGetClassifierSize()#

NCVStatus ncvHaarGetClassifierSize(
const cv::String & filename,
Ncv32u & numStages,
Ncv32u & numNodes,
Ncv32u & numFeatures )

#include <opencv2/cudalegacy/NCVHaarObjectDetection.hpp>

ncvHaarLoadFromFile_host()#

NCVStatus ncvHaarLoadFromFile_host(
const cv::String & filename,
HaarClassifierCascadeDescriptor & haar,
NCVVector< HaarStage64 > & h_HaarStages,
NCVVector< HaarClassifierNode128 > & h_HaarNodes,
NCVVector< HaarFeature64 > & h_HaarFeatures )

#include <opencv2/cudalegacy/NCVHaarObjectDetection.hpp>

ncvHaarStoreNVBIN_host()#

NCVStatus ncvHaarStoreNVBIN_host(
const cv::String & filename,
HaarClassifierCascadeDescriptor haar,
NCVVector< HaarStage64 > & h_HaarStages,
NCVVector< HaarClassifierNode128 > & h_HaarNodes,
NCVVector< HaarFeature64 > & h_HaarFeatures )

#include <opencv2/cudalegacy/NCVHaarObjectDetection.hpp>

ncvSetDebugOutputHandler()#

void ncvSetDebugOutputHandler(NCVDebugOutputHandler * func)

#include <opencv2/cudalegacy/NCV.hpp>

ncvStartTimer()#

NcvTimer ncvStartTimer(void)

#include <opencv2/cudalegacy/NCV.hpp>

projectPoints()#

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

#include <opencv2/cudalegacy.hpp>

solvePnPRansac()#

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

#include <opencv2/cudalegacy.hpp>

Finds the object pose from 3D-2D point correspondences.

Parameters

object — Single-row matrix of object points.
image — Single-row matrix of image points.
camera_mat — 3x3 matrix of intrinsic camera parameters.
dist_coef — Distortion coefficients. See undistortPoints for details.
rvec — Output 3D rotation vector.
tvec — Output 3D translation vector.
use_extrinsic_guess — Flag to indicate that the function must use rvec and tvec as an initial transformation guess. It is not supported for now.
num_iters — Maximum number of RANSAC iterations.
max_dist — Euclidean distance threshold to detect whether point is inlier or not.
min_inlier_count — Flag to indicate that the function must stop if greater or equal number of inliers is achieved. It is not supported for now.
inliers — Output vector of inlier indices.

transformPoints()#

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

#include <opencv2/cudalegacy.hpp>

Variable Documentation#

K_LOG2_WARP_SIZE#

const Ncv32u K_LOG2_WARP_SIZE = 5

#include <opencv2/cudalegacy/NCV.hpp>

K_WARP_SIZE#

const Ncv32u K_WARP_SIZE = 32

#include <opencv2/cudalegacy/NCV.hpp>

Macro Definition Documentation#

CLAMP#

#define CLAMP(x, a, b)

#include <opencv2/cudalegacy/NCV.hpp>

Value:

( (x) > (b) ? (b) : ( (x) < (a) ? (a) : (x) ) )

CLAMP_0_255#

#define CLAMP_0_255(x)

#include <opencv2/cudalegacy/NCV.hpp>

Value:

CLAMP(x,0,255)

CLAMP_BOTTOM#

#define CLAMP_BOTTOM(x, a)

#include <opencv2/cudalegacy/NCV.hpp>

Value:

(((x) < (a)) ? (a) : (x))

CLAMP_TOP#

#define CLAMP_TOP(x, a)

#include <opencv2/cudalegacy/NCV.hpp>

Value:

(((x) > (a)) ? (a) : (x))

HAAR_STDDEV_BORDER#

#define HAAR_STDDEV_BORDER

#include <opencv2/cudalegacy/NCVHaarObjectDetection.hpp>

Value:

NCV_CT_ASSERT#

#define NCV_CT_ASSERT(X)

#include <opencv2/cudalegacy/NCV.hpp>

Value:

typedef NcvCTprep::assertTest<sizeof(NcvCTprep::CT_ASSERT_FAILURE< (bool)(X) >)> \
    NCV_CT_PREP_PASTE(__ct_assert_typedef_, __LINE__)

Performs compile-time assertion of a condition on the file scope

NCV_CT_PREP_PASTE#

#define NCV_CT_PREP_PASTE(a, b)

#include <opencv2/cudalegacy/NCV.hpp>

Value:

NCV_CT_PREP_PASTE_AUX(a, b)

Concatenation macro.

NCV_CT_PREP_PASTE_AUX#

#define NCV_CT_PREP_PASTE_AUX(a, b)

#include <opencv2/cudalegacy/NCV.hpp>

Value:

a##b

Concatenation indirection macro.

NCV_RESET_SKIP_COND#

#define NCV_RESET_SKIP_COND(x)

#include <opencv2/cudalegacy/NCV.hpp>

Value:

__ncv_skip_cond = x

NCV_SET_SKIP_COND#

#define NCV_SET_SKIP_COND(x)

#include <opencv2/cudalegacy/NCV.hpp>

Value:

bool __ncv_skip_cond = x

NCV_SKIP_COND_BEGIN#

#define NCV_SKIP_COND_BEGIN

#include <opencv2/cudalegacy/NCV.hpp>

Value:

if (!__ncv_skip_cond) {

NCV_SKIP_COND_END#

#define NCV_SKIP_COND_END

#include <opencv2/cudalegacy/NCV.hpp>

Value:

ncvAssertCUDALastErrorReturn#

#define ncvAssertCUDALastErrorReturn(errCode)

#include <opencv2/cudalegacy/NCV.hpp>

Value:

do \
    { \
        cudaError_t res = cudaGetLastError(); \
        cv::String msg = cv::format("cudaError_t=%d", (int)res); \
        ncvAssertPrintReturn(cudaSuccess==res, msg.c_str(), errCode); \
    } while (0)

ncvAssertCUDAReturn#

#define ncvAssertCUDAReturn(cudacall, errCode)

#include <opencv2/cudalegacy/NCV.hpp>

Value:

do \
    { \
        cudaError_t res = cudacall; \
        cv::String msg = cv::format("cudaError_t=%d", (int)res); \
        ncvAssertPrintReturn(cudaSuccess==res, msg.c_str(), errCode); \
    } while (0)

ncvAssertPrintCheck#

#define ncvAssertPrintCheck(pred, msg)

#include <opencv2/cudalegacy/NCV.hpp>

Value:

do \
    { \
        if (!(pred)) \
        { \
            cv::String str = cv::format("NCV Assertion Failed: %s, file=%s, line=%d", msg, __FILE__, __LINE__); \
            ncvDebugOutput(str); \
        } \
    } while (0)

ncvAssertPrintReturn#

#define ncvAssertPrintReturn(pred, msg, err)

#include <opencv2/cudalegacy/NCV.hpp>

Value:

do \
    { \
        ncvAssertPrintCheck(pred, msg); \
        if (!(pred)) return err; \
    } while (0)

ncvAssertReturn#

#define ncvAssertReturn(pred, err)

#include <opencv2/cudalegacy/NCV.hpp>

Value:

do \
    { \
        cv::String msg = cv::format("retcode=%d", (int)err); \
        ncvAssertPrintReturn(pred, msg.c_str(), err); \
    } while (0)

ncvAssertReturnNcvStat#

#define ncvAssertReturnNcvStat(ncvOp)

#include <opencv2/cudalegacy/NCV.hpp>

Value:

do \
    { \
        NCVStatus _ncvStat = ncvOp; \
        cv::String msg = cv::format("NcvStat=%d", (int)_ncvStat); \
        ncvAssertPrintReturn(NCV_SUCCESS==_ncvStat, msg.c_str(), _ncvStat); \
    } while (0)

ncvSafeMatAlloc#

#define ncvSafeMatAlloc(name, type, alloc, width, height, err)

#include <opencv2/cudalegacy/NCV.hpp>

Value:

NCVMatrixAlloc<type> name(alloc, width, height); \
    ncvAssertReturn(name.isMemAllocated(), err);

OBJDET_MASK_ELEMENT_INVALID_32U#

#define OBJDET_MASK_ELEMENT_INVALID_32U

#include <opencv2/cudalegacy/NCVHaarObjectDetection.hpp>

Value:

0xFFFFFFFF

RECT_SIMILARITY_PROPORTION#

#define RECT_SIMILARITY_PROPORTION

#include <opencv2/cudalegacy/NCVHaarObjectDetection.hpp>

Value:

0.2f

SQR#

#define SQR(x)

#include <opencv2/cudalegacy/NCV.hpp>

Value:

((x)*(x))

SUB_BEGIN#

#define SUB_BEGIN(type, name)

#include <opencv2/cudalegacy/NCV.hpp>

Value:

struct { __inline type name

SUB_CALL#

#define SUB_CALL(name)

#include <opencv2/cudalegacy/NCV.hpp>

Value:

name.name

SUB_END#

#define SUB_END(name)

#include <opencv2/cudalegacy/NCV.hpp>

Value:

} name;