//CVG_LicenseBegin==============================================================
//
// Copyright@ GET 2005 (Groupe des Ecoles de Telecom)
// http://www.get-telecom.fr/
//
// This software is a GPU accelerated library for computer-vision. It
// supports an OPENCV-like extensible interface for easily porting OPENCV
// applications.
//
// Contacts:
// GpuCV core team: gpucv@picoforge.int-evry.fr
// GpuCV developers newsgroup: gpucv-developers@picoforge.int-evry.fr
//
// Project's Home Page:
// https://picoforge.int-evry.fr/cgi-bin/twiki/view/Gpucv/Web/WebHome
//
// This software is governed by the CeCILL license under French law and
// abiding by the rules of distribution of free software. You can use,
// modify and/ or redistribute the software under the terms of the CeCILL
// license as circulated by CEA, CNRS and INRIA at the following URL
// "http://www.cecill.info".
//
//================================================================CVG_LicenseEnd
#ifndef _MAINSAMPLETEST_H_
#define _MAINSAMPLETEST_H_
#include "cxcoreg_test.h"
#include "cvg_test.h"
#include <SugoiTools/memory_manager.h>
#include <SugoiTools/exceptions.h>
#include <SugoiTools/tools.h>
#include <SugoiTools/sg_gl.h>
#include <GPUCV/include.h>
#include <GPUCVCore/ToolsTracer.h>
#include <SugoiTools/MultiPlat.h>
#ifdef _GPUCV_SUPPORT_CUDA
#include <GPUCVCuda/include.h>
#endif
#define _BENCH_IPP 1
#define TEST_GPUCV_CV 1
#define TEST_GPUCV_CXCORE 1
//! All input image will be converted to GRAY to be compatible with CUDA operators(it doesn't support 3 channels imagee yet).
#ifdef _GPUCV_SUPPORT_CUDA
#define GPUCVCONSOLE_FORCE_BW_SOURCE 0
#else
#define GPUCVCONSOLE_FORCE_BW_SOURCE 0
#endif
//In GPUCV libraries, we disable GPUCV_FUNCNAME in release mode for faster processing
//but it is used by the console application to perform profiling
#if NDEBUG
#undef GPUCV_FUNCNAME
#define GPUCV_FUNCNAME(FCT_NAME)std::string FctName=FCT_NAME;
#endif
void ExportBenchToFile(char * filename);
//test functions
void runVBO(IplImage * src1);
void runStats(IplImage * src1);
void TestCast(IplImage * src1);
void runGpuToCpu(IplImage * _src1);
void runCpuToGpu(IplImage * _src1);
void runCudaTransfer(IplImage * _src1);
void runIsDiff(IplImage * src1,IplImage * src2);
void runMultiTest(IplImage * src1,IplImage * src2);
//bool resizeImage(IplImage ** Img, int width, int height, int interpolation=CV_INTER_LINEAR);
bool RunDataTransferTest(IplImage * _src1);
bool runCloneTest(IplImage * _src1);
//==============
//tools fct
template<typename TType>
void PrintMatrix(std::string _name, int width, int height, TType * data)
{
int p,q;
TType * tempData = data;
std::cout << "Matrix Name : "<< _name;
for (p=0;p<height;p++)
{
std::cout << std::endl << "___________________________________________" << std::endl;
std::cout << "|" << std::endl;
for (q=0;q<width;q++)
{
printf("%.1f ",*tempData++);
std::cout << "\t|";
}
}
std::cout << std::endl << "___________________________________________" << std::endl;
}
void PrintImageInfo(std::string _imgID);
bool resizeImage(IplImage ** Img, int width, int height, int interpolation=CV_INTER_LINEAR);
void showbenchResult(std::string Cmd);
void PrintMsg();
bool loadImage(IplImage * Img, char * filename="");
void LoadDefaultImages(std::string _AppPath);
void testImageFormat(IplImage * src1, int channels, int depth, float scale);
//===============================
extern IplImage *GlobSrc1,*GlobSrc2, *GlobMask, *MaskBackup;
extern int NB_ITER_BENCH;
extern float time_cv;
extern float time_cvg;
extern bool benchmark;
extern bool AvoidCPUReturn;
extern bool DataPreloading;
extern bool CmdOperator;
extern FCT_TRACER * FctTrcCV;
extern FCT_TRACER * FctTrcGPU;
extern bool ShowImage;
extern bool SelectIpp;
extern int GpuCVSelectionMask;
extern bool use_scalar;
extern bool use_mask;
extern CvScalar * global_scalar;
extern bool ControlOperators;
#define _PROFILE_
#ifdef _PROFILE_
#define _CV_TimerStart(FctName){\
FctTrcCV->StartTrc();\
}
#define _CV_TimerStop(FctName){\
FctTrcCV->StopTrc();\
}
#define _GPU_TimerStart(FctName)\
{ FctTrcGPU->StartTrc();\
}
#define _GPU_TimerStop(FctName){\
FctTrcGPU->StopTrc();\
}
#else
#define _CV_TimerStart(FctName){}
#define _CV_TimerStop(FctName){}
#define _GPU_TimerStart(FctName){}
#define _GPU_TimerStop(FctName){}
#endif
#define _CV_benchLoop(FctName, Fct, Params)if(__CurrentOperMask & OperOpenCV)\
{\
GPUCV_DEBUG("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");\
GPUCV_DEBUG("Start " << ((SelectIpp)?"IPP":"CV") << " test function:" << FctName);\
GPUCV_DEBUG("================================================================");\
GetGpuCVSettings()->IncreaseIndentSize();\
FctTrcCV = AppliTracer()->AddRecord(FctName, (SelectIpp)?_BENCH_IPP_TYPE:_BENCH_OPENCV_TYPE, Params,src1->width, src1->height);\
time_cv = (float)glutGet(GLUT_ELAPSED_TIME);\
if(src1)cvgSynchronize(src1);\
if(src2)cvgSynchronize(src2);\
if (GlobMask)cvgSynchronize(GlobMask);\
for(int i=0;i<NB_ITER_BENCH;i++)\
{\
GPUCV_DEBUG("~~~~~~~~~~~"<< FctName << "->Iteration " << i << "start ~~~~~~~~~~~~");\
_CV_TimerStart(FctName)\
Fct;\
_CV_TimerStop(FctName)\
GPUCV_DEBUG("~~~~~~~~~~~"<< FctName << "->Iteration " << i << "stop ~~~~~~~~~~~~");\
}\
time_cv = ((float)glutGet(GLUT_ELAPSED_TIME)-time_cv)/NB_ITER_BENCH;\
GetGpuCVSettings()->DecreaseIndentSize();\
GPUCV_DEBUG("================================================================");\
GPUCV_DEBUG("Stop " << ((SelectIpp)?"IPP":"CV") << " test function:" << FctName);\
GPUCV_DEBUG("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");\
}
#define _GPU_benchLoop(FctName, Fct, CPUReturnImg, Params)if(__CurrentOperMask&OperGLSL)\
{\
GPUCV_DEBUG("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");\
GPUCV_DEBUG("Start GPUCV test function:" << FctName);\
GPUCV_DEBUG("================================================================");\
GetGpuCVSettings()->IncreaseIndentSize();\
FctTrcGPU = AppliTracer()->AddRecord(FctName, _BENCH_GPUCV_TYPE, Params,src1->width, src1->height);\
if(!IS_OPENCV_FORCED())\
{\
if((void *)CPUReturnImg != NULL)\
{\
cvgPushSetOptions(CPUReturnImg, DataContainer::DEST_IMG, true);\
if (AvoidCPUReturn)cvgUnsetCpuReturn(CPUReturnImg);\
if(DataPreloading)\
cvgSetLocation<DataDsc_GLTex>(CPUReturnImg, false);\
}\
if(src1)\
{\
if (AvoidCPUReturn)cvgUnsetCpuReturn(src1);\
cvgSetOptions(src1, DataContainer::UBIQUITY, true);\
cvgSetLabel(src1, FctName "_Src1");\
if(DataPreloading)\
cvgSetLocation<DataDsc_GLTex>(src1, true);\
}\
if (src2 != NULL)\
{\
if (AvoidCPUReturn)cvgUnsetCpuReturn(src2);\
cvgSetOptions(src2, DataContainer::UBIQUITY, true);\
cvgSetLabel(src2, FctName "_Src2");\
if(DataPreloading)\
cvgSetLocation<DataDsc_GLTex>(src2, true);\
}\
if (GlobMask)\
{\
if (AvoidCPUReturn)cvgUnsetCpuReturn(GlobMask);\
cvgSetOptions(GlobMask, DataContainer::UBIQUITY, true);\
cvgSetLabel(GlobMask, FctName "_Mask");\
if(DataPreloading)\
cvgSetLocation<DataDsc_GLTex>(GlobMask, true);\
}\
}\
glFlush();\
glFinish();\
time_cvg = (float)glutGet(GLUT_ELAPSED_TIME);\
for(int i=0;i<NB_ITER_BENCH;i++) \
{\
GPUCV_DEBUG("~~~~~~~~~~~"<< FctName << "->Iteration " << i << "start ~~~~~~~~~~~~");\
glFlush();\
glFinish();\
_GPU_TimerStart(FctName)\
Fct;\
glFlush();\
glFinish();\
_GPU_TimerStop(FctName)\
GPUCV_DEBUG("~~~~~~~~~~~"<< FctName << "->Iteration " << i << "stop ~~~~~~~~~~~~");\
}\
time_cvg = ((float)glutGet(GLUT_ELAPSED_TIME)-time_cvg)/NB_ITER_BENCH;\
if(benchmark) showbenchResult(FctName);\
if(ControlOperators && destCV!=NULL)\
{\
IplImage * TestImage = cvCloneImage((IplImage*)destCV);\
cvgSynchronize(destGLSL);\
cvXor(destCV, destGLSL, TestImage);\
CvScalar Avg = cvAvg(TestImage);\
float AvgSum = (Avg.val[0] + Avg.val[1] + Avg.val[2] + Avg.val[3])/4./GetWidth(destCV)/GetHeight(destCV);\
if(1||AvgSum!=0){GPUCV_NOTICE(FctName << ": matching error rate (GpuCV-GLSL vs OpenCV) is:" << AvgSum);}\
}\
if(!IS_OPENCV_FORCED())\
{\
if(CPUReturnImg)\
{\
if (AvoidCPUReturn)cvgSetCpuReturn(CPUReturnImg);\
cvgPopOptions(CPUReturnImg);\
}\
}\
GetGpuCVSettings()->DecreaseIndentSize();\
GPUCV_DEBUG("================================================================");\
GPUCV_DEBUG("Stop GPUCV test function:" << FctName);\
GPUCV_DEBUG("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");\
}
#ifdef _GPUCV_SUPPORT_CUDA
#define _GCU_BENCH_PRELOAD_INTO_ARRAY 1
#define _GCU_BENCH_PRELOAD_INTO_BUFFER 1
#define _CUDA_benchLoop(FctName, Fct, CPUReturnImg, Params)if(__CurrentOperMask&OperCuda)\
{\
GPUCV_DEBUG("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");\
GPUCV_DEBUG("Start CUDA test function:" << FctName);\
GPUCV_DEBUG("================================================================");\
GetGpuCVSettings()->IncreaseIndentSize();\
FctTrcGPU = AppliTracer()->AddRecord(FctName, _BENCH_CUDA_TYPE, Params,src1->width, src1->height);\
if(!IS_OPENCV_FORCED())\
{\
if((void *)CPUReturnImg != NULL)\
{\
cvgPushSetOptions(CPUReturnImg, DataContainer::DEST_IMG, true);\
if (AvoidCPUReturn)cvgUnsetCpuReturn(CPUReturnImg);\
if(DataPreloading)\
{\
cvgSetLocation<DataDsc_CUDA_Buffer>(CPUReturnImg,false);\
}\
}\
if(src1)\
{\
if (AvoidCPUReturn)cvgUnsetCpuReturn(src1);\
cvgSetOptions(src1, DataContainer::UBIQUITY, true);\
cvgSetLabel(src1, std::string(FctName) + std::string("_Src1"));\
if(DataPreloading)\
{\
if(_GCU_BENCH_PRELOAD_INTO_ARRAY)cvgSetLocation<DataDsc_CUDA_Array>(src1,true);\
if(_GCU_BENCH_PRELOAD_INTO_BUFFER)cvgSetLocation<DataDsc_CUDA_Buffer>(src1,true);\
}\
}\
if (src2 != NULL)\
{\
if (AvoidCPUReturn)cvgUnsetCpuReturn(src2);\
cvgSetOptions(src2, DataContainer::UBIQUITY, true);\
cvgSetLabel(src2, std::string(FctName) + std::string("_Src2"));\
if(DataPreloading)\
{\
if(_GCU_BENCH_PRELOAD_INTO_ARRAY)cvgSetLocation<DataDsc_CUDA_Array>(src2,true);\
if(_GCU_BENCH_PRELOAD_INTO_BUFFER)cvgSetLocation<DataDsc_CUDA_Buffer>(src2,true);\
}\
}\
if (GlobMask)\
{\
if (AvoidCPUReturn)cvgUnsetCpuReturn(GlobMask);\
cvgSetOptions(GlobMask, DataContainer::UBIQUITY, true);\
cvgSetLabel(GlobMask, std::string(FctName) + std::string("_Mask"));\
if(DataPreloading)\
{\
if(_GCU_BENCH_PRELOAD_INTO_ARRAY)cvgSetLocation<DataDsc_CUDA_Array>(GlobMask,true);\
if(_GCU_BENCH_PRELOAD_INTO_BUFFER)cvgSetLocation<DataDsc_CUDA_Buffer>(GlobMask,true);\
}\
}\
}\
cvgCudaThreadSynchronize();\
time_cvg = (float)glutGet(GLUT_ELAPSED_TIME);\
for(int i=0;i<NB_ITER_BENCH;i++) \
{\
GPUCV_DEBUG("~~~~~~~~~~~"<< FctName << "->Iteration " << i << "start ~~~~~~~~~~~~");\
cvgCudaThreadSynchronize();\
glFlush();\
glFinish();\
_GPU_TimerStart(FctName)\
Fct;\
cvgCudaThreadSynchronize();\
_GPU_TimerStop(FctName)\
GPUCV_DEBUG("~~~~~~~~~~~"<< FctName << "->Iteration " << i << "stop ~~~~~~~~~~~~");\
}\
time_cvg = ((float)glutGet(GLUT_ELAPSED_TIME)-time_cvg)/NB_ITER_BENCH;\
if(benchmark) showbenchResult(FctName);\
if(ControlOperators && destCV!=NULL)\
{\
IplImage * TestImage = cvCloneImage((IplImage*)destCV);\
cvgSynchronize(destCUDA);\
cvXor(destCV, destCUDA, TestImage);\
CvScalar Avg = cvAvg(TestImage);\
float AvgSum = (Avg.val[0] + Avg.val[1] + Avg.val[2] + Avg.val[3])/4./GetWidth(destCV)/GetHeight(destCV);\
if(1||AvgSum!=0){GPUCV_NOTICE(FctName << ": matching error rate (GpuCV-CUDA vs OpenCV) is:" << AvgSum);}\
}\
if(!IS_OPENCV_FORCED())\
{\
if(CPUReturnImg)\
{\
if (AvoidCPUReturn)cvgSetCpuReturn(CPUReturnImg);\
cvgPopOptions(CPUReturnImg);\
}\
}\
GetGpuCVSettings()->DecreaseIndentSize();\
GPUCV_DEBUG("================================================================");\
GPUCV_DEBUG("Stop CUDA test function:" << FctName);\
GPUCV_DEBUG("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");\
}
#else
#define _CUDA_benchLoop(FctName, Fct, CPUReturnImg, Params)
#endif
enum OperType{
OperOpenCV = 1,
OperGLSL = 2,
#ifdef _GPUCV_SUPPORT_CUDA
OperCuda = 4,
#else
OperCuda = 0,
#endif
OperIPP = 8,
OperALL = OperOpenCV|OperGLSL|OperCuda|OperIPP
};
#define __CreateImages__( SIZE, DEPTH, CHANNELS, MASK)\
unsigned char __CurrentOperMask = (MASK) & GpuCVSelectionMask;\
IplImage * destCV = NULL;\
IplImage * destGLSL = NULL;\
IplImage * destCUDA = NULL;\
if(__CurrentOperMask & OperOpenCV)\
{\
destCV = cvgCreateImage(SIZE,DEPTH,CHANNELS);\
cvgSetLabel(destCV,GPUCV_GET_FCT_NAME()+"-destCV");\
}\
if(__CurrentOperMask & OperGLSL)\
{\
destGLSL = cvgCreateImage(SIZE,DEPTH,CHANNELS);\
cvgSetLabel(destGLSL,GPUCV_GET_FCT_NAME()+"-destGLSL");\
}\
if(__CurrentOperMask & OperCuda)\
{\
destCUDA = cvgCreateImage(SIZE,DEPTH,CHANNELS);\
cvgSetLabel(destCUDA,GPUCV_GET_FCT_NAME()+"-destCUDA");\
}
#define __CreateMatrixes__( SIZE_X, SIZE_Y,DEPTH, MASK)\
unsigned char __CurrentOperMask = (MASK) & GpuCVSelectionMask;\
CvMat * destCV = NULL;\
CvMat * destGLSL = NULL;\
CvMat * destCUDA = NULL;\
if(__CurrentOperMask & OperOpenCV)\
{\
destCV = cvgCreateMat(SIZE_X, SIZE_Y,DEPTH);\
cvgSetLabel(destCV,"destCV-Mat");\
destCV->hdr_refcount=0;\
}\
if(__CurrentOperMask & OperGLSL)\
{\
destGLSL = cvgCreateMat(SIZE_X, SIZE_Y,DEPTH);\
cvgSetLabel(destGLSL,"destGLSL-Mat");\
destGLSL->hdr_refcount=0;\
}\
if(__CurrentOperMask & OperCuda)\
{\
destCUDA = cvgCreateMat(SIZE_X, SIZE_Y,DEPTH);\
cvgSetLabel(destCUDA,"destCUDA-Mat");\
destCUDA->hdr_refcount=0;\
}
#define __ReleaseImages__()\
if(__CurrentOperMask & OperOpenCV)\
cvgReleaseImage(&destCV);\
if(__CurrentOperMask & OperGLSL)\
cvgReleaseImage(&destGLSL);\
if(__CurrentOperMask & OperCuda)\
cvgReleaseImage(&destCUDA);
//ShowGpuCVStats();
#define __ReleaseMatrixes__()\
if(__CurrentOperMask & OperOpenCV)\
cvgReleaseMat(&destCV);\
if(__CurrentOperMask & OperGLSL)\
cvgReleaseMat(&destGLSL);\
if(__CurrentOperMask & OperCuda)\
cvgReleaseMat(&destCUDA);
#ifdef _GPUCV_SUPPORT_CUDA
#define __SetInputImage_CUDA__(iImage, LABEL)\
if(__CurrentOperMask & OperCuda)\
{\
cvgSetLocation<DataDsc_CUDA_Array>(iImage, true);\
cvgSetLocation<DataDsc_CUDA_Buffer>(iImage, true);\
}
#else
#define __SetInputImage_CUDA__(iImage, LABEL)
#endif
#define __SetInputImage__(iImage, LABEL)\
cvgSetOptions(iImage, DataContainer::UBIQUITY, true);\
cvgSetOptions(iImage, DataContainer::CPU_RETURN, false);\
cvgSetLabel(iImage, LABEL);\
if(__CurrentOperMask & OperOpenCV)\
cvgSetLocation<DataDsc_IplImage>(iImage, true);\
if(__CurrentOperMask & OperGLSL)\
cvgSetLocation<DataDsc_GLTex>(iImage, true);\
__SetInputImage_CUDA__(iImage, true);
#ifdef _GPUCV_SUPPORT_CUDA
#define __SetInputMatrix_CUDA__(iMatrix, LABEL)\
if(__CurrentOperMask & OperCuda)\
{\
cvgSetLocation<DataDsc_CUDA_Buffer>(iMatrix, true);\
cvgSetLocation<DataDsc_CUDA_Array>(iMatrix, true);\
}
#else
#define __SetInputMatrix_CUDA__(iImage, LABEL)
#endif
#define __SetInputMatrix__(iMatrix, LABEL)\
cvgSetOptions(iMatrix, DataContainer::UBIQUITY, true);\
cvgSetOptions(iMatrix, DataContainer::CPU_RETURN, false);\
cvgSetLabel(iMatrix, LABEL);\
if(__CurrentOperMask & OperOpenCV)\
cvgSetLocation<DataDsc_CvMat>(iMatrix, true);\
if(__CurrentOperMask & OperGLSL)\
cvgSetLocation<DataDsc_GLTex>(iMatrix, true);\
__SetInputMatrix_CUDA__(iMatrix, true);
#define __CreateWindows__()\
if (ShowImage==true){\
if(__CurrentOperMask & OperOpenCV)\
cvNamedWindow("cv*()",1);\
if(__CurrentOperMask & OperGLSL)\
cvNamedWindow("cvg*()",1);\
if(__CurrentOperMask & OperCuda)\
cvNamedWindow("cvgCuda*()",1);\
}
#define __ShowImages__()\
if (ShowImage==true)\
{\
if(__CurrentOperMask & OperOpenCV)\
cvgShowImage("cv*()",destCV);\
if(__CurrentOperMask & OperGLSL)\
cvgShowImage("cvg*()",destGLSL);\
if(__CurrentOperMask & OperCuda)\
cvgShowImage("cvgCuda*()",destCUDA);\
cvWaitKey(0);\
if(__CurrentOperMask & OperOpenCV)\
cvDestroyWindow("cv*()");\
if(__CurrentOperMask & OperGLSL)\
cvDestroyWindow("cvg*()");\
if(__CurrentOperMask & OperCuda)\
cvDestroyWindow("cvgCuda*()");\
}
#ifndef _WIN32
typedef long int LONGLONG;
#endif
#endif
|
