OpenCV  5.0.0-pre
Open Source Computer Vision
Loading...
Searching...
No Matches

Topics

 NPPST Core
 
 NPPST Image Processing
 
 NPPST Signal Processing
 

Detailed Description

Namespaces

namespace  NcvCTprep
 

Classes

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

Macros

#define CLAMP(x, a, b)
 
#define CLAMP_0_255(x)
 
#define CLAMP_BOTTOM(x, a)
 
#define CLAMP_TOP(x, a)
 
#define HAAR_STDDEV_BORDER   1
 
#define NCV_CT_ASSERT(X)
 
#define NCV_CT_PREP_PASTE(a, b)
 Concatenation macro.
 
#define NCV_CT_PREP_PASTE_AUX(a, b)
 Concatenation indirection macro.
 
#define NCV_RESET_SKIP_COND(x)
 
#define NCV_SET_SKIP_COND(x)
 
#define NCV_SKIP_COND_BEGIN    if (!__ncv_skip_cond) {
 
#define NCV_SKIP_COND_END    }
 
#define ncvAssertCUDALastErrorReturn(errCode)
 
#define ncvAssertCUDAReturn(cudacall, errCode)
 
#define ncvAssertPrintCheck(pred, msg)
 
#define ncvAssertPrintReturn(pred, msg, err)
 
#define ncvAssertReturn(pred, err)
 
#define ncvAssertReturnNcvStat(ncvOp)
 
#define ncvSafeMatAlloc(name, type, alloc, width, height, err)
 
#define OBJDET_MASK_ELEMENT_INVALID_32U   0xFFFFFFFF
 
#define RECT_SIMILARITY_PROPORTION   0.2f
 
#define SQR(x)
 
#define SUB_BEGIN(type, name)
 
#define SUB_CALL(name)
 
#define SUB_END(name)
 

Typedefs

typedef short Ncv16s
 
typedef unsigned short Ncv16u
 
typedef float Ncv32f
 
typedef Ncv32f Ncv32f_a
 
typedef int Ncv32s
 
typedef unsigned int Ncv32u
 
typedef Ncv32u Ncv32u_a
 
typedef double Ncv64f
 
typedef long long Ncv64s
 
typedef uint64 Ncv64u
 
typedef signed char Ncv8s
 
typedef unsigned char Ncv8u
 
typedef bool NcvBool
 
typedef void NCVDebugOutputHandler(const cv::String &msg)
 
typedef Ncv32u NCVStatus
 
typedef struct _NcvTimer * NcvTimer
 

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
}
 
enum  {
  NCVPipeObjDet_Default = 0x000 ,
  NCVPipeObjDet_UseFairImageScaling = 0x001 ,
  NCVPipeObjDet_FindLargestObject = 0x002 ,
  NCVPipeObjDet_VisualizeInPlace = 0x004
}
 
enum  NCVMemoryType {
  NCVMemoryTypeNone ,
  NCVMemoryTypeHostPageable ,
  NCVMemoryTypeHostPinned ,
  NCVMemoryTypeDevice
}
 

Functions

virtual INCVMemAllocator::~INCVMemAllocator ()=0
 
Ncv32u alignUp (Ncv32u what, Ncv32u alignment)
 
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())
 Calculates optical flow for 2 images using block matching algorithm *‍/.
 
void cv::cuda::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::BackgroundSubtractorFGDcv::cuda::createBackgroundSubtractorFGD (const FGDParams &params=FGDParams())
 Creates FGD Background Subtractor.
 
Ptr< cuda::BackgroundSubtractorGMGcv::cuda::createBackgroundSubtractorGMG (int initializationFrames=120, double decisionThreshold=0.8)
 Creates GMG Background Subtractor.
 
Ptr< ImagePyramidcv::cuda::createImagePyramid (InputArray img, int nLayers=-1, Stream &stream=Stream::Null())
 
void cv::cuda::createOpticalFlowNeedleMap (const GpuMat &u, const GpuMat &v, GpuMat &vertex, GpuMat &colors)
 
void cv::cuda::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::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())
 performs labeling via graph cuts of a 2D regular 8-connected graph.
 
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())
 Interpolates frames (images) using provided optical flow (displacement field).
 
void cv::cuda::labelComponents (const GpuMat &mask, GpuMat &components, int flags=0, Stream &stream=Stream::Null())
 performs connected componnents labeling.
 
NCVStatus memSegCopyHelper (void *dst, NCVMemoryType dstType, const void *src, NCVMemoryType srcType, size_t sz, cudaStream_t cuStream)
 
NCVStatus memSegCopyHelper2D (void *dst, Ncv32u dstPitch, NCVMemoryType dstType, const void *src, Ncv32u srcPitch, NCVMemoryType srcType, Ncv32u widthbytes, Ncv32u height, cudaStream_t cuStream)
 
 NCV_CT_ASSERT (sizeof(HaarClassifierNode128)==16)
 
 NCV_CT_ASSERT (sizeof(HaarClassifierNodeDescriptor32)==4)
 
 NCV_CT_ASSERT (sizeof(HaarFeature64)==8)
 
 NCV_CT_ASSERT (sizeof(HaarFeatureDescriptor32)==4)
 
 NCV_CT_ASSERT (sizeof(HaarStage64)==8)
 
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)
 
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)
 
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)
 Compute optical flow.
 
