Only for VS2008 now. Sample for it. new NPP_staging for VS2008 onlypull/13383/head
Anatoly Baksheev
14 years ago
parent
31e582e314
commit
1a94186195
17 changed files with 6066 additions and 185 deletions
Binary file not shown.
@ -0,0 +1,362 @@ |
||||
/*M/////////////////////////////////////////////////////////////////////////////////////// |
||||
// |
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. |
||||
// |
||||
// By downloading, copying, installing or using the software you agree to this license. |
||||
// If you do not agree to this license, do not download, install, |
||||
// copy or use the software. |
||||
// |
||||
// |
||||
// License Agreement |
||||
// For Open Source Computer Vision Library |
||||
// |
||||
// Copyright (C) 2009-2010, NVIDIA Corporation, all rights reserved. |
||||
// Third party copyrights are property of their respective owners. |
||||
// |
||||
// Redistribution and use in source and binary forms, with or without modification, |
||||
// are permitted provided that the following conditions are met: |
||||
// |
||||
// * Redistribution's of source code must retain the above copyright notice, |
||||
// this list of conditions and the following disclaimer. |
||||
// |
||||
// * Redistribution's in binary form must reproduce the above copyright notice, |
||||
// this list of conditions and the following disclaimer in the documentation |
||||
// and/or other materials provided with the distribution. |
||||
// |
||||
// * The name of the copyright holders may not be used to endorse or promote products |
||||
// derived from this software without specific prior written permission. |
||||
// |
||||
// This software is provided by the copyright holders and contributors "as is" and |
||||
// any express or implied warranties, including, but not limited to, the implied |
||||
// warranties of merchantability and fitness for a particular purpose are disclaimed. |
||||
// In no event shall the Intel Corporation or contributors be liable for any direct, |
||||
// indirect, incidental, special, exemplary, or consequential damages |
||||
// (including, but not limited to, procurement of substitute goods or services; |
||||
// loss of use, data, or profits; or business interruption) however caused |
||||
// and on any theory of liability, whether in contract, strict liability, |
||||
// or tort (including negligence or otherwise) arising in any way out of |
||||
// the use of this software, even if advised of the possibility of such damage. |
||||
// |
||||
//M*/ |
||||
|
||||
#include <cstdio> |
||||
#include <cuda_runtime.h> |
||||
|
||||
#define CV_NO_BACKWARD_COMPATIBILITY |
||||
|
||||
#include "opencv2/opencv.hpp" |
||||
|
||||
#include "NCVHaarObjectDetection.hpp" |
||||
|
||||
using namespace cv; |
||||
using namespace std; |
||||
|
||||
const Size preferredVideoFrameSize(640, 480); |
||||
|
||||
string preferredClassifier = "haarcascade_frontalface_alt.xml"; |
||||
string wndTitle = "NVIDIA Computer Vision SDK :: Face Detection in Video Feed"; |
||||
|
||||
|
||||
void printSyntax(void) |
||||
{ |
||||
printf("Syntax: FaceDetectionFeed.exe [-c cameranum | -v filename] classifier.xml\n"); |
||||
} |
||||
|
||||
|
||||
void imagePrintf(Mat& img, int lineOffsY, Scalar color, const char *format, ...) |
||||
{ |
||||
int fontFace = CV_FONT_HERSHEY_PLAIN; |
||||
double fontScale = 1; |
||||
|
||||
int baseline; |
||||
Size textSize = cv::getTextSize("T", fontFace, fontScale, 1, &baseline); |
||||
|
||||
va_list arg_ptr; |
||||
va_start(arg_ptr, format); |
||||
int len = _vscprintf(format, arg_ptr) + 1; |
||||
|
||||
vector<char> strBuf(len); |
||||
vsprintf_s(&strBuf[0], len, format, arg_ptr); |
||||
|
||||
Point org(1, 3 * textSize.height * (lineOffsY + 1) / 2); |
||||
putText(img, &strBuf[0], org, fontFace, fontScale, color); |
||||
va_end(arg_ptr); |
||||
} |
||||
|
||||
|
||||
NCVStatus process(Mat *srcdst, |
||||
Ncv32u width, Ncv32u height, |
||||
NcvBool bShowAllHypotheses, NcvBool bLargestFace, |
||||
HaarClassifierCascadeDescriptor &haar, |
||||
NCVVector<HaarStage64> &d_haarStages, NCVVector<HaarClassifierNode128> &d_haarNodes, |
||||
NCVVector<HaarFeature64> &d_haarFeatures, NCVVector<HaarStage64> &h_haarStages, |
||||
INCVMemAllocator &gpuAllocator, |
||||
INCVMemAllocator &cpuAllocator, |
||||
cudaDeviceProp &devProp) |
||||
{ |
||||
ncvAssertReturn(!((srcdst == NULL) ^ gpuAllocator.isCounting()), NCV_NULL_PTR); |
||||
|
||||
NCVStatus ncvStat; |
||||
|
||||
NCV_SET_SKIP_COND(gpuAllocator.isCounting()); |
||||
|
||||
NCVMatrixAlloc<Ncv8u> d_src(gpuAllocator, width, height); |
||||
ncvAssertReturn(d_src.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC); |
||||
NCVMatrixAlloc<Ncv8u> h_src(cpuAllocator, width, height); |
||||
ncvAssertReturn(h_src.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC); |
||||
NCVVectorAlloc<NcvRect32u> d_rects(gpuAllocator, 100); |
||||
ncvAssertReturn(d_rects.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC); |
||||
|
||||
Mat h_src_hdr(Size(width, height), CV_8U, h_src.ptr(), h_src.stride()); |
||||
|
||||
NCV_SKIP_COND_BEGIN |
||||
|
||||
(*srcdst).copyTo(h_src_hdr); |
||||
|
||||
ncvStat = h_src.copySolid(d_src, 0); |
||||
ncvAssertReturnNcvStat(ncvStat); |
||||
ncvAssertCUDAReturn(cudaStreamSynchronize(0), NCV_CUDA_ERROR); |
||||
|
||||
NCV_SKIP_COND_END |
||||
|
||||
NcvSize32u roi; |
||||
roi.width = d_src.width(); |
||||
roi.height = d_src.height(); |
||||
|
||||
Ncv32u numDetections; |
||||
ncvStat = ncvDetectObjectsMultiScale_device( |
||||
d_src, roi, d_rects, numDetections, haar, h_haarStages, |
||||
d_haarStages, d_haarNodes, d_haarFeatures, |
||||
haar.ClassifierSize, |
||||
bShowAllHypotheses ? 0 : 4, |
||||
1.2f, 1, |
||||
(bLargestFace ? NCVPipeObjDet_FindLargestObject : 0) | NCVPipeObjDet_VisualizeInPlace, |
||||
gpuAllocator, cpuAllocator, devProp.major, devProp.minor, 0); |
||||
ncvAssertReturnNcvStat(ncvStat); |
||||
ncvAssertCUDAReturn(cudaStreamSynchronize(0), NCV_CUDA_ERROR); |
||||
|
||||
NCV_SKIP_COND_BEGIN |
||||
|
||||
ncvStat = d_src.copySolid(h_src, 0); |
||||
ncvAssertReturnNcvStat(ncvStat); |
||||
ncvAssertCUDAReturn(cudaStreamSynchronize(0), NCV_CUDA_ERROR); |
||||
|
||||
h_src_hdr.copyTo(*srcdst); |
||||
|
||||
NCV_SKIP_COND_END |
||||
|
||||
return NCV_SUCCESS; |
||||
} |
||||
|
||||
|
||||
int main( int argc, const char** argv ) |
||||
{ |
||||
NCVStatus ncvStat; |
||||
|
||||
printf("NVIDIA Computer Vision SDK\n"); |
||||
printf("Face Detection in video and live feed\n"); |
||||
printf("=========================================\n"); |
||||
printf(" Esc - Quit\n"); |
||||
printf(" Space - Switch between NCV and OpenCV\n"); |
||||
printf(" L - Switch between FullSearch and LargestFace modes\n"); |
||||
printf(" U - Toggle unfiltered hypotheses visualization in FullSearch\n"); |
||||
|
||||
if (argc != 4 && argc != 1) |
||||
return printSyntax(), -1; |
||||
|
||||
VideoCapture capture; |
||||
Size frameSize; |
||||
|
||||
if (argc == 1 || strcmp(argv[1], "-c") == 0) |
||||
{ |
||||
// Camera input is specified |
||||
int camIdx = (argc == 3) ? atoi(argv[2]) : 0; |
||||
if(!capture.open(camIdx)) |
||||
return printf("Error opening camera\n"), -1; |
||||
|
||||
capture.set(CV_CAP_PROP_FRAME_WIDTH, preferredVideoFrameSize.width); |
||||
capture.set(CV_CAP_PROP_FRAME_HEIGHT, preferredVideoFrameSize.height); |
||||
capture.set(CV_CAP_PROP_FPS, 25); |
||||
frameSize = preferredVideoFrameSize; |
||||
} |
||||
else if (strcmp(argv[1], "-v") == 0) |
||||
{ |
||||
// Video file input (avi) |
||||
if(!capture.open(argv[2])) |
||||
return printf("Error opening video file\n"), -1; |
||||
|
||||
frameSize.width = (int)capture.get(CV_CAP_PROP_FRAME_WIDTH); |
||||
frameSize.height = (int)capture.get(CV_CAP_PROP_FRAME_HEIGHT); |
||||
} |
||||
else |
||||
return printSyntax(), -1; |
||||
|
||||
NcvBool bUseOpenCV = true; |
||||
NcvBool bLargestFace = true; |
||||
NcvBool bShowAllHypotheses = false; |
||||
|
||||
string classifierFile = (argc == 1) ? preferredClassifier : argv[3]; |
||||
|
||||
CascadeClassifier classifierOpenCV; |
||||
if (!classifierOpenCV.load(classifierFile)) |
||||
return printf("Error (in OpenCV) opening classifier\n"), printSyntax(), -1; |
||||
|
||||
int devId; |
||||
ncvAssertCUDAReturn(cudaGetDevice(&devId), -1); |
||||
cudaDeviceProp devProp; |
||||
ncvAssertCUDAReturn(cudaGetDeviceProperties(&devProp, devId), -1); |
||||
printf("Using GPU %d %s, arch=%d.%d\n", devId, devProp.name, devProp.major, devProp.minor); |
||||
|
||||
//============================================================================== |
||||
// |
||||
// Load the classifier from file (assuming its size is about 1 mb) |
||||
// using a simple allocator |
||||
// |
||||
//============================================================================== |
||||
|
||||
NCVMemNativeAllocator gpuCascadeAllocator(NCVMemoryTypeDevice); |
||||
ncvAssertPrintReturn(gpuCascadeAllocator.isInitialized(), "Error creating cascade GPU allocator", -1); |
||||
NCVMemNativeAllocator cpuCascadeAllocator(NCVMemoryTypeHostPinned); |
||||
ncvAssertPrintReturn(cpuCascadeAllocator.isInitialized(), "Error creating cascade CPU allocator", -1); |
||||
|
||||
Ncv32u haarNumStages, haarNumNodes, haarNumFeatures; |
||||
ncvStat = ncvHaarGetClassifierSize(classifierFile, haarNumStages, haarNumNodes, haarNumFeatures); |
||||
ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "Error reading classifier size (check the file)", -1); |
||||
|
||||
NCVVectorAlloc<HaarStage64> h_haarStages(cpuCascadeAllocator, haarNumStages); |
||||
ncvAssertPrintReturn(h_haarStages.isMemAllocated(), "Error in cascade CPU allocator", -1); |
||||
NCVVectorAlloc<HaarClassifierNode128> h_haarNodes(cpuCascadeAllocator, haarNumNodes); |
||||
ncvAssertPrintReturn(h_haarNodes.isMemAllocated(), "Error in cascade CPU allocator", -1); |
||||
NCVVectorAlloc<HaarFeature64> h_haarFeatures(cpuCascadeAllocator, haarNumFeatures); |
||||
ncvAssertPrintReturn(h_haarFeatures.isMemAllocated(), "Error in cascade CPU allocator", -1); |
||||
|
||||
HaarClassifierCascadeDescriptor haar; |
||||
ncvStat = ncvHaarLoadFromFile_host(classifierFile, haar, h_haarStages, h_haarNodes, h_haarFeatures); |
||||
ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "Error loading classifier", -1); |
||||
|
||||
NCVVectorAlloc<HaarStage64> d_haarStages(gpuCascadeAllocator, haarNumStages); |
||||
ncvAssertPrintReturn(d_haarStages.isMemAllocated(), "Error in cascade GPU allocator", -1); |
||||
NCVVectorAlloc<HaarClassifierNode128> d_haarNodes(gpuCascadeAllocator, haarNumNodes); |
||||
ncvAssertPrintReturn(d_haarNodes.isMemAllocated(), "Error in cascade GPU allocator", -1); |
||||
NCVVectorAlloc<HaarFeature64> d_haarFeatures(gpuCascadeAllocator, haarNumFeatures); |
||||
ncvAssertPrintReturn(d_haarFeatures.isMemAllocated(), "Error in cascade GPU allocator", -1); |
||||
|
||||
ncvStat = h_haarStages.copySolid(d_haarStages, 0); |
||||
ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "Error copying cascade to GPU", -1); |
||||
ncvStat = h_haarNodes.copySolid(d_haarNodes, 0); |
||||
ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "Error copying cascade to GPU", -1); |
||||
ncvStat = h_haarFeatures.copySolid(d_haarFeatures, 0); |
||||
ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "Error copying cascade to GPU", -1); |
||||
|
||||
//============================================================================== |
||||
// |
||||
// Calculate memory requirements and create real allocators |
||||
// |
||||
//============================================================================== |
||||
|
||||
NCVMemStackAllocator gpuCounter(devProp.textureAlignment); |
||||
ncvAssertPrintReturn(gpuCounter.isInitialized(), "Error creating GPU memory counter", -1); |
||||
NCVMemStackAllocator cpuCounter(devProp.textureAlignment); |
||||
ncvAssertPrintReturn(cpuCounter.isInitialized(), "Error creating CPU memory counter", -1); |
||||
|
||||
ncvStat = process(NULL, frameSize.width, frameSize.height, |
||||
false, false, haar, |
||||
d_haarStages, d_haarNodes, |
||||
d_haarFeatures, h_haarStages, |
||||
gpuCounter, cpuCounter, devProp); |
||||
ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "Error in memory counting pass", -1); |
||||
|
||||
NCVMemStackAllocator gpuAllocator(NCVMemoryTypeDevice, gpuCounter.maxSize(), devProp.textureAlignment); |
||||
ncvAssertPrintReturn(gpuAllocator.isInitialized(), "Error creating GPU memory allocator", -1); |
||||
NCVMemStackAllocator cpuAllocator(NCVMemoryTypeHostPinned, cpuCounter.maxSize(), devProp.textureAlignment); |
||||
ncvAssertPrintReturn(cpuAllocator.isInitialized(), "Error creating CPU memory allocator", -1); |
||||
|
||||
printf("Initialized for frame size [%dx%d]\n", frameSize.width, frameSize.height); |
||||
|
||||
//============================================================================== |
||||
// |
||||
// Main processing loop |
||||
// |
||||
//============================================================================== |
||||
|
||||
namedWindow(wndTitle, 1); |
||||
|
||||
Mat frame, gray, frameDisp; |
||||
|
||||
for(;;) |
||||
{ |
||||
// For camera and video file, capture the next image |
||||
capture >> frame; |
||||
if (frame.empty()) |
||||
break; |
||||
|
||||
cvtColor(frame, gray, CV_BGR2GRAY); |
||||
|
||||
// process |
||||
NcvSize32u minSize = haar.ClassifierSize; |
||||
if (bLargestFace) |
||||
{ |
||||
Ncv32u ratioX = preferredVideoFrameSize.width / minSize.width; |
||||
Ncv32u ratioY = preferredVideoFrameSize.height / minSize.height; |
||||
Ncv32u ratioSmallest = std::min(ratioX, ratioY); |
||||
ratioSmallest = (Ncv32u)std::max(ratioSmallest / 2.5f, 1.f); |
||||
minSize.width *= ratioSmallest; |
||||
minSize.height *= ratioSmallest; |
||||
} |
||||
|
||||
NcvTimer timer = ncvStartTimer(); |
||||
|
||||
if (!bUseOpenCV) |
||||
{ |
||||
ncvStat = process(&gray, frameSize.width, frameSize.height, |
||||
bShowAllHypotheses, bLargestFace, haar, |
||||
d_haarStages, d_haarNodes, |
||||
d_haarFeatures, h_haarStages, |
||||
gpuAllocator, cpuAllocator, devProp); |
||||
ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "Error in memory counting pass", -1); |
||||
} |
||||
else |
||||
{ |
||||
vector<Rect> rectsOpenCV; |
||||
|
||||
classifierOpenCV.detectMultiScale( |
||||
gray, |
||||
rectsOpenCV, |
||||
1.2f, |
||||
bShowAllHypotheses && !bLargestFace ? 0 : 4, |
||||
(bLargestFace ? CV_HAAR_FIND_BIGGEST_OBJECT : 0) | CV_HAAR_SCALE_IMAGE, |
||||
Size(minSize.width, minSize.height)); |
||||
|
||||
for (size_t rt = 0; rt < rectsOpenCV.size(); ++rt) |
||||
rectangle(gray, rectsOpenCV[rt], Scalar(255)); |
||||
} |
||||
|
||||
Ncv32f avgTime = (Ncv32f)ncvEndQueryTimerMs(timer); |
||||
|
||||
cvtColor(gray, frameDisp, CV_GRAY2BGR); |
||||
|
||||
imagePrintf(frameDisp, 0, CV_RGB(255, 0,0), "Space - Switch NCV%s / OpenCV%s", bUseOpenCV?"":" (ON)", bUseOpenCV?" (ON)":""); |
||||
imagePrintf(frameDisp, 1, CV_RGB(255, 0,0), "L - Switch FullSearch%s / LargestFace%s modes", bLargestFace?"":" (ON)", bLargestFace?" (ON)":""); |
||||
imagePrintf(frameDisp, 2, CV_RGB(255, 0,0), "U - Toggle unfiltered hypotheses visualization in FullSearch %s", bShowAllHypotheses?"(ON)":"(OFF)"); |
||||
imagePrintf(frameDisp, 3, CV_RGB(118,185,0), " Running at %f FPS on %s", 1000.0f / avgTime, bUseOpenCV?"CPU":"GPU"); |
||||
|
||||
cv::imshow(wndTitle, frameDisp); |
||||
|
||||
switch (cvWaitKey(1)) |
||||
{ |
||||
case ' ': |
||||
bUseOpenCV = !bUseOpenCV; |
||||
break; |
||||
case 'L':case 'l': |
||||
bLargestFace = !bLargestFace; |
||||
break; |
||||
case 'U':case 'u': |
||||
bShowAllHypotheses = !bShowAllHypotheses; |
||||
break; |
||||
case 27: |
||||
return 0; |
||||
} |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
@ -0,0 +1,571 @@ |
||||
/*M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2009-2010, NVIDIA Corporation, all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
//
|
||||
// * The name of the copyright holders may not be used to endorse or promote products
|
||||
// derived from this software without specific prior written permission.
|
||||
//
|
||||
// This software is provided by the copyright holders and contributors "as is" and
|
||||
// any express or implied warranties, including, but not limited to, the implied
|
||||
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
||||
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
||||
// indirect, incidental, special, exemplary, or consequential damages
|
||||
// (including, but not limited to, procurement of substitute goods or services;
|
||||
// loss of use, data, or profits; or business interruption) however caused
|
||||
// and on any theory of liability, whether in contract, strict liability,
|
||||
// or tort (including negligence or otherwise) arising in any way out of
|
||||
// the use of this software, even if advised of the possibility of such damage.
|
||||
//
|
||||
//M*/
|
||||
|
||||
|
||||
#include <precomp.hpp> |
||||
|
||||
|
||||
#if !defined (HAVE_CUDA) |
||||
|
||||
|
||||
#else /* !defined (HAVE_CUDA) */ |
||||
|
||||
|
||||
#include <stdarg.h> |
||||
#include "NCV.hpp" |
||||
|
||||
|
||||
//==============================================================================
|
||||
//
|
||||
// Error handling helpers
|
||||
//
|
||||
//==============================================================================
|
||||
|
||||
|
||||
static void stdioDebugOutput(const char *msg) |
||||
{ |
||||
printf("%s", msg); |
||||
} |
||||
|
||||
|
||||
static NCVDebugOutputHandler *debugOutputHandler = stdioDebugOutput; |
||||
|
||||
|
||||
void ncvDebugOutput(const char *msg, ...) |
||||
{ |
||||
const int K_DEBUG_STRING_MAXLEN = 1024; |
||||
char buffer[K_DEBUG_STRING_MAXLEN]; |
||||
va_list args; |
||||
va_start(args, msg); |
||||
vsnprintf_s(buffer, K_DEBUG_STRING_MAXLEN, K_DEBUG_STRING_MAXLEN-1, msg, args); |
||||
va_end (args); |
||||
debugOutputHandler(buffer); |
||||
} |
||||
|
||||
|
||||
void ncvSetDebugOutputHandler(NCVDebugOutputHandler *func) |
||||
{ |
||||
debugOutputHandler = func; |
||||
} |
||||
|
||||
|
||||
//==============================================================================
|
||||
//
|
||||
// Memory wrappers and helpers
|
||||
//
|
||||
//==============================================================================
|
||||
|
||||
|
||||
NCVStatus GPUAlignmentValue(Ncv32u &alignment) |
||||
{ |
||||
int curDev; |
||||
cudaDeviceProp curProp; |
||||
ncvAssertCUDAReturn(cudaGetDevice(&curDev), NCV_CUDA_ERROR); |
||||
ncvAssertCUDAReturn(cudaGetDeviceProperties(&curProp, curDev), NCV_CUDA_ERROR); |
||||
alignment = curProp.textureAlignment; //GPUAlignmentValue(curProp.major);
|
||||
return NCV_SUCCESS; |
||||
} |
||||
|
||||
|
||||
Ncv32u alignUp(Ncv32u what, Ncv32u alignment) |
||||
{ |
||||
Ncv32u alignMask = alignment-1; |
||||
Ncv32u inverseAlignMask = ~alignMask; |
||||
Ncv32u res = (what + alignMask) & inverseAlignMask; |
||||
return res; |
||||
} |
||||
|
||||
|
||||
void NCVMemPtr::clear() |
||||
{ |
||||
ptr = NULL; |
||||
memtype = NCVMemoryTypeNone; |
||||
} |
||||
|
||||
|
||||
void NCVMemSegment::clear() |
||||
{ |
||||
begin.clear(); |
||||
size = 0; |
||||
} |
||||
|
||||
|
||||
NCVStatus memSegCopyHelper(void *dst, NCVMemoryType dstType, const void *src, NCVMemoryType srcType, size_t sz, cudaStream_t cuStream) |
||||
{ |
||||
NCVStatus ncvStat; |
||||
switch (dstType) |
||||
{ |
||||
case NCVMemoryTypeHostPageable: |
||||
case NCVMemoryTypeHostPinned: |
||||
switch (srcType) |
||||
{ |
||||
case NCVMemoryTypeHostPageable: |
||||
case NCVMemoryTypeHostPinned: |
||||
memcpy(dst, src, sz); |
||||
ncvStat = NCV_SUCCESS; |
||||
break; |
||||
case NCVMemoryTypeDevice: |
||||
if (cuStream != 0) |
||||
{ |
||||
ncvAssertCUDAReturn(cudaMemcpyAsync(dst, src, sz, cudaMemcpyDeviceToHost, cuStream), NCV_CUDA_ERROR); |
||||
} |
||||
else |
||||
{ |
||||
ncvAssertCUDAReturn(cudaMemcpy(dst, src, sz, cudaMemcpyDeviceToHost), NCV_CUDA_ERROR); |
||||
} |
||||
ncvStat = NCV_SUCCESS; |
||||
break; |
||||
default: |
||||
ncvStat = NCV_MEM_RESIDENCE_ERROR; |
||||
} |
||||
break; |
||||
case NCVMemoryTypeDevice: |
||||
switch (srcType) |
||||
{ |
||||
case NCVMemoryTypeHostPageable: |
||||
case NCVMemoryTypeHostPinned: |
||||
if (cuStream != 0) |
||||
{ |
||||
ncvAssertCUDAReturn(cudaMemcpyAsync(dst, src, sz, cudaMemcpyHostToDevice, cuStream), NCV_CUDA_ERROR); |
||||
} |
||||
else |
||||
{ |
||||
ncvAssertCUDAReturn(cudaMemcpy(dst, src, sz, cudaMemcpyHostToDevice), NCV_CUDA_ERROR); |
||||
} |
||||
ncvStat = NCV_SUCCESS; |
||||
break; |
||||
case NCVMemoryTypeDevice: |
||||
if (cuStream != 0) |
||||
{ |
||||
ncvAssertCUDAReturn(cudaMemcpyAsync(dst, src, sz, cudaMemcpyDeviceToDevice, cuStream), NCV_CUDA_ERROR); |
||||
} |
||||
else |
||||
{ |
||||
ncvAssertCUDAReturn(cudaMemcpy(dst, src, sz, cudaMemcpyDeviceToDevice), NCV_CUDA_ERROR); |
||||
} |
||||
ncvStat = NCV_SUCCESS; |
||||
break; |
||||
default: |
||||
ncvStat = NCV_MEM_RESIDENCE_ERROR; |
||||
} |
||||
break; |
||||
default: |
||||
ncvStat = NCV_MEM_RESIDENCE_ERROR; |
||||
} |
||||
|
||||
return ncvStat; |
||||
} |
||||
|
||||
|
||||
//===================================================================
|
||||
//
|
||||
// NCVMemStackAllocator class members implementation
|
||||
//
|
||||
//===================================================================
|
||||
|
||||
|
||||
NCVMemStackAllocator::NCVMemStackAllocator(Ncv32u alignment) |
||||
: |
||||
currentSize(0), |
||||
_maxSize(0), |
||||
allocBegin(NULL), |
||||
begin(NULL), |
||||
_memType(NCVMemoryTypeNone), |
||||
_alignment(alignment) |
||||
{ |
||||
NcvBool bProperAlignment = (alignment & (alignment-1)) == 0; |
||||
ncvAssertPrintCheck(bProperAlignment, "NCVMemStackAllocator ctor:: alignment not power of 2"); |
||||
} |
||||
|
||||
|
||||
NCVMemStackAllocator::NCVMemStackAllocator(NCVMemoryType memT, size_t capacity, Ncv32u alignment) |
||||
: |
||||
currentSize(0), |
||||
_maxSize(0), |
||||
allocBegin(NULL), |
||||
_memType(memT), |
||||
_alignment(alignment) |
||||
{ |
||||
NcvBool bProperAlignment = (alignment & (alignment-1)) == 0; |
||||
ncvAssertPrintCheck(bProperAlignment, "NCVMemStackAllocator ctor:: _alignment not power of 2"); |
||||
|
||||
allocBegin = NULL; |
||||
|
||||
switch (memT) |
||||
{ |
||||
case NCVMemoryTypeDevice: |
||||
ncvAssertCUDAReturn(cudaMalloc(&allocBegin, capacity), ); |
||||
break; |
||||
case NCVMemoryTypeHostPinned: |
||||
ncvAssertCUDAReturn(cudaMallocHost(&allocBegin, capacity), ); |
||||
break; |
||||
case NCVMemoryTypeHostPageable: |
||||
allocBegin = (Ncv8u *)malloc(capacity); |
||||
break; |
||||
} |
||||
|
||||
if (capacity == 0) |
||||
{ |
||||
allocBegin = (Ncv8u *)(0x1); |
||||
} |
||||
|
||||
if (!isCounting()) |
||||
{ |
||||
begin = allocBegin; |
||||
end = begin + capacity; |
||||
} |
||||
} |
||||
|
||||
|
||||
NCVMemStackAllocator::~NCVMemStackAllocator() |
||||
{ |
||||
if (allocBegin != NULL) |
||||
{ |
||||
ncvAssertPrintCheck(currentSize == 0, "NCVMemStackAllocator dtor:: not all objects were deallocated properly, forcing destruction"); |
||||
switch (_memType) |
||||
{ |
||||
case NCVMemoryTypeDevice: |
||||
ncvAssertCUDAReturn(cudaFree(allocBegin), ); |
||||
break; |
||||
case NCVMemoryTypeHostPinned: |
||||
ncvAssertCUDAReturn(cudaFreeHost(allocBegin), ); |
||||
break; |
||||
case NCVMemoryTypeHostPageable: |
||||
free(allocBegin); |
||||
break; |
||||
} |
||||
allocBegin = NULL; |
||||
} |
||||
} |
||||
|
||||
|
||||
NCVStatus NCVMemStackAllocator::alloc(NCVMemSegment &seg, size_t size) |
||||
{ |
||||
seg.clear(); |
||||
ncvAssertReturn(isInitialized(), NCV_ALLOCATOR_BAD_ALLOC); |
||||
|
||||
size = alignUp(size, this->_alignment); |
||||
this->currentSize += size; |
||||
this->_maxSize = std::max(this->_maxSize, this->currentSize); |
||||
|
||||
if (!isCounting()) |
||||
{ |
||||
size_t availSize = end - begin; |
||||
ncvAssertReturn(size <= availSize, NCV_ALLOCATOR_INSUFFICIENT_CAPACITY); |
||||
} |
||||
|
||||
seg.begin.ptr = begin; |
||||
seg.begin.memtype = this->_memType; |
||||
seg.size = size; |
||||
begin += size; |
||||
|
||||
return NCV_SUCCESS; |
||||
} |
||||
|
||||
|
||||
NCVStatus NCVMemStackAllocator::dealloc(NCVMemSegment &seg) |
||||
{ |
||||
ncvAssertReturn(isInitialized(), NCV_ALLOCATOR_BAD_ALLOC); |
||||
ncvAssertReturn(seg.begin.memtype == this->_memType, NCV_ALLOCATOR_BAD_DEALLOC); |
||||
ncvAssertReturn(seg.begin.ptr != NULL || isCounting(), NCV_ALLOCATOR_BAD_DEALLOC); |
||||
ncvAssertReturn(seg.begin.ptr == begin - seg.size, NCV_ALLOCATOR_DEALLOC_ORDER); |
||||
|
||||
currentSize -= seg.size; |
||||
begin -= seg.size; |
||||
|
||||
seg.clear(); |
||||
|
||||
ncvAssertReturn(allocBegin <= begin, NCV_ALLOCATOR_BAD_DEALLOC); |
||||
|
||||
return NCV_SUCCESS; |
||||
} |
||||
|
||||
|
||||
NcvBool NCVMemStackAllocator::isInitialized(void) const |
||||
{ |
||||
return ((this->_alignment & (this->_alignment-1)) == 0) && isCounting() || this->allocBegin != NULL; |
||||
} |
||||
|
||||
|
||||
NcvBool NCVMemStackAllocator::isCounting(void) const |
||||
{ |
||||
return this->_memType == NCVMemoryTypeNone; |
||||
} |
||||
|
||||
|
||||
NCVMemoryType NCVMemStackAllocator::memType(void) const |
||||
{ |
||||
return this->_memType; |
||||
} |
||||
|
||||
|
||||
Ncv32u NCVMemStackAllocator::alignment(void) const |
||||
{ |
||||
return this->_alignment; |
||||
} |
||||
|
||||
|
||||
size_t NCVMemStackAllocator::maxSize(void) const |
||||
{ |
||||
return this->_maxSize; |
||||
} |
||||
|
||||
|
||||
//===================================================================
|
||||
//
|
||||
// NCVMemNativeAllocator class members implementation
|
||||
//
|
||||
//===================================================================
|
||||
|
||||
|
||||
NCVMemNativeAllocator::NCVMemNativeAllocator(NCVMemoryType memT) |
||||
: |
||||
currentSize(0), |
||||
_maxSize(0), |
||||
_memType(memT) |
||||
{ |
||||
ncvAssertPrintReturn(memT != NCVMemoryTypeNone, "NCVMemNativeAllocator ctor:: counting not permitted for this allocator type", ); |
||||
ncvAssertPrintReturn(NCV_SUCCESS == GPUAlignmentValue(this->_alignment), "NCVMemNativeAllocator ctor:: couldn't get device _alignment", ); |
||||
} |
||||
|
||||
|
||||
NCVMemNativeAllocator::~NCVMemNativeAllocator() |
||||
{ |
||||
ncvAssertPrintCheck(currentSize == 0, "NCVMemNativeAllocator dtor:: detected memory leak"); |
||||
} |
||||
|
||||
|
||||
NCVStatus NCVMemNativeAllocator::alloc(NCVMemSegment &seg, size_t size) |
||||
{ |
||||
seg.clear(); |
||||
ncvAssertReturn(isInitialized(), NCV_ALLOCATOR_BAD_ALLOC); |
||||
|
||||
switch (this->_memType) |
||||
{ |
||||
case NCVMemoryTypeDevice: |
||||
ncvAssertCUDAReturn(cudaMalloc(&seg.begin.ptr, size), NCV_CUDA_ERROR); |
||||
break; |
||||
case NCVMemoryTypeHostPinned: |
||||
ncvAssertCUDAReturn(cudaMallocHost(&seg.begin.ptr, size), NCV_CUDA_ERROR); |
||||
break; |
||||
case NCVMemoryTypeHostPageable: |
||||
seg.begin.ptr = (Ncv8u *)malloc(size); |
||||
break; |
||||
} |
||||
|
||||
this->currentSize += alignUp(size, this->_alignment); |
||||
this->_maxSize = std::max(this->_maxSize, this->currentSize); |
||||
|
||||
seg.begin.memtype = this->_memType; |
||||
seg.size = size; |
||||
|
||||
return NCV_SUCCESS; |
||||
} |
||||
|
||||
|
||||
NCVStatus NCVMemNativeAllocator::dealloc(NCVMemSegment &seg) |
||||
{ |
||||
ncvAssertReturn(isInitialized(), NCV_ALLOCATOR_BAD_ALLOC); |
||||
ncvAssertReturn(seg.begin.memtype == this->_memType, NCV_ALLOCATOR_BAD_DEALLOC); |
||||
ncvAssertReturn(seg.begin.ptr != NULL, NCV_ALLOCATOR_BAD_DEALLOC); |
||||
|
||||
ncvAssertReturn(currentSize >= alignUp(seg.size, this->_alignment), NCV_ALLOCATOR_BAD_DEALLOC); |
||||
currentSize -= alignUp(seg.size, this->_alignment); |
||||
|
||||
switch (this->_memType) |
||||
{ |
||||
case NCVMemoryTypeDevice: |
||||
ncvAssertCUDAReturn(cudaFree(seg.begin.ptr), NCV_CUDA_ERROR); |
||||
break; |
||||
case NCVMemoryTypeHostPinned: |
||||
ncvAssertCUDAReturn(cudaFreeHost(seg.begin.ptr), NCV_CUDA_ERROR); |
||||
break; |
||||
case NCVMemoryTypeHostPageable: |
||||
free(seg.begin.ptr); |
||||
break; |
||||
} |
||||
|
||||
seg.clear(); |
||||
|
||||
return NCV_SUCCESS; |
||||
} |
||||
|
||||
|
||||
NcvBool NCVMemNativeAllocator::isInitialized(void) const |
||||
{ |
||||
return (this->_alignment != 0); |
||||
} |
||||
|
||||
|
||||
NcvBool NCVMemNativeAllocator::isCounting(void) const |
||||
{ |
||||
return false; |
||||
} |
||||
|
||||
|
||||
NCVMemoryType NCVMemNativeAllocator::memType(void) const |
||||
{ |
||||
return this->_memType; |
||||
} |
||||
|
||||
|
||||
Ncv32u NCVMemNativeAllocator::alignment(void) const |
||||
{ |
||||
return this->_alignment; |
||||
} |
||||
|
||||
|
||||
size_t NCVMemNativeAllocator::maxSize(void) const |
||||
{ |
||||
return this->_maxSize; |
||||
} |
||||
|
||||
|
||||
//===================================================================
|
||||
//
|
||||
// Time and timer routines
|
||||
//
|
||||
//===================================================================
|
||||
|
||||
|
||||
typedef struct _NcvTimeMoment NcvTimeMoment; |
||||
|
||||
#if defined(_WIN32) || defined(_WIN64) |
||||
|
||||
#include <Windows.h> |
||||
|
||||
typedef struct _NcvTimeMoment |
||||
{ |
||||
LONGLONG moment, freq; |
||||
} NcvTimeMoment; |
||||
|
||||
|
||||
static void _ncvQueryMoment(NcvTimeMoment *t) |
||||
{ |
||||
QueryPerformanceFrequency((LARGE_INTEGER *)&(t->freq)); |
||||
QueryPerformanceCounter((LARGE_INTEGER *)&(t->moment)); |
||||
} |
||||
|
||||
|
||||
double _ncvMomentToMicroseconds(NcvTimeMoment *t) |
||||
{ |
||||
return 1000000.0 * t->moment / t->freq; |
||||
} |
||||
|
||||
|
||||
double _ncvMomentsDiffToMicroseconds(NcvTimeMoment *t1, NcvTimeMoment *t2) |
||||
{ |
||||
return 1000000.0 * 2 * ((t2->moment) - (t1->moment)) / (t1->freq + t2->freq); |
||||
} |
||||
|
||||
|
||||
double _ncvMomentsDiffToMilliseconds(NcvTimeMoment *t1, NcvTimeMoment *t2) |
||||
{ |
||||
return 1000.0 * 2 * ((t2->moment) - (t1->moment)) / (t1->freq + t2->freq); |
||||
} |
||||
|
||||
#elif defined(__unix__) |
||||
|
||||
#include <sys/time.h> |
||||
|
||||
typedef struct _NcvTimeMoment |
||||
{ |
||||
struct timeval tv;
|
||||
struct timezone tz; |
||||
} NcvTimeMoment; |
||||
|
||||
|
||||
void _ncvQueryMoment(NcvTimeMoment *t) |
||||
{ |
||||
gettimeofday(& t->tv, & t->tz); |
||||
} |
||||
|
||||
|
||||
double _ncvMomentToMicroseconds(NcvTimeMoment *t) |
||||
{ |
||||
return 1000000.0 * t->tv.tv_sec + (double)t->tv.tv_usec; |
||||
} |
||||
|
||||
|
||||
double _ncvMomentsDiffToMicroseconds(NcvTimeMoment *t1, NcvTimeMoment *t2) |
||||
{ |
||||
return (((double)t2->tv.tv_sec - (double)t1->tv.tv_sec) * 1000000 + (double)t2->tv.tv_usec - (double)t1->tv.tv_usec); |
||||
} |
||||
|
||||
|
||||
#endif //#if defined(_WIN32) || defined(_WIN64)
|
||||
|
||||
|
||||
struct _NcvTimer |
||||
{ |
||||
NcvTimeMoment t1, t2; |
||||
}; |
||||
|
||||
|
||||
NcvTimer ncvStartTimer(void) |
||||
{ |
||||
struct _NcvTimer *t; |
||||
t = (struct _NcvTimer *)malloc(sizeof(struct _NcvTimer)); |
||||
_ncvQueryMoment(&t->t1); |
||||
return t; |
||||
} |
||||
|
||||
|
||||
double ncvEndQueryTimerUs(NcvTimer t) |
||||
{ |
||||
double res; |
||||
_ncvQueryMoment(&t->t2); |
||||
res = _ncvMomentsDiffToMicroseconds(&t->t1, &t->t2); |
||||
free(t); |
||||
return res; |
||||
} |
||||
|
||||
|
||||
double ncvEndQueryTimerMs(NcvTimer t) |
||||
{ |
||||
double res; |
||||
_ncvQueryMoment(&t->t2); |
||||
res = _ncvMomentsDiffToMilliseconds(&t->t1, &t->t2); |
||||
free(t); |
||||
return res; |
||||
} |
||||
|
||||
#endif /* !defined (HAVE_CUDA) */ |
||||
@ -0,0 +1,837 @@ |
||||
/*M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2009-2010, NVIDIA Corporation, all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
//
|
||||
// * The name of the copyright holders may not be used to endorse or promote products
|
||||
// derived from this software without specific prior written permission.
|
||||
//
|
||||
// This software is provided by the copyright holders and contributors "as is" and
|
||||
// any express or implied warranties, including, but not limited to, the implied
|
||||
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
||||
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
||||
// indirect, incidental, special, exemplary, or consequential damages
|
||||
// (including, but not limited to, procurement of substitute goods or services;
|
||||
// loss of use, data, or profits; or business interruption) however caused
|
||||
// and on any theory of liability, whether in contract, strict liability,
|
||||
// or tort (including negligence or otherwise) arising in any way out of
|
||||
// the use of this software, even if advised of the possibility of such damage.
|
||||
//
|
||||
//M*/
|
||||
|
||||
#ifndef _ncv_hpp_ |
||||
#define _ncv_hpp_ |
||||
|
||||
#include <cuda_runtime.h> |
||||
#include "npp_staging.h" |
||||
|
||||
|
||||
//==============================================================================
|
||||
//
|
||||
// Alignment macros
|
||||
//
|
||||
//==============================================================================
|
||||
|
||||
|
||||
#if !defined(__align__) && !defined(__CUDACC__) |
||||
#if defined(_WIN32) || defined(_WIN64) |
||||
#define __align__(n) __declspec(align(n)) |
||||
#elif defined(__unix__) |
||||
#define __align__(n) __attribute__((__aligned__(n))) |
||||
#endif |
||||
#endif |
||||
|
||||
|
||||
//==============================================================================
|
||||
//
|
||||
// Integral and compound types of guaranteed size
|
||||
//
|
||||
//==============================================================================
|
||||
|
||||
|
||||
typedef bool NcvBool; |
||||
typedef long long Ncv64s; |
||||
typedef unsigned long long Ncv64u; |
||||
typedef int Ncv32s; |
||||
typedef unsigned int Ncv32u; |
||||
typedef short Ncv16s; |
||||
typedef unsigned short Ncv16u; |
||||
typedef char Ncv8s; |
||||
typedef unsigned char Ncv8u; |
||||
typedef float Ncv32f; |
||||
typedef double Ncv64f; |
||||
|
||||
|
||||
typedef struct
|
||||
{ |
||||
Ncv8u x; |
||||
Ncv8u y; |
||||
Ncv8u width; |
||||
Ncv8u height; |
||||
} NcvRect8u; |
||||
|
||||
|
||||
typedef struct
|
||||
{ |
||||
Ncv32s x; ///< x-coordinate of upper left corner.
|
||||
Ncv32s y; ///< y-coordinate of upper left corner.
|
||||
Ncv32s width; ///< Rectangle width.
|
||||
Ncv32s height; ///< Rectangle height.
|
||||
} NcvRect32s; |
||||
|
||||
|
||||
typedef struct
|
||||
{ |
||||
Ncv32u x; ///< x-coordinate of upper left corner.
|
||||
Ncv32u y; ///< y-coordinate of upper left corner.
|
||||
Ncv32u width; ///< Rectangle width.
|
||||
Ncv32u height; ///< Rectangle height.
|
||||
} NcvRect32u; |
||||
|
||||
|
||||
typedef struct
|
||||
{ |
||||
Ncv32s width; ///< Rectangle width.
|
||||
Ncv32s height; ///< Rectangle height.
|
||||
} NcvSize32s; |
||||
|
||||
|
||||
typedef struct
|
||||
{ |
||||
Ncv32u width; ///< Rectangle width.
|
||||
Ncv32u height; ///< Rectangle height.
|
||||
} NcvSize32u; |
||||
|
||||
|
||||
NPPST_CT_ASSERT(sizeof(NcvBool) <= 4); |
||||
NPPST_CT_ASSERT(sizeof(Ncv64s) == 8); |
||||
NPPST_CT_ASSERT(sizeof(Ncv64u) == 8); |
||||
NPPST_CT_ASSERT(sizeof(Ncv32s) == 4); |
||||
NPPST_CT_ASSERT(sizeof(Ncv32u) == 4); |
||||
NPPST_CT_ASSERT(sizeof(Ncv16s) == 2); |
||||
NPPST_CT_ASSERT(sizeof(Ncv16u) == 2); |
||||
NPPST_CT_ASSERT(sizeof(Ncv8s) == 1); |
||||
NPPST_CT_ASSERT(sizeof(Ncv8u) == 1); |
||||
NPPST_CT_ASSERT(sizeof(Ncv32f) == 4); |
||||
NPPST_CT_ASSERT(sizeof(Ncv64f) == 8); |
||||
NPPST_CT_ASSERT(sizeof(NcvRect8u) == sizeof(Ncv32u)); |
||||
NPPST_CT_ASSERT(sizeof(NcvRect32s) == 4 * sizeof(Ncv32s)); |
||||
NPPST_CT_ASSERT(sizeof(NcvRect32u) == 4 * sizeof(Ncv32u)); |
||||
NPPST_CT_ASSERT(sizeof(NcvSize32u) == 2 * sizeof(Ncv32u)); |
||||
|
||||
|
||||
//==============================================================================
|
||||
//
|
||||
// Persistent constants
|
||||
//
|
||||
//==============================================================================
|
||||
|
||||
|
||||
const Ncv32u K_WARP_SIZE = 32; |
||||
const Ncv32u K_LOG2_WARP_SIZE = 5; |
||||
|
||||
|
||||
//==============================================================================
|
||||
//
|
||||
// Error handling
|
||||
//
|
||||
//==============================================================================
|
||||
|
||||
|
||||
#define NCV_CT_PREP_STRINGIZE_AUX(x) #x |
||||
#define NCV_CT_PREP_STRINGIZE(x) NCV_CT_PREP_STRINGIZE_AUX(x) |
||||
|
||||
|
||||
void ncvDebugOutput(const char *msg, ...); |
||||
|
||||
|
||||
typedef void NCVDebugOutputHandler(const char* msg); |
||||
|
||||
|
||||
void ncvSetDebugOutputHandler(NCVDebugOutputHandler* func); |
||||
|
||||
|
||||
#define ncvAssertPrintCheck(pred, msg) \ |
||||
((pred) ? true : (ncvDebugOutput("\n%s\n", \
|
||||
"NCV Assertion Failed: " msg ", file=" __FILE__ ", line=" NCV_CT_PREP_STRINGIZE(__LINE__) \
|
||||
), false)) |
||||
|
||||
|
||||
#define ncvAssertPrintReturn(pred, msg, err) \ |
||||
if (ncvAssertPrintCheck(pred, msg)) ; else return err |
||||
|
||||
|
||||
#define ncvAssertReturn(pred, err) \ |
||||
do \
|
||||
{ \
|
||||
if (!(pred)) \
|
||||
{ \
|
||||
ncvDebugOutput("\n%s%d%s\n", "NCV Assertion Failed: retcode=", (int)err, ", file=" __FILE__ ", line=" NCV_CT_PREP_STRINGIZE(__LINE__)); \
|
||||
return err; \
|
||||
} \
|
||||
} while (0) |
||||
|
||||
|
||||
#define ncvAssertReturnNcvStat(ncvOp) \ |
||||
do \
|
||||
{ \
|
||||
NCVStatus _ncvStat = ncvOp; \
|
||||
if (NCV_SUCCESS != _ncvStat) \
|
||||
{ \
|
||||
ncvDebugOutput("\n%s%d%s\n", "NCV Assertion Failed: NcvStat=", (int)_ncvStat, ", file=" __FILE__ ", line=" NCV_CT_PREP_STRINGIZE(__LINE__)); \
|
||||
return _ncvStat; \
|
||||
} \
|
||||
} while (0) |
||||
|
||||
|
||||
#define ncvAssertCUDAReturn(cudacall, errCode) \ |
||||
do \
|
||||
{ \
|
||||
cudaError_t resCall = cudacall; \
|
||||
cudaError_t resGLE = cudaGetLastError(); \
|
||||
if (cudaSuccess != resCall || cudaSuccess != resGLE) \
|
||||
{ \
|
||||
ncvDebugOutput("\n%s%d%s\n", "NCV CUDA Assertion Failed: cudaError_t=", (int)(resCall | resGLE), ", file=" __FILE__ ", line=" NCV_CT_PREP_STRINGIZE(__LINE__)); \
|
||||
return errCode; \
|
||||
} \
|
||||
} while (0) |
||||
|
||||
|
||||
/**
|
||||
* Return-codes for status notification, errors and warnings |
||||
*/ |
||||
enum NCVStatus |
||||
{ |
||||
NCV_SUCCESS, |
||||
|
||||
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_WARNING_HAAR_DETECTIONS_VECTOR_OVERFLOW, |
||||
}; |
||||
|
||||
|
||||
#define NCV_SET_SKIP_COND(x) \ |
||||
bool __ncv_skip_cond = x |
||||
|
||||
|
||||
#define NCV_RESET_SKIP_COND(x) \ |
||||
__ncv_skip_cond = x |
||||
|
||||
|
||||
#define NCV_SKIP_COND_BEGIN \ |
||||
if (!__ncv_skip_cond) { |
||||
|
||||
|
||||
#define NCV_SKIP_COND_END \ |
||||
} |
||||
|
||||
|
||||
//==============================================================================
|
||||
//
|
||||
// Timer
|
||||
//
|
||||
//==============================================================================
|
||||
|
||||
|
||||
typedef struct _NcvTimer *NcvTimer; |
||||
|
||||
NcvTimer ncvStartTimer(void); |
||||
|
||||
double ncvEndQueryTimerUs(NcvTimer t); |
||||
|
||||
double ncvEndQueryTimerMs(NcvTimer t); |
||||
|
||||
|
||||
//==============================================================================
|
||||
//
|
||||
// Memory management classes template compound types
|
||||
//
|
||||
//==============================================================================
|
||||
|
||||
|
||||
/**
|
||||
* Alignment of GPU memory chunks in bytes |
||||
*/ |
||||
NCVStatus GPUAlignmentValue(Ncv32u &alignment); |
||||
|
||||
|
||||
/**
|
||||
* Calculates the aligned top bound value |
||||
*/ |
||||
Ncv32u alignUp(Ncv32u what, Ncv32u alignment); |
||||
|
||||
|
||||
/**
|
||||
* NCVMemoryType |
||||
*/ |
||||
enum NCVMemoryType |
||||
{ |
||||
NCVMemoryTypeNone, |
||||
NCVMemoryTypeHostPageable, |
||||
NCVMemoryTypeHostPinned, |
||||
NCVMemoryTypeDevice |
||||
}; |
||||
|
||||
|
||||
/**
|
||||
* NCVMemPtr |
||||
*/ |
||||
struct NCVMemPtr |
||||
{ |
||||
void *ptr; |
||||
NCVMemoryType memtype; |
||||
void clear(); |
||||
}; |
||||
|
||||
|
||||
/**
|
||||
* NCVMemSegment |
||||
*/ |
||||
struct NCVMemSegment |
||||
{ |
||||
NCVMemPtr begin; |
||||
size_t size; |
||||
void clear(); |
||||
}; |
||||
|
||||
|
||||
/**
|
||||
* INCVMemAllocator (Interface) |
||||
*/ |
||||
class INCVMemAllocator |
||||
{ |
||||
public: |
||||
virtual ~INCVMemAllocator() = 0; |
||||
|
||||
virtual NCVStatus alloc(NCVMemSegment &seg, size_t size) = 0; |
||||
virtual NCVStatus dealloc(NCVMemSegment &seg) = 0; |
||||
|
||||
virtual NcvBool isInitialized(void) const = 0; |
||||
virtual NcvBool isCounting(void) const = 0; |
||||
|
||||
virtual NCVMemoryType memType(void) const = 0; |
||||
virtual Ncv32u alignment(void) const = 0; |
||||
virtual size_t maxSize(void) const = 0; |
||||
}; |
||||
|
||||
inline INCVMemAllocator::~INCVMemAllocator() {} |
||||
|
||||
|
||||
/**
|
||||
* NCVMemStackAllocator |
||||
*/ |
||||
class NCVMemStackAllocator : public INCVMemAllocator |
||||
{ |
||||
NCVMemStackAllocator(); |
||||
NCVMemStackAllocator(const NCVMemStackAllocator &); |
||||
|
||||
public: |
||||
|
||||
explicit NCVMemStackAllocator(Ncv32u alignment); |
||||
NCVMemStackAllocator(NCVMemoryType memT, size_t capacity, Ncv32u alignment); |
||||
virtual ~NCVMemStackAllocator(); |
||||
|
||||
virtual NCVStatus alloc(NCVMemSegment &seg, size_t size); |
||||
virtual NCVStatus dealloc(NCVMemSegment &seg); |
||||
|
||||
virtual NcvBool isInitialized(void) const; |
||||
virtual NcvBool isCounting(void) const; |
||||
|
||||
virtual NCVMemoryType memType(void) const; |
||||
virtual Ncv32u alignment(void) const; |
||||
virtual size_t maxSize(void) const; |
||||
|
||||
private: |
||||
|
||||
NCVMemoryType _memType; |
||||
Ncv32u _alignment; |
||||
Ncv8u *allocBegin; |
||||
Ncv8u *begin; |
||||
Ncv8u *end; |
||||
size_t currentSize; |
||||
size_t _maxSize; |
||||
}; |
||||
|
||||
|
||||
/**
|
||||
* NCVMemNativeAllocator |
||||
*/ |
||||
class NCVMemNativeAllocator : public INCVMemAllocator |
||||
{ |
||||
public: |
||||
|
||||
NCVMemNativeAllocator(NCVMemoryType memT); |
||||
virtual ~NCVMemNativeAllocator(); |
||||
|
||||
virtual NCVStatus alloc(NCVMemSegment &seg, size_t size); |
||||
virtual NCVStatus dealloc(NCVMemSegment &seg); |
||||
|
||||
virtual NcvBool isInitialized(void) const; |
||||
virtual NcvBool isCounting(void) const; |
||||
|
||||
virtual NCVMemoryType memType(void) const; |
||||
virtual Ncv32u alignment(void) const; |
||||
virtual size_t maxSize(void) const; |
||||
|
||||
private: |
||||
|
||||
NCVMemNativeAllocator(); |
||||
NCVMemNativeAllocator(const NCVMemNativeAllocator &); |
||||
|
||||
NCVMemoryType _memType; |
||||
Ncv32u _alignment; |
||||
size_t currentSize; |
||||
size_t _maxSize; |
||||
}; |
||||
|
||||
|
||||
/**
|
||||
* Copy dispatcher |
||||
*/ |
||||
NCVStatus memSegCopyHelper(void *dst, NCVMemoryType dstType, |
||||
const void *src, NCVMemoryType srcType, |
||||
size_t sz, cudaStream_t cuStream); |
||||
|
||||
|
||||
/**
|
||||
* NCVVector (1D) |
||||
*/ |
||||
template <class T> |
||||
class NCVVector |
||||
{ |
||||
NCVVector(const NCVVector &); |
||||
|
||||
public: |
||||
|
||||
NCVVector() |
||||
{ |
||||
clear(); |
||||
} |
||||
|
||||
virtual ~NCVVector() {} |
||||
|
||||
void clear() |
||||
{ |
||||
_ptr = NULL; |
||||
_length = 0; |
||||
_memtype = NCVMemoryTypeNone; |
||||
} |
||||
|
||||
NCVStatus copySolid(NCVVector<T> &dst, cudaStream_t cuStream, size_t howMuch=0) |
||||
{ |
||||
if (howMuch == 0) |
||||
{ |
||||
ncvAssertReturn(dst._length == this->_length, NCV_MEM_COPY_ERROR); |
||||
howMuch = this->_length * sizeof(T); |
||||
} |
||||
else |
||||
{ |
||||
ncvAssertReturn(dst._length * sizeof(T) >= howMuch &&
|
||||
this->_length * sizeof(T) >= howMuch && |
||||
howMuch > 0, NCV_MEM_COPY_ERROR); |
||||
} |
||||
ncvAssertReturn((this->_ptr != NULL || this->_memtype == NCVMemoryTypeNone) &&
|
||||
(dst._ptr != NULL || dst._memtype == NCVMemoryTypeNone), NCV_NULL_PTR); |
||||
|
||||
NCVStatus ncvStat = NCV_SUCCESS; |
||||
if (this->_memtype != NCVMemoryTypeNone) |
||||
{ |
||||
ncvStat = memSegCopyHelper(dst._ptr, dst._memtype, |
||||
this->_ptr, this->_memtype, |
||||
howMuch, cuStream); |
||||
} |
||||
|
||||
return ncvStat; |
||||
} |
||||
|
||||
T *ptr() const {return this->_ptr;} |
||||
size_t length() const {return this->_length;} |
||||
NCVMemoryType memType() const {return this->_memtype;} |
||||
|
||||
protected: |
||||
|
||||
T *_ptr; |
||||
size_t _length; |
||||
NCVMemoryType _memtype; |
||||
}; |
||||
|
||||
|
||||
/**
|
||||
* NCVVectorAlloc |
||||
*/ |
||||
template <class T> |
||||
class NCVVectorAlloc : public NCVVector<T> |
||||
{ |
||||
NCVVectorAlloc(); |
||||
NCVVectorAlloc(const NCVVectorAlloc &); |
||||
|
||||
public: |
||||
|
||||
NCVVectorAlloc(INCVMemAllocator &allocator, Ncv32u length) |
||||
: |
||||
allocator(allocator) |
||||
{ |
||||
NCVStatus ncvStat; |
||||
|
||||
this->clear(); |
||||
this->allocatedMem.clear(); |
||||
|
||||
ncvStat = allocator.alloc(this->allocatedMem, length * sizeof(T)); |
||||
ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "NCVVectorAlloc ctor:: alloc failed", ); |
||||
|
||||
this->_ptr = (T *)this->allocatedMem.begin.ptr; |
||||
this->_length = length; |
||||
this->_memtype = this->allocatedMem.begin.memtype; |
||||
} |
||||
|
||||
|
||||
~NCVVectorAlloc() |
||||
{ |
||||
NCVStatus ncvStat; |
||||
|
||||
ncvStat = allocator.dealloc(this->allocatedMem); |
||||
ncvAssertPrintCheck(ncvStat == NCV_SUCCESS, "NCVVectorAlloc dtor:: dealloc failed"); |
||||
|
||||
this->clear(); |
||||
} |
||||
|
||||
|
||||
NcvBool isMemAllocated() const |
||||
{ |
||||
return (this->allocatedMem.begin.ptr != NULL) || (this->allocator.isCounting()); |
||||
} |
||||
|
||||
|
||||
Ncv32u getAllocatorsAlignment() const |
||||
{ |
||||
return allocator.alignment(); |
||||
} |
||||
|
||||
|
||||
NCVMemSegment getSegment() const |
||||
{ |
||||
return allocatedMem; |
||||
} |
||||
|
||||
private: |
||||
|
||||
INCVMemAllocator &allocator; |
||||
NCVMemSegment allocatedMem; |
||||
}; |
||||
|
||||
|
||||
/**
|
||||
* NCVVectorReuse |
||||
*/ |
||||
template <class T> |
||||
class NCVVectorReuse : public NCVVector<T> |
||||
{ |
||||
NCVVectorReuse(); |
||||
NCVVectorReuse(const NCVVectorReuse &); |
||||
|
||||
public: |
||||
|
||||
explicit NCVVectorReuse(const NCVMemSegment &memSegment) |
||||
{ |
||||
this->bReused = false; |
||||
this->clear(); |
||||
|
||||
this->_length = memSegment.size / sizeof(T); |
||||
this->_ptr = (T *)memSegment.begin.ptr; |
||||
this->_memtype = memSegment.begin.memtype; |
||||
|
||||
this->bReused = true; |
||||
} |
||||
|
||||
|
||||
NCVVectorReuse(const NCVMemSegment &memSegment, Ncv32u length) |
||||
{ |
||||
this->bReused = false; |
||||
this->clear(); |
||||
|
||||
ncvAssertPrintReturn(length * sizeof(T) <= memSegment.size, \
|
||||
"NCVVectorReuse ctor:: memory binding failed due to size mismatch", ); |
||||
|
||||
this->_length = length; |
||||
this->_ptr = (T *)memSegment.begin.ptr; |
||||
this->_memtype = memSegment.begin.memtype; |
||||
|
||||
this->bReused = true; |
||||
} |
||||
|
||||
|
||||
NcvBool isMemReused() const |
||||
{ |
||||
return this->bReused; |
||||
} |
||||
|
||||
private: |
||||
|
||||
NcvBool bReused; |
||||
}; |
||||
|
||||
|
||||
/**
|
||||
* NCVMatrix (2D) |
||||
*/ |
||||
template <class T> |
||||
class NCVMatrix |
||||
{ |
||||
NCVMatrix(const NCVMatrix &); |
||||
|
||||
public: |
||||
|
||||
NCVMatrix() |
||||
{ |
||||
clear(); |
||||
} |
||||
|
||||
virtual ~NCVMatrix() {} |
||||
|
||||
|
||||
void clear() |
||||
{ |
||||
_ptr = NULL; |
||||
_pitch = 0; |
||||
_width = 0; |
||||
_height = 0; |
||||
_memtype = NCVMemoryTypeNone; |
||||
} |
||||
|
||||
|
||||
Ncv32u stride() const |
||||
{ |
||||
return _pitch / sizeof(T); |
||||
} |
||||
|
||||
|
||||
NCVStatus copySolid(NCVMatrix<T> &dst, cudaStream_t cuStream, size_t howMuch=0) |
||||
{ |
||||
if (howMuch == 0) |
||||
{ |
||||
ncvAssertReturn(dst._pitch == this->_pitch && |
||||
dst._height == this->_height, NCV_MEM_COPY_ERROR); |
||||
howMuch = this->_pitch * this->_height; |
||||
} |
||||
else |
||||
{ |
||||
ncvAssertReturn(dst._pitch * dst._height >= howMuch &&
|
||||
this->_pitch * this->_height >= howMuch && |
||||
howMuch > 0, NCV_MEM_COPY_ERROR); |
||||
} |
||||
ncvAssertReturn((this->_ptr != NULL || this->_memtype == NCVMemoryTypeNone) &&
|
||||
(dst._ptr != NULL || dst._memtype == NCVMemoryTypeNone), NCV_NULL_PTR); |
||||
|
||||
NCVStatus ncvStat = NCV_SUCCESS; |
||||
if (this->_memtype != NCVMemoryTypeNone) |
||||
{ |
||||
ncvStat = memSegCopyHelper(dst._ptr, dst._memtype,
|
||||
this->_ptr, this->_memtype,
|
||||
howMuch, cuStream); |
||||
} |
||||
|
||||
return ncvStat; |
||||
} |
||||
|
||||
T *ptr() const {return this->_ptr;} |
||||
Ncv32u width() const {return this->_width;} |
||||
Ncv32u height() const {return this->_height;} |
||||
Ncv32u pitch() const {return this->_pitch;} |
||||
NCVMemoryType memType() const {return this->_memtype;} |
||||
|
||||
protected: |
||||
|
||||
T *_ptr; |
||||
Ncv32u _width; |
||||
Ncv32u _height; |
||||
Ncv32u _pitch; |
||||
NCVMemoryType _memtype; |
||||
}; |
||||
|
||||
|
||||
/**
|
||||
* NCVMatrixAlloc |
||||
*/ |
||||
template <class T> |
||||
class NCVMatrixAlloc : public NCVMatrix<T> |
||||
{ |
||||
NCVMatrixAlloc(); |
||||
NCVMatrixAlloc(const NCVMatrixAlloc &); |
||||
|
||||
public: |
||||
|
||||
NCVMatrixAlloc(INCVMemAllocator &allocator, Ncv32u width, Ncv32u height, Ncv32u pitch=0) |
||||
: |
||||
allocator(allocator) |
||||
{ |
||||
NCVStatus ncvStat; |
||||
|
||||
this->clear(); |
||||
this->allocatedMem.clear(); |
||||
|
||||
Ncv32u widthBytes = width * sizeof(T); |
||||
Ncv32u pitchBytes = alignUp(widthBytes, allocator.alignment()); |
||||
|
||||
if (pitch != 0) |
||||
{ |
||||
ncvAssertPrintReturn(pitch >= pitchBytes && |
||||
(pitch & (allocator.alignment() - 1)) == 0, |
||||
"NCVMatrixAlloc ctor:: incorrect pitch passed", ); |
||||
pitchBytes = pitch; |
||||
} |
||||
|
||||
Ncv32u requiredAllocSize = pitchBytes * height; |
||||
|
||||
ncvStat = allocator.alloc(this->allocatedMem, requiredAllocSize); |
||||
ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "NCVMatrixAlloc ctor:: alloc failed", ); |
||||
|
||||
this->_ptr = (T *)this->allocatedMem.begin.ptr; |
||||
this->_width = width; |
||||
this->_height = height; |
||||
this->_pitch = pitchBytes; |
||||
this->_memtype = this->allocatedMem.begin.memtype; |
||||
} |
||||
|
||||
~NCVMatrixAlloc() |
||||
{ |
||||
NCVStatus ncvStat; |
||||
|
||||
ncvStat = allocator.dealloc(this->allocatedMem); |
||||
ncvAssertPrintCheck(ncvStat == NCV_SUCCESS, "NCVMatrixAlloc dtor:: dealloc failed"); |
||||
|
||||
this->clear(); |
||||
} |
||||
|
||||
|
||||
NcvBool isMemAllocated() const |
||||
{ |
||||
return (this->allocatedMem.begin.ptr != NULL) || (this->allocator.isCounting()); |
||||
} |
||||
|
||||
|
||||
Ncv32u getAllocatorsAlignment() const |
||||
{ |
||||
return allocator.alignment(); |
||||
} |
||||
|
||||
|
||||
NCVMemSegment getSegment() const |
||||
{ |
||||
return allocatedMem; |
||||
} |
||||
|
||||
private: |
||||
|
||||
INCVMemAllocator &allocator; |
||||
NCVMemSegment allocatedMem; |
||||
}; |
||||
|
||||
|
||||
/**
|
||||
* NCVMatrixReuse |
||||
*/ |
||||
template <class T> |
||||
class NCVMatrixReuse : public NCVMatrix<T> |
||||
{ |
||||
NCVMatrixReuse(); |
||||
NCVMatrixReuse(const NCVMatrixReuse &); |
||||
|
||||
public: |
||||
|
||||
NCVMatrixReuse(const NCVMemSegment &memSegment, Ncv32u alignment, Ncv32u width, Ncv32u height, Ncv32u pitch=0, NcvBool bSkipPitchCheck=false) |
||||
{ |
||||
this->bReused = false; |
||||
this->clear(); |
||||
|
||||
Ncv32u widthBytes = width * sizeof(T); |
||||
Ncv32u pitchBytes = alignUp(widthBytes, alignment); |
||||
|
||||
if (pitch != 0) |
||||
{ |
||||
if (!bSkipPitchCheck) |
||||
{ |
||||
ncvAssertPrintReturn(pitch >= pitchBytes && |
||||
(pitch & (alignment - 1)) == 0, |
||||
"NCVMatrixReuse ctor:: incorrect pitch passed", ); |
||||
} |
||||
else |
||||
{ |
||||
ncvAssertPrintReturn(pitch >= widthBytes, "NCVMatrixReuse ctor:: incorrect pitch passed", ); |
||||
} |
||||
pitchBytes = pitch; |
||||
} |
||||
|
||||
ncvAssertPrintReturn(pitchBytes * height <= memSegment.size, \
|
||||
"NCVMatrixReuse ctor:: memory binding failed due to size mismatch", ); |
||||
|
||||
this->_width = width; |
||||
this->_height = height; |
||||
this->_pitch = pitchBytes; |
||||
this->_ptr = (T *)memSegment.begin.ptr; |
||||
this->_memtype = memSegment.begin.memtype; |
||||
|
||||
this->bReused = true; |
||||
} |
||||
|
||||
|
||||
NcvBool isMemReused() const |
||||
{ |
||||
return this->bReused; |
||||
} |
||||
|
||||
private: |
||||
|
||||
NcvBool bReused; |
||||
}; |
||||
|
||||
#endif // _ncv_hpp_
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,501 @@ |
||||
/*M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2009-2010, NVIDIA Corporation, all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
//
|
||||
// * The name of the copyright holders may not be used to endorse or promote products
|
||||
// derived from this software without specific prior written permission.
|
||||
//
|
||||
// This software is provided by the copyright holders and contributors "as is" and
|
||||
// any express or implied warranties, including, but not limited to, the implied
|
||||
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
||||
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
||||
// indirect, incidental, special, exemplary, or consequential damages
|
||||
// (including, but not limited to, procurement of substitute goods or services;
|
||||
// loss of use, data, or profits; or business interruption) however caused
|
||||
// and on any theory of liability, whether in contract, strict liability,
|
||||
// or tort (including negligence or otherwise) arising in any way out of
|
||||
// the use of this software, even if advised of the possibility of such damage.
|
||||
//
|
||||
//M*/
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// NVIDIA CUDA implementation of Viola-Jones Object Detection Framework
|
||||
//
|
||||
// The algorithm and code are explained in the upcoming GPU Computing Gems
|
||||
// chapter in detail:
|
||||
//
|
||||
// Anton Obukhov, "Haar Classifiers for Object Detection with CUDA"
|
||||
// PDF URL placeholder
|
||||
// email: aobukhov@nvidia.com, devsupport@nvidia.com
|
||||
//
|
||||
// Credits for help with the code to:
|
||||
// Alexey Mendelenko, Cyril Crassin, and Mikhail Smirnov.
|
||||
//
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _ncvhaarobjectdetection_hpp_ |
||||
#define _ncvhaarobjectdetection_hpp_ |
||||
|
||||
#include <string> |
||||
#include "NCV.hpp" |
||||
|
||||
|
||||
//==============================================================================
|
||||
//
|
||||
// Guaranteed size cross-platform classifier structures
|
||||
//
|
||||
//==============================================================================
|
||||
|
||||
|
||||
struct HaarFeature64 |
||||
{ |
||||
uint2 _ui2; |
||||
|
||||
#define HaarFeature64_CreateCheck_MaxRectField 0xFF |
||||
|
||||
__host__ NCVStatus setRect(Ncv32u rectX, Ncv32u rectY, Ncv32u rectWidth, Ncv32u rectHeight, Ncv32u clsWidth, Ncv32u clsHeight) |
||||
{ |
||||
ncvAssertReturn(rectWidth <= HaarFeature64_CreateCheck_MaxRectField && rectHeight <= HaarFeature64_CreateCheck_MaxRectField, NCV_HAAR_TOO_LARGE_FEATURES); |
||||
((NcvRect8u*)&(this->_ui2.x))->x = rectX; |
||||
((NcvRect8u*)&(this->_ui2.x))->y = rectY; |
||||
((NcvRect8u*)&(this->_ui2.x))->width = rectWidth; |
||||
((NcvRect8u*)&(this->_ui2.x))->height = rectHeight; |
||||
return NCV_SUCCESS; |
||||
} |
||||
|
||||
__host__ NCVStatus setWeight(Ncv32f weight) |
||||
{ |
||||
((Ncv32f*)&(this->_ui2.y))[0] = weight; |
||||
return NCV_SUCCESS; |
||||
} |
||||
|
||||
__device__ __host__ void getRect(Ncv32u *rectX, Ncv32u *rectY, Ncv32u *rectWidth, Ncv32u *rectHeight) |
||||
{ |
||||
NcvRect8u tmpRect = *(NcvRect8u*)(&this->_ui2.x); |
||||
*rectX = tmpRect.x; |
||||
*rectY = tmpRect.y; |
||||
*rectWidth = tmpRect.width; |
||||
*rectHeight = tmpRect.height; |
||||
} |
||||
|
||||
__device__ __host__ Ncv32f getWeight(void) |
||||
{ |
||||
return *(Ncv32f*)(&this->_ui2.y); |
||||
} |
||||
}; |
||||
|
||||
|
||||
struct HaarFeatureDescriptor32 |
||||
{ |
||||
private: |
||||
|
||||
#define HaarFeatureDescriptor32_Interpret_MaskFlagTilted 0x80000000 |
||||
#define HaarFeatureDescriptor32_CreateCheck_MaxNumFeatures 0x7F |
||||
#define HaarFeatureDescriptor32_NumFeatures_Shift 24 |
||||
#define HaarFeatureDescriptor32_CreateCheck_MaxFeatureOffset 0x00FFFFFF |
||||
|
||||
Ncv32u desc; |
||||
|
||||
public: |
||||
|
||||
__host__ NCVStatus create(NcvBool bTilted, Ncv32u numFeatures, Ncv32u offsetFeatures) |
||||
{ |
||||
if (numFeatures > HaarFeatureDescriptor32_CreateCheck_MaxNumFeatures) |
||||
{ |
||||
return NCV_HAAR_TOO_MANY_FEATURES_IN_CLASSIFIER; |
||||
} |
||||
if (offsetFeatures > HaarFeatureDescriptor32_CreateCheck_MaxFeatureOffset) |
||||
{ |
||||
return NCV_HAAR_TOO_MANY_FEATURES_IN_CASCADE; |
||||
} |
||||
this->desc = 0; |
||||
this->desc |= (bTilted ? HaarFeatureDescriptor32_Interpret_MaskFlagTilted : 0); |
||||
this->desc |= (numFeatures << HaarFeatureDescriptor32_NumFeatures_Shift); |
||||
this->desc |= offsetFeatures; |
||||
return NCV_SUCCESS; |
||||
} |
||||
|
||||
__device__ __host__ NcvBool isTilted(void) |
||||
{ |
||||
return (this->desc & HaarFeatureDescriptor32_Interpret_MaskFlagTilted) != 0; |
||||
} |
||||
|
||||
__device__ __host__ Ncv32u getNumFeatures(void) |
||||
{ |
||||
return (this->desc & ~HaarFeatureDescriptor32_Interpret_MaskFlagTilted) >> HaarFeatureDescriptor32_NumFeatures_Shift; |
||||
} |
||||
|
||||
__device__ __host__ Ncv32u getFeaturesOffset(void) |
||||
{ |
||||
return this->desc & HaarFeatureDescriptor32_CreateCheck_MaxFeatureOffset; |
||||
} |
||||
}; |
||||
|
||||
|
||||
struct HaarClassifierNodeDescriptor32 |
||||
{ |
||||
uint1 _ui1; |
||||
|
||||
#define HaarClassifierNodeDescriptor32_Interpret_MaskSwitch (1 << 30) |
||||
|
||||
__host__ NCVStatus create(Ncv32f leafValue) |
||||
{ |
||||
if ((*(Ncv32u *)&leafValue) & HaarClassifierNodeDescriptor32_Interpret_MaskSwitch) |
||||
{ |
||||
return NCV_HAAR_XML_LOADING_EXCEPTION; |
||||
} |
||||
*(Ncv32f *)&this->_ui1 = leafValue; |
||||
return NCV_SUCCESS; |
||||
} |
||||
|
||||
__host__ NCVStatus create(Ncv32u offsetHaarClassifierNode) |
||||
{ |
||||
if (offsetHaarClassifierNode >= HaarClassifierNodeDescriptor32_Interpret_MaskSwitch) |
||||
{ |
||||
return NCV_HAAR_XML_LOADING_EXCEPTION; |
||||
} |
||||
this->_ui1.x = offsetHaarClassifierNode; |
||||
this->_ui1.x |= HaarClassifierNodeDescriptor32_Interpret_MaskSwitch; |
||||
return NCV_SUCCESS; |
||||
} |
||||
|
||||
__device__ __host__ NcvBool isLeaf(void) |
||||
{ |
||||
return !(this->_ui1.x & HaarClassifierNodeDescriptor32_Interpret_MaskSwitch); |
||||
} |
||||
|
||||
__host__ Ncv32f getLeafValueHost(void) |
||||
{ |
||||
return *(Ncv32f *)&this->_ui1.x; |
||||
} |
||||
|
||||
#ifdef __CUDACC__ |
||||
__device__ Ncv32f getLeafValue(void) |
||||
{ |
||||
return __int_as_float(this->_ui1.x); |
||||
} |
||||
#endif |
||||
|
||||
__device__ __host__ Ncv32u getNextNodeOffset(void) |
||||
{ |
||||
return (this->_ui1.x & ~HaarClassifierNodeDescriptor32_Interpret_MaskSwitch); |
||||
} |
||||
}; |
||||
|
||||
|
||||
struct HaarClassifierNode128 |
||||
{ |
||||
uint4 _ui4; |
||||
|
||||
__host__ NCVStatus setFeatureDesc(HaarFeatureDescriptor32 f) |
||||
{ |
||||
this->_ui4.x = *(Ncv32u *)&f; |
||||
return NCV_SUCCESS; |
||||
} |
||||
|
||||
__host__ NCVStatus setThreshold(Ncv32f t) |
||||
{ |
||||
this->_ui4.y = *(Ncv32u *)&t; |
||||
return NCV_SUCCESS; |
||||
} |
||||
|
||||
__host__ NCVStatus setLeftNodeDesc(HaarClassifierNodeDescriptor32 nl) |
||||
{ |
||||
this->_ui4.z = *(Ncv32u *)&nl; |
||||
return NCV_SUCCESS; |
||||
} |
||||
|
||||
__host__ NCVStatus setRightNodeDesc(HaarClassifierNodeDescriptor32 nr) |
||||
{ |
||||
this->_ui4.w = *(Ncv32u *)&nr; |
||||
return NCV_SUCCESS; |
||||
} |
||||
|
||||
__host__ __device__ HaarFeatureDescriptor32 getFeatureDesc(void) |
||||
{ |
||||
return *(HaarFeatureDescriptor32 *)&this->_ui4.x; |
||||
} |
||||
|
||||
__host__ __device__ Ncv32f getThreshold(void) |
||||
{ |
||||
return *(Ncv32f*)&this->_ui4.y; |
||||
} |
||||
|
||||
__host__ __device__ HaarClassifierNodeDescriptor32 getLeftNodeDesc(void) |
||||
{ |
||||
return *(HaarClassifierNodeDescriptor32 *)&this->_ui4.z; |
||||
} |
||||
|
||||
__host__ __device__ HaarClassifierNodeDescriptor32 getRightNodeDesc(void) |
||||
{ |
||||
return *(HaarClassifierNodeDescriptor32 *)&this->_ui4.w; |
||||
} |
||||
}; |
||||
|
||||
|
||||
struct HaarStage64 |
||||
{ |
||||
#define HaarStage64_Interpret_MaskRootNodes 0x0000FFFF |
||||
#define HaarStage64_Interpret_MaskRootNodeOffset 0xFFFF0000 |
||||
#define HaarStage64_Interpret_ShiftRootNodeOffset 16 |
||||
|
||||
uint2 _ui2; |
||||
|
||||
__host__ NCVStatus setStageThreshold(Ncv32f t) |
||||
{ |
||||
this->_ui2.x = *(Ncv32u *)&t; |
||||
return NCV_SUCCESS; |
||||
} |
||||
|
||||
__host__ NCVStatus setStartClassifierRootNodeOffset(Ncv32u val) |
||||
{ |
||||
if (val > (HaarStage64_Interpret_MaskRootNodeOffset >> HaarStage64_Interpret_ShiftRootNodeOffset)) |
||||
{ |
||||
return NCV_HAAR_XML_LOADING_EXCEPTION; |
||||
} |
||||
this->_ui2.y = (val << HaarStage64_Interpret_ShiftRootNodeOffset) | (this->_ui2.y & HaarStage64_Interpret_MaskRootNodes); |
||||
return NCV_SUCCESS; |
||||
} |
||||
|
||||
__host__ NCVStatus setNumClassifierRootNodes(Ncv32u val) |
||||
{ |
||||
if (val > HaarStage64_Interpret_MaskRootNodes) |
||||
{ |
||||
return NCV_HAAR_XML_LOADING_EXCEPTION; |
||||
} |
||||
this->_ui2.y = val | (this->_ui2.y & HaarStage64_Interpret_MaskRootNodeOffset); |
||||
return NCV_SUCCESS; |
||||
} |
||||
|
||||
__host__ __device__ Ncv32f getStageThreshold(void) |
||||
{ |
||||
return *(Ncv32f*)&this->_ui2.x; |
||||
} |
||||
|
||||
__host__ __device__ Ncv32u getStartClassifierRootNodeOffset(void) |
||||
{ |
||||
return (this->_ui2.y >> HaarStage64_Interpret_ShiftRootNodeOffset); |
||||
} |
||||
|
||||
__host__ __device__ Ncv32u getNumClassifierRootNodes(void) |
||||
{ |
||||
return (this->_ui2.y & HaarStage64_Interpret_MaskRootNodes); |
||||
} |
||||
}; |
||||
|
||||
|
||||
NPPST_CT_ASSERT(sizeof(HaarFeature64) == 8); |
||||
NPPST_CT_ASSERT(sizeof(HaarFeatureDescriptor32) == 4); |
||||
NPPST_CT_ASSERT(sizeof(HaarClassifierNodeDescriptor32) == 4); |
||||
NPPST_CT_ASSERT(sizeof(HaarClassifierNode128) == 16); |
||||
NPPST_CT_ASSERT(sizeof(HaarStage64) == 8); |
||||
|
||||
|
||||
//==============================================================================
|
||||
//
|
||||
// Classifier cascade descriptor
|
||||
//
|
||||
//==============================================================================
|
||||
|
||||
|
||||
struct HaarClassifierCascadeDescriptor |
||||
{ |
||||
Ncv32u NumStages; |
||||
Ncv32u NumClassifierRootNodes; |
||||
Ncv32u NumClassifierTotalNodes; |
||||
Ncv32u NumFeatures; |
||||
NcvSize32u ClassifierSize; |
||||
NcvBool bNeedsTiltedII; |
||||
NcvBool bHasStumpsOnly; |
||||
}; |
||||
|
||||
|
||||
//==============================================================================
|
||||
//
|
||||
// Functional interface
|
||||
//
|
||||
//==============================================================================
|
||||
|
||||
|
||||
enum
|
||||
{ |
||||
NCVPipeObjDet_Default = 0x000, |
||||
NCVPipeObjDet_UseFairImageScaling = 0x001, |
||||
NCVPipeObjDet_FindLargestObject = 0x002, |
||||
NCVPipeObjDet_VisualizeInPlace = 0x004, |
||||
}; |
||||
|
||||
|
||||
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, //default 4
|
||||
Ncv32f scaleStep, //default 1.2f
|
||||
Ncv32u pixelStep, //default 1
|
||||
Ncv32u flags, //default NCVPipeObjDet_Default
|
||||
|
||||
INCVMemAllocator &gpuAllocator, |
||||
INCVMemAllocator &cpuAllocator, |
||||
Ncv32u devPropMajor, |
||||
Ncv32u devPropMinor, |
||||
cudaStream_t cuStream); |
||||
|
||||
|
||||
#define OBJDET_MASK_ELEMENT_INVALID_32U 0xFFFFFFFF |
||||
#define HAAR_STDDEV_BORDER 1 |
||||
|
||||
|
||||
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, |
||||
Ncv32u devPropMajor, |
||||
Ncv32u devPropMinor, |
||||
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 ncvDrawRects_8u_device(Ncv8u *d_dst, |
||||
Ncv32u dstStride, |
||||
Ncv32u dstWidth, |
||||
Ncv32u dstHeight, |
||||
NcvRect32u *d_rects, |
||||
Ncv32u numRects, |
||||
Ncv8u color, |
||||
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_8u_host(Ncv8u *h_dst, |
||||
Ncv32u dstStride, |
||||
Ncv32u dstWidth, |
||||
Ncv32u dstHeight, |
||||
NcvRect32u *h_rects, |
||||
Ncv32u numRects, |
||||
Ncv8u color); |
||||
|
||||
|
||||
NCVStatus ncvDrawRects_32u_host(Ncv32u *h_dst, |
||||
Ncv32u dstStride, |
||||
Ncv32u dstWidth, |
||||
Ncv32u dstHeight, |
||||
NcvRect32u *h_rects, |
||||
Ncv32u numRects, |
||||
Ncv32u color); |
||||
|
||||
|
||||
#define RECT_SIMILARITY_PROPORTION 0.2f |
||||
|
||||
|
||||
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 ncvFilterHypotheses_host(NCVVector<NcvRect32u> &hypotheses, |
||||
Ncv32u &numHypotheses, |
||||
Ncv32u minNeighbors, |
||||
Ncv32f intersectEps, |
||||
NCVVector<Ncv32u> *hypothesesWeights); |
||||
|
||||
|
||||
NCVStatus ncvHaarGetClassifierSize(const std::string &filename, Ncv32u &numStages, |
||||
Ncv32u &numNodes, Ncv32u &numFeatures); |
||||
|
||||
|
||||
NCVStatus ncvHaarLoadFromFile_host(const std::string &filename, |
||||
HaarClassifierCascadeDescriptor &haar, |
||||
NCVVector<HaarStage64> &h_HaarStages, |
||||
NCVVector<HaarClassifierNode128> &h_HaarNodes, |
||||
NCVVector<HaarFeature64> &h_HaarFeatures); |
||||
|
||||
|
||||
NCVStatus ncvHaarStoreNVBIN_host(const std::string &filename, |
||||
HaarClassifierCascadeDescriptor haar, |
||||
NCVVector<HaarStage64> &h_HaarStages, |
||||
NCVVector<HaarClassifierNode128> &h_HaarNodes, |
||||
NCVVector<HaarFeature64> &h_HaarFeatures); |
||||
|
||||
|
||||
|
||||
#endif // _ncvhaarobjectdetection_hpp_
|
||||
@ -0,0 +1,174 @@ |
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// The Loki Library
|
||||
// Copyright (c) 2001 by Andrei Alexandrescu
|
||||
// This code accompanies the book:
|
||||
// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
|
||||
// Patterns Applied". Copyright (c) 2001. Addison-Wesley.
|
||||
// Permission to use, copy, modify, distribute and sell this software for any
|
||||
// purpose is hereby granted without fee, provided that the above copyright
|
||||
// notice appear in all copies and that both that copyright notice and this
|
||||
// permission notice appear in supporting documentation.
|
||||
// The author or Addison-Welsey Longman make no representations about the
|
||||
// suitability of this software for any purpose. It is provided "as is"
|
||||
// without express or implied warranty.
|
||||
// http://loki-lib.sourceforge.net/index.php?n=Main.License
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _ncvruntimetemplates_hpp_ |
||||
#define _ncvruntimetemplates_hpp_ |
||||
|
||||
#include <stdarg.h> |
||||
#include <vector> |
||||
|
||||
|
||||
namespace Loki |
||||
{ |
||||
//==============================================================================
|
||||
// class NullType
|
||||
// Used as a placeholder for "no type here"
|
||||
// Useful as an end marker in typelists
|
||||
//==============================================================================
|
||||
|
||||
class NullType {}; |
||||
|
||||
//==============================================================================
|
||||
// class template Typelist
|
||||
// The building block of typelists of any length
|
||||
// Use it through the LOKI_TYPELIST_NN macros
|
||||
// Defines nested types:
|
||||
// Head (first element, a non-typelist type by convention)
|
||||
// Tail (second element, can be another typelist)
|
||||
//==============================================================================
|
||||
|
||||
template <class T, class U> |
||||
struct Typelist |
||||
{ |
||||
typedef T Head; |
||||
typedef U Tail; |
||||
}; |
||||
|
||||
//==============================================================================
|
||||
// class template Int2Type
|
||||
// Converts each integral constant into a unique type
|
||||
// Invocation: Int2Type<v> where v is a compile-time constant integral
|
||||
// Defines 'value', an enum that evaluates to v
|
||||
//==============================================================================
|
||||
|
||||
template <int v> |
||||
struct Int2Type |
||||
{ |
||||
enum { value = v }; |
||||
}; |
||||
|
||||
namespace TL |
||||
{ |
||||
//==============================================================================
|
||||
// class template TypeAt
|
||||
// Finds the type at a given index in a typelist
|
||||
// Invocation (TList is a typelist and index is a compile-time integral
|
||||
// constant):
|
||||
// TypeAt<TList, index>::Result
|
||||
// returns the type in position 'index' in TList
|
||||
// If you pass an out-of-bounds index, the result is a compile-time error
|
||||
//==============================================================================
|
||||
|
||||
template <class TList, unsigned int index> struct TypeAt; |
||||
|
||||
template <class Head, class Tail> |
||||
struct TypeAt<Typelist<Head, Tail>, 0> |
||||
{ |
||||
typedef Head Result; |
||||
}; |
||||
|
||||
template <class Head, class Tail, unsigned int i> |
||||
struct TypeAt<Typelist<Head, Tail>, i> |
||||
{ |
||||
typedef typename TypeAt<Tail, i - 1>::Result Result; |
||||
}; |
||||
} |
||||
} |
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Runtime boolean template instance dispatcher
|
||||
// Cyril Crassin <cyril.crassin@icare3d.org>
|
||||
// NVIDIA, 2010
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
namespace NCVRuntimeTemplateBool |
||||
{ |
||||
//This struct is used to transform a list of parameters into template arguments
|
||||
//The idea is to build a typelist containing the arguments
|
||||
//and to pass this typelist to a user defined functor
|
||||
template<typename TList, int NumArguments, class Func> |
||||
struct KernelCaller |
||||
{ |
||||
//Convenience function used by the user
|
||||
//Takes a variable argument list, transforms it into a list
|
||||
static void call(Func &functor, int dummy, ...) |
||||
{ |
||||
//Vector used to collect arguments
|
||||
std::vector<int> templateParamList; |
||||
|
||||
//Variable argument list manipulation
|
||||
va_list listPointer; |
||||
va_start(listPointer, dummy); |
||||
//Collect parameters into the list
|
||||
for(int i=0; i<NumArguments; i++) |
||||
{ |
||||
int val = va_arg(listPointer, int); |
||||
templateParamList.push_back(val); |
||||
} |
||||
va_end(listPointer); |
||||
|
||||
//Call the actual typelist building function
|
||||
call(functor, templateParamList); |
||||
} |
||||
|
||||
//Actual function called recursively to build a typelist based
|
||||
//on a list of values
|
||||
static void call( Func &functor, std::vector<int> &templateParamList) |
||||
{ |
||||
//Get current parameter value in the list
|
||||
int val = templateParamList[templateParamList.size() - 1]; |
||||
templateParamList.pop_back(); |
||||
|
||||
//Select the compile time value to add into the typelist
|
||||
//depending on the runtime variable and make recursive call.
|
||||
//Both versions are really instantiated
|
||||
if(val) |
||||
{ |
||||
KernelCaller< |
||||
Loki::Typelist<typename Loki::Int2Type<true>, TList >, |
||||
NumArguments-1, Func > |
||||
::call(functor, templateParamList); |
||||
} |
||||
else |
||||
{ |
||||
KernelCaller<
|
||||
Loki::Typelist<typename Loki::Int2Type<false>, TList >, |
||||
NumArguments-1, Func > |
||||
::call(functor, templateParamList); |
||||
} |
||||
} |
||||
}; |
||||
|
||||
//Specialization for 0 value left in the list
|
||||
//-> actual kernel functor call
|
||||
template<class TList, class Func> |
||||
struct KernelCaller<TList, 0, Func> |
||||
{ |
||||
static void call(Func &functor) |
||||
{ |
||||
//Call to the functor's kernel call method
|
||||
functor.call(TList()); //TList instantiated to get the method template parameter resolved
|
||||
} |
||||
|
||||
static void call(Func &functor, std::vector<int> &templateParams) |
||||
{ |
||||
functor.call(TList()); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
#endif //_ncvruntimetemplates_hpp_
|
||||
@ -0,0 +1,193 @@ |
||||
// WARNING: this sample is under construction! Use it on your own risk.
|
||||
|
||||
#include <opencv2/contrib/contrib.hpp> |
||||
#include <opencv2/objdetect/objdetect.hpp> |
||||
#include <opencv2/highgui/highgui.hpp> |
||||
#include <opencv2/imgproc/imgproc.hpp> |
||||
#include <opencv2/gpu/gpu.hpp> |
||||
|
||||
#include <iostream> |
||||
#include <iomanip> |
||||
#include <stdio.h> |
||||
|
||||
using namespace std; |
||||
using namespace cv; |
||||
using namespace cv::gpu; |
||||
|
||||
void help() |
||||
{ |
||||
cout << "Usage: ./cascadeclassifier <cascade_file> <image_or_video_or_cameraid>\n"
|
||||
"Using OpenCV version " << CV_VERSION << endl << endl; |
||||
} |
||||
|
||||
void DetectAndDraw(Mat& img, CascadeClassifier_GPU& cascade); |
||||
|
||||
String cascadeName = "../../data/haarcascades/haarcascade_frontalface_alt.xml"; |
||||
String nestedCascadeName = "../../data/haarcascades/haarcascade_eye_tree_eyeglasses.xml"; |
||||
|
||||
|
||||
|
||||
template<class T> void convertAndReseize(const T& src, T& gray, T& resized, double scale = 2.0) |
||||
{ |
||||
if (src.channels() == 3) |
||||
cvtColor( src, gray, CV_BGR2GRAY ); |
||||
else |
||||
gray = src; |
||||
|
||||
Size sz(cvRound(gray.cols * scale), cvRound(gray.rows * scale)); |
||||
if (scale != 1) |
||||
resize(gray, resized, sz); |
||||
else |
||||
resized = gray; |
||||
} |
||||
|
||||
|
||||
|
||||
int main( int argc, const char** argv ) |
||||
{
|
||||
if (argc != 3) |
||||
return help(), -1; |
||||
|
||||
if (cv::gpu::getCudaEnabledDeviceCount() == 0) |
||||
return cerr << "No GPU found or the library is compiled without GPU support" << endl, -1; |
||||
|
||||
VideoCapture capture; |
||||
|
||||
string cascadeName = argv[1]; |
||||
string inputName = argv[2]; |
||||
|
||||
cv::gpu::CascadeClassifier_GPU cascade_gpu; |
||||
if( !cascade_gpu.load( cascadeName ) ) |
||||
return cerr << "ERROR: Could not load cascade classifier \"" << cascadeName << "\"" << endl, help(), -1; |
||||
|
||||
cv::CascadeClassifier cascade_cpu; |
||||
if( !cascade_cpu.load( cascadeName ) ) |
||||
return cerr << "ERROR: Could not load cascade classifier \"" << cascadeName << "\"" << endl, help(), -1; |
||||
|
||||
Mat image = imread( inputName); |
||||
if( image.empty() ) |
||||
if (!capture.open(inputName)) |
||||
{ |
||||
int camid = 0; |
||||
sscanf(inputName.c_str(), "%d", &camid); |
||||
if(!capture.open(camid)) |
||||
cout << "Can't open source" << endl; |
||||
} |
||||
|
||||
namedWindow( "result", 1 );
|
||||
Size fontSz = cv::getTextSize("T[]", FONT_HERSHEY_SIMPLEX, 1.0, 2, 0); |
||||
|
||||
Mat frame, frame_cpu, gray_cpu, resized_cpu, faces_downloaded, frameDisp; |
||||
vector<Rect> facesBuf_cpu; |
||||
|
||||
GpuMat frame_gpu, gray_gpu, resized_gpu, facesBuf_gpu;
|
||||
|
||||
/* parameters */ |
||||
bool useGPU = true; |
||||
double scale_factor = 2; |
||||
|
||||
bool visualizeInPlace = false;
|
||||
bool findLargestObject = false;
|
||||
|
||||
printf("\t<space> - toggle GPU/CPU\n"); |
||||
printf("\tL - toggle lagest faces\n"); |
||||
printf("\tV - toggle visualisation in-place (for GPU only)\n"); |
||||
printf("\t1/q - inc/dec scale\n"); |
||||
|
||||
int detections_num; |
||||
for(;;) |
||||
{
|
||||
if( capture.isOpened() ) |
||||
{ |
||||
capture >> frame;
|
||||
if( frame.empty()) |
||||
break; |
||||
} |
||||
|
||||
(image.empty() ? frame : image).copyTo(frame_cpu); |
||||
frame_gpu.upload( image.empty() ? frame : image); |
||||
|
||||
convertAndReseize(frame_gpu, gray_gpu, resized_gpu, scale_factor); |
||||
convertAndReseize(frame_cpu, gray_cpu, resized_cpu, scale_factor); |
||||
|
||||
cv::TickMeter tm; |
||||
tm.start();
|
||||
|
||||
if (useGPU) |
||||
{ |
||||
cascade_gpu.visualizeInPlace = visualizeInPlace;
|
||||
cascade_gpu.findLargestObject = findLargestObject;
|
||||
|
||||
detections_num = cascade_gpu.detectMultiScale( resized_gpu, facesBuf_gpu );
|
||||
facesBuf_gpu.colRange(0, detections_num).download(faces_downloaded); |
||||
|
||||
} |
||||
else /* so use CPU */ |
||||
{
|
||||
Size minSize = cascade_gpu.getClassifierSize(); |
||||
if (findLargestObject) |
||||
{
|
||||
float ratio = (float)std::min(frame.cols / minSize.width, frame.rows / minSize.height); |
||||
ratio = std::max(ratio / 2.5f, 1.f); |
||||
minSize = Size(cvRound(minSize.width * ratio), cvRound(minSize.height * ratio));
|
||||
} |
||||
|
||||
cascade_cpu.detectMultiScale(resized_cpu, facesBuf_cpu, 1.2, 4, (findLargestObject ? CV_HAAR_FIND_BIGGEST_OBJECT : 0) | CV_HAAR_SCALE_IMAGE, minSize);
|
||||
detections_num = (int)facesBuf_cpu.size(); |
||||
} |
||||
|
||||
tm.stop(); |
||||
printf( "detection time = %g ms\n", tm.getTimeMilli() ); |
||||
|
||||
if (useGPU) |
||||
resized_gpu.download(resized_cpu); |
||||
|
||||
if (!visualizeInPlace || !useGPU) |
||||
if (detections_num) |
||||
{ |
||||
Rect* faces = useGPU ? faces_downloaded.ptr<Rect>() : &facesBuf_cpu[0];
|
||||
for(int i = 0; i < detections_num; ++i)
|
||||
cv::rectangle(resized_cpu, faces[i], Scalar(255));
|
||||
} |
||||
|
||||
Point text_pos(5, 25); |
||||
int offs = fontSz.height + 5; |
||||
Scalar color = CV_RGB(255, 0, 0); |
||||
|
||||
|
||||
cv::cvtColor(resized_cpu, frameDisp, CV_GRAY2BGR); |
||||
|
||||
char buf[4096]; |
||||
sprintf(buf, "%s, FPS = %0.3g", useGPU ? "GPU" : "CPU", 1.0/tm.getTimeSec());
|
||||
putText(frameDisp, buf, text_pos, FONT_HERSHEY_SIMPLEX, 1.0, color, 2); |
||||
sprintf(buf, "scale = %0.3g, [%d*scale x %d*scale]", scale_factor, frame.cols, frame.rows);
|
||||
putText(frameDisp, buf, text_pos+=Point(0,offs), FONT_HERSHEY_SIMPLEX, 1.0, color, 2); |
||||
putText(frameDisp, "Hotkeys: space, 1, Q, L, V, Esc", text_pos+=Point(0,offs), FONT_HERSHEY_SIMPLEX, 1.0, color, 2); |
||||
|
||||
if (findLargestObject) |
||||
putText(frameDisp, "FindLargestObject", text_pos+=Point(0,offs), FONT_HERSHEY_SIMPLEX, 1.0, color, 2); |
||||
|
||||
if (visualizeInPlace && useGPU) |
||||
putText(frameDisp, "VisualizeInPlace", text_pos+Point(0,offs), FONT_HERSHEY_SIMPLEX, 1.0, color, 2); |
||||
|
||||
cv::imshow( "result", frameDisp); |
||||
|
||||
int key = waitKey( 5 ); |
||||
if( key == 27) |
||||
break; |
||||
|
||||
switch (key) |
||||
{ |
||||
case (int)' ': useGPU = !useGPU; printf("Using %s\n", useGPU ? "GPU" : "CPU");break; |
||||
case (int)'v': case (int)'V': visualizeInPlace = !visualizeInPlace; printf("VisualizeInPlace = %d\n", visualizeInPlace); break; |
||||
case (int)'l': case (int)'L': findLargestObject = !findLargestObject; printf("FindLargestObject = %d\n", findLargestObject); break; |
||||
case (int)'1': scale_factor*=1.05; printf("Scale factor = %g\n", scale_factor); break; |
||||
case (int)'q': case (int)'Q':scale_factor/=1.05; printf("Scale factor = %g\n", scale_factor); break; |
||||
} |
||||
|
||||
}
|
||||
return 0; |
||||
} |
||||
|
||||
|
||||
|
||||
Loading…
Reference in new issue