Legacy support

Overview

NPPST Core

NPPST Image Processing

NPPST Signal Processing

// namespaces

namespace NcvCTprep;

// typedefs

typedef short Ncv16s;
typedef unsigned short Ncv16u;
typedef float Ncv32f;
typedef int Ncv32s;
typedef unsigned int Ncv32u;
typedef double Ncv64f;
typedef long long Ncv64s;
typedef unsigned long long 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;
typedef Ncv32f Ncv32f_a;
typedef Ncv32u Ncv32u_a;

// enums

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

enum
{
    @181::NCVPipeObjDet_Default             = 0x000,
    @181::NCVPipeObjDet_UseFairImageScaling = 0x001,
    @181::NCVPipeObjDet_FindLargestObject   = 0x002,
    @181::NCVPipeObjDet_VisualizeInPlace    = 0x004,
};

enum NCVMemoryType;

// structs

struct cv::cuda::FGDParams;
struct HaarClassifierCascadeDescriptor;
struct HaarClassifierNode128;
struct HaarClassifierNodeDescriptor32;
struct HaarFeature64;
struct HaarFeatureDescriptor32;
struct HaarStage64;
struct NCVBroxOpticalFlowDescriptor;
struct NCVMemPtr;
struct NCVMemSegment;
struct NcvPoint2D32s;
struct NcvPoint2D32u;
struct NcvRect32s;
struct NcvRect32u;
struct NcvRect8u;
struct NcvSize32s;
struct NcvSize32u;

// classes

class cv::cuda::BackgroundSubtractorFGD;
class cv::cuda::BackgroundSubtractorGMG;
class cv::cuda::FastOpticalFlowBM;
class INCVMemAllocator;
class cv::cuda::ImagePyramid;

template <class T>
class NCVMatrix;

template <class T>
class NCVMatrixAlloc;

template <class T>
class NCVMatrixReuse;

class NCVMemNativeAllocator;
class NCVMemStackAllocator;

template <class T>
class NCVVector;

template <class T>
class NCVVectorAlloc;

template <class T>
class NCVVectorReuse;

// global variables

const Ncv32u K_LOG2_WARP_SIZE;
const Ncv32u K_WARP_SIZE;

// global functions

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

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

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

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

Ptr<ImagePyramid>
cv::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()
    );

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

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

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

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

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

Ncv32u
alignUp(
    Ncv32u what,
    Ncv32u alignment
    );

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

void
ncvDebugOutput(const cv::String& msg);

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

void
ncvSetDebugOutputHandler(NCVDebugOutputHandler* func);

NcvTimer
ncvStartTimer(void);

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

NCV_CT_ASSERT(sizeof(HaarFeature64) = =8);
NCV_CT_ASSERT(sizeof(HaarFeatureDescriptor32) = =4);
NCV_CT_ASSERT(sizeof(HaarClassifierNodeDescriptor32) = =4);
NCV_CT_ASSERT(sizeof(HaarClassifierNode128) = =16);
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
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
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
    );

// 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
#define NCV_CT_ASSERT(X)

#define NCV_CT_PREP_PASTE( \
    a, \
    b \
    )

#define NCV_CT_PREP_PASTE_AUX( \
    a, \
    b \
    )

#define NCV_RESET_SKIP_COND(x)
#define NCV_SET_SKIP_COND(x)
#define NCV_SKIP_COND_BEGIN
#define NCV_SKIP_COND_END
#define OBJDET_MASK_ELEMENT_INVALID_32U
#define RECT_SIMILARITY_PROPORTION
#define SQR(x)

#define SUB_BEGIN( \
    type, \
    name \
    )

#define SUB_CALL(name)
#define SUB_END(name)
#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 \
    )

Detailed Documentation

Enum Values

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.

Global Functions

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::BackgroundSubtractorFGD>
cv::cuda::createBackgroundSubtractorFGD(const FGDParams& params = FGDParams())

Creates FGD Background Subtractor.

Parameters:

params

Algorithm ‘s parameters. See [47] for explanation.

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

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.

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

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.

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

performs connected componnents labeling.

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.

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.

Ncv32u
alignUp(
    Ncv32u what,
    Ncv32u alignment
    )

Calculates the aligned top bound value

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

Copy dispatchers

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

Operations with rectangles

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.

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

Macros

#define NCV_CT_ASSERT(X)

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

#define NCV_CT_PREP_PASTE( \
    a, \
    b \
    )

Concatenation macro.

#define NCV_CT_PREP_PASTE_AUX( \
    a, \
    b \
    )

Concatenation indirection macro.