void ncvDebugOutput (const cv::String &msg)
 
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)
 
NCVStatus ncvDrawRects_32u_device (Ncv32u *d_dst, Ncv32u dstStride, Ncv32u dstWidth, Ncv32u dstHeight, NcvRect32u *d_rects, Ncv32u numRects, Ncv32u color, cudaStream_t cuStream)
 
NCVStatus ncvDrawRects_32u_host (Ncv32u *h_dst, Ncv32u dstStride, Ncv32u dstWidth, Ncv32u dstHeight, NcvRect32u *h_rects, Ncv32u numRects, Ncv32u color)
 
NCVStatus ncvDrawRects_8u_device (Ncv8u *d_dst, Ncv32u dstStride, Ncv32u dstWidth, Ncv32u dstHeight, NcvRect32u *d_rects, Ncv32u numRects, Ncv8u color, cudaStream_t cuStream)
 
NCVStatus ncvDrawRects_8u_host (Ncv8u *h_dst, Ncv32u dstStride, Ncv32u dstWidth, Ncv32u dstHeight, NcvRect32u *h_rects, Ncv32u numRects, Ncv8u color)
 
double ncvEndQueryTimerMs (NcvTimer t)
 
double ncvEndQueryTimerUs (NcvTimer t)
 
NCVStatus ncvGroupRectangles_host (NCVVector< NcvRect32u > &hypotheses, Ncv32u &numHypotheses, Ncv32u minNeighbors, Ncv32f intersectEps, NCVVector< Ncv32u > *hypothesesWeights)
 
NCVStatus ncvGrowDetectionsVector_device (NCVVector< Ncv32u > &pixelMask, Ncv32u numPixelMaskDetections, NCVVector< NcvRect32u > &hypotheses, Ncv32u &totalDetections, Ncv32u totalMaxDetections, Ncv32u rectWidth, Ncv32u rectHeight, Ncv32f curScale, cudaStream_t cuStream)
 
NCVStatus ncvGrowDetectionsVector_host (NCVVector< Ncv32u > &pixelMask, Ncv32u numPixelMaskDetections, NCVVector< NcvRect32u > &hypotheses, Ncv32u &totalDetections, Ncv32u totalMaxDetections, Ncv32u rectWidth, Ncv32u rectHeight, Ncv32f curScale)
 
NCVStatus ncvHaarGetClassifierSize (const cv::String &filename, Ncv32u &numStages, Ncv32u &numNodes, Ncv32u &numFeatures)
 
NCVStatus ncvHaarLoadFromFile_host (const cv::String &filename, HaarClassifierCascadeDescriptor &haar, NCVVector< HaarStage64 > &h_HaarStages, NCVVector< HaarClassifierNode128 > &h_HaarNodes, NCVVector< HaarFeature64 > &h_HaarFeatures)
 
NCVStatus ncvHaarStoreNVBIN_host (const cv::String &filename, HaarClassifierCascadeDescriptor haar, NCVVector< HaarStage64 > &h_HaarStages, NCVVector< HaarClassifierNode128 > &h_HaarNodes, NCVVector< HaarFeature64 > &h_HaarFeatures)
 
void ncvSetDebugOutputHandler (NCVDebugOutputHandler *func)
 
NcvTimer ncvStartTimer (void)
 
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())
 
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)
 Finds the object pose from 3D-2D point correspondences.
 
void cv::cuda::transformPoints (const GpuMat &src, const Mat &rvec, const Mat &tvec, GpuMat &dst, Stream &stream=Stream::Null())
 

Variables

const Ncv32u K_LOG2_WARP_SIZE = 5
 
const Ncv32u K_WARP_SIZE = 32
 

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)
#define CLAMP(x, a, b)
Definition NCV.hpp:1013

◆ 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   1

◆ 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__)
#define NCV_CT_PREP_PASTE(a, b)
Concatenation macro.
Definition NCV.hpp:83
Definition NCV.hpp:72
Definition NCV.hpp:78

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:
#define NCV_CT_PREP_PASTE_AUX(a, b)
Concatenation indirection macro.
Definition NCV.hpp:82

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    if (!__ncv_skip_cond) {

◆ NCV_SKIP_COND_END

#define NCV_SKIP_COND_END    }

◆ 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)
std::string String
Definition cvstd.hpp:151
String format(const char *fmt,...)
Returns a text string formatted using the printf-like expression.

◆ 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)
Ncv32u NCVStatus
Definition NCV.hpp:376
@ NCV_SUCCESS
Definition NCV.hpp:316

◆ 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);
Definition NCV.hpp:845

◆ OBJDET_MASK_ELEMENT_INVALID_32U

#define OBJDET_MASK_ELEMENT_INVALID_32U   0xFFFFFFFF

◆ RECT_SIMILARITY_PROPORTION

#define RECT_SIMILARITY_PROPORTION   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;

Typedef Documentation

◆ Ncv16s

typedef short Ncv16s

◆ Ncv16u

typedef unsigned short Ncv16u

◆ Ncv32f

typedef float Ncv32f

◆ Ncv32f_a

◆ Ncv32s

typedef int Ncv32s

◆ Ncv32u

typedef unsigned int Ncv32u

◆ Ncv32u_a

◆ Ncv64f

typedef double Ncv64f

◆ Ncv64s

typedef long long Ncv64s

◆ Ncv64u

◆ Ncv8s

typedef signed char Ncv8s

◆ Ncv8u

typedef unsigned char Ncv8u

◆ NcvBool

typedef bool NcvBool

◆ NCVDebugOutputHandler

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

◆ NCVStatus

◆ NcvTimer

typedef struct _NcvTimer* NcvTimer

Enumeration Type Documentation

◆ anonymous enum

anonymous 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.

◆ anonymous enum

anonymous enum

#include <opencv2/cudalegacy/NCVHaarObjectDetection.hpp>

Enumerator
NCVPipeObjDet_Default 
NCVPipeObjDet_UseFairImageScaling 
NCVPipeObjDet_FindLargestObject 
NCVPipeObjDet_VisualizeInPlace 

◆ NCVMemoryType

#include <opencv2/cudalegacy/NCV.hpp>

NCVMemoryType

Enumerator
NCVMemoryTypeNone 
NCVMemoryTypeHostPageable 
NCVMemoryTypeHostPinned 
NCVMemoryTypeDevice 

Function Documentation

◆ ~INCVMemAllocator()

INCVMemAllocator::~INCVMemAllocator ( )
inlinepure virtual

◆ 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
paramsAlgorithm's parameters. See [162] 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
initializationFramesNumber of frames of video to use to initialize histograms.
decisionThresholdValue above which pixel is determined to be FG.

◆ createImagePyramid()

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

◆ createOpticalFlowNeedleMap()

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

◆ graphcut() [1/2]

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() [2/2]

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
frame0First frame (32-bit floating point images, single channel).
frame1Second frame. Must have the same type and size as frame0 .
fuForward horizontal displacement.
fvForward vertical displacement.
buBackward horizontal displacement.
bvBackward vertical displacement.
posNew frame position.
newFrameOutput image.
bufTemporary 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.
streamStream 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 )

◆ NCV_CT_ASSERT() [1/5]

NCV_CT_ASSERT ( sizeof(HaarClassifierNode128) = =16)

◆ NCV_CT_ASSERT() [2/5]

◆ NCV_CT_ASSERT() [3/5]

NCV_CT_ASSERT ( sizeof(HaarFeature64) = =8)

◆ NCV_CT_ASSERT() [4/5]

◆ NCV_CT_ASSERT() [5/5]

NCV_CT_ASSERT ( sizeof(HaarStage64) = =8)

◆ 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 )

◆ 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 )

◆ 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
[in]descmodel and solver parameters
[in]gpu_mem_allocatorGPU memory allocator
[in]frame0source frame
[in]frame1frame to track
[out]uflow horizontal component (along x axis)
[out]vflow vertical component (along y axis)
stream
Returns
computation status

◆ ncvDebugOutput()

void ncvDebugOutput ( const cv::String & msg)

◆ 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 )

◆ 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 )

◆ ncvDrawRects_32u_host()

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

◆ 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 )

◆ ncvDrawRects_8u_host()

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

◆ ncvEndQueryTimerMs()

double ncvEndQueryTimerMs ( NcvTimer t)

◆ ncvEndQueryTimerUs()

double ncvEndQueryTimerUs ( NcvTimer t)

◆ 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 )

◆ ncvGrowDetectionsVector_host()

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

◆ ncvHaarGetClassifierSize()

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

◆ ncvHaarLoadFromFile_host()

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

◆ ncvHaarStoreNVBIN_host()

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

◆ ncvSetDebugOutputHandler()

void ncvSetDebugOutputHandler ( NCVDebugOutputHandler * func)

◆ ncvStartTimer()

NcvTimer ncvStartTimer ( void )

◆ 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() )

◆ 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
objectSingle-row matrix of object points.
imageSingle-row matrix of image points.
camera_mat3x3 matrix of intrinsic camera parameters.
dist_coefDistortion coefficients. See undistortPoints for details.
rvecOutput 3D rotation vector.
tvecOutput 3D translation vector.
use_extrinsic_guessFlag to indicate that the function must use rvec and tvec as an initial transformation guess. It is not supported for now.
num_itersMaximum number of RANSAC iterations.
max_distEuclidean distance threshold to detect whether point is inlier or not.
min_inlier_countFlag to indicate that the function must stop if greater or equal number of inliers is achieved. It is not supported for now.
inliersOutput vector of inlier indices.

◆ transformPoints()

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

Variable Documentation

◆ K_LOG2_WARP_SIZE

const Ncv32u K_LOG2_WARP_SIZE = 5

◆ K_WARP_SIZE

const Ncv32u K_WARP_SIZE = 32