gpunvidia module for NCV & NPP API
This commit is contained in:
Vladislav Vinogradov
@@ -1,130 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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 "test_precomp.hpp"
|
||||
|
||||
#ifdef HAVE_CUDA
|
||||
|
||||
using namespace std;
|
||||
using namespace cv;
|
||||
using namespace cv::gpu;
|
||||
using namespace cvtest;
|
||||
using namespace testing;
|
||||
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
try
|
||||
{
|
||||
const std::string keys =
|
||||
"{ h help ? | | Print help}"
|
||||
"{ i info | | Print information about system and exit }"
|
||||
"{ device | -1 | Device on which tests will be executed (-1 means all devices) }"
|
||||
"{ nvtest_output_level | none | NVidia test verbosity level (none, compact, full) }"
|
||||
;
|
||||
|
||||
CommandLineParser cmd(argc, (const char**)argv, keys);
|
||||
|
||||
if (cmd.has("help"))
|
||||
{
|
||||
cmd.printMessage();
|
||||
return 0;
|
||||
}
|
||||
|
||||
printCudaInfo();
|
||||
|
||||
if (cmd.has("info"))
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int device = cmd.get<int>("device");
|
||||
if (device < 0)
|
||||
{
|
||||
DeviceManager::instance().loadAll();
|
||||
|
||||
cout << "Run tests on all supported devices \n" << endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
DeviceManager::instance().load(device);
|
||||
|
||||
DeviceInfo info(device);
|
||||
cout << "Run tests on device " << device << " [" << info.name() << "] \n" << endl;
|
||||
}
|
||||
|
||||
string outputLevel = cmd.get<string>("nvtest_output_level");
|
||||
|
||||
if (outputLevel == "none")
|
||||
nvidiaTestOutputLevel = OutputLevelNone;
|
||||
else if (outputLevel == "compact")
|
||||
nvidiaTestOutputLevel = OutputLevelCompact;
|
||||
else if (outputLevel == "full")
|
||||
nvidiaTestOutputLevel = OutputLevelFull;
|
||||
|
||||
TS::ptr()->init("gpu");
|
||||
InitGoogleTest(&argc, argv);
|
||||
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
||||
catch (const exception& e)
|
||||
{
|
||||
cerr << e.what() << endl;
|
||||
return -1;
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
cerr << "Unknown error" << endl;
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#else // HAVE_CUDA
|
||||
|
||||
int main()
|
||||
{
|
||||
printf("OpenCV was built without CUDA support\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif // HAVE_CUDA
|
||||
@@ -1,67 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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 __main_test_nvidia_h__
|
||||
#define __main_test_nvidia_h__
|
||||
|
||||
enum OutputLevel
|
||||
{
|
||||
OutputLevelNone,
|
||||
OutputLevelCompact,
|
||||
OutputLevelFull
|
||||
};
|
||||
|
||||
extern OutputLevel nvidiaTestOutputLevel;
|
||||
|
||||
bool nvidia_NPPST_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel);
|
||||
bool nvidia_NPPST_Squared_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel);
|
||||
bool nvidia_NPPST_RectStdDev(const std::string& test_data_path, OutputLevel outputLevel);
|
||||
bool nvidia_NPPST_Resize(const std::string& test_data_path, OutputLevel outputLevel);
|
||||
bool nvidia_NPPST_Vector_Operations(const std::string& test_data_path, OutputLevel outputLevel);
|
||||
bool nvidia_NPPST_Transpose(const std::string& test_data_path, OutputLevel outputLevel);
|
||||
bool nvidia_NCV_Vector_Operations(const std::string& test_data_path, OutputLevel outputLevel);
|
||||
bool nvidia_NCV_Haar_Cascade_Loader(const std::string& test_data_path, OutputLevel outputLevel);
|
||||
bool nvidia_NCV_Haar_Cascade_Application(const std::string& test_data_path, OutputLevel outputLevel);
|
||||
bool nvidia_NCV_Hypotheses_Filtration(const std::string& test_data_path, OutputLevel outputLevel);
|
||||
bool nvidia_NCV_Visualization(const std::string& test_data_path, OutputLevel outputLevel);
|
||||
|
||||
#endif
|
||||
@@ -1,172 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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 _ncvautotestlister_hpp_
|
||||
#define _ncvautotestlister_hpp_
|
||||
|
||||
#include <vector>
|
||||
|
||||
#include "NCVTest.hpp"
|
||||
#include <main_test_nvidia.h>
|
||||
//enum OutputLevel
|
||||
//{
|
||||
// OutputLevelNone,
|
||||
// OutputLevelCompact,
|
||||
// OutputLevelFull
|
||||
//};
|
||||
|
||||
class NCVAutoTestLister
|
||||
{
|
||||
public:
|
||||
|
||||
NCVAutoTestLister(std::string testSuiteName_, OutputLevel outputLevel_ = OutputLevelCompact, NcvBool bStopOnFirstFail_=false)
|
||||
:
|
||||
testSuiteName(testSuiteName_),
|
||||
outputLevel(outputLevel_),
|
||||
bStopOnFirstFail(bStopOnFirstFail_)
|
||||
{
|
||||
}
|
||||
|
||||
void add(INCVTest *test)
|
||||
{
|
||||
this->tests.push_back(test);
|
||||
}
|
||||
|
||||
bool invoke()
|
||||
{
|
||||
Ncv32u nPassed = 0;
|
||||
Ncv32u nFailed = 0;
|
||||
Ncv32u nFailedMem = 0;
|
||||
|
||||
if (outputLevel == OutputLevelCompact)
|
||||
{
|
||||
printf("Test suite '%s' with %d tests\n",
|
||||
testSuiteName.c_str(),
|
||||
(int)(this->tests.size()));
|
||||
}
|
||||
|
||||
for (Ncv32u i=0; i<this->tests.size(); i++)
|
||||
{
|
||||
INCVTest &curTest = *tests[i];
|
||||
|
||||
NCVTestReport curReport;
|
||||
bool res = curTest.executeTest(curReport);
|
||||
|
||||
if (outputLevel == OutputLevelFull)
|
||||
{
|
||||
printf("Test %3i %16s; Consumed mem GPU = %8d, CPU = %8d; %s\n",
|
||||
i,
|
||||
curTest.getName().c_str(),
|
||||
curReport.statsNums["MemGPU"],
|
||||
curReport.statsNums["MemCPU"],
|
||||
curReport.statsText["rcode"].c_str());
|
||||
}
|
||||
|
||||
if (res)
|
||||
{
|
||||
nPassed++;
|
||||
if (outputLevel == OutputLevelCompact)
|
||||
{
|
||||
printf(".");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!curReport.statsText["rcode"].compare("FAILED"))
|
||||
{
|
||||
nFailed++;
|
||||
if (outputLevel == OutputLevelCompact)
|
||||
{
|
||||
printf("x");
|
||||
}
|
||||
if (bStopOnFirstFail)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
nFailedMem++;
|
||||
if (outputLevel == OutputLevelCompact)
|
||||
{
|
||||
printf("m");
|
||||
}
|
||||
}
|
||||
}
|
||||
fflush(stdout);
|
||||
}
|
||||
if (outputLevel == OutputLevelCompact)
|
||||
{
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
if (outputLevel != OutputLevelNone)
|
||||
{
|
||||
printf("Test suite '%s' complete: %d total, %d passed, %d memory errors, %d failed\n\n",
|
||||
testSuiteName.c_str(),
|
||||
(int)(this->tests.size()),
|
||||
nPassed,
|
||||
nFailedMem,
|
||||
nFailed);
|
||||
}
|
||||
|
||||
bool passed = nFailed == 0 && nFailedMem == 0;
|
||||
return passed;
|
||||
}
|
||||
|
||||
~NCVAutoTestLister()
|
||||
{
|
||||
for (Ncv32u i=0; i<this->tests.size(); i++)
|
||||
{
|
||||
delete tests[i];
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
std::string testSuiteName;
|
||||
OutputLevel outputLevel;
|
||||
NcvBool bStopOnFirstFail;
|
||||
std::vector<INCVTest *> tests;
|
||||
};
|
||||
|
||||
#endif // _ncvautotestlister_hpp_
|
||||
@@ -1,246 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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 _ncvtest_hpp_
|
||||
#define _ncvtest_hpp_
|
||||
|
||||
#if defined _MSC_VER
|
||||
# pragma warning( disable : 4201 4408 4127 4100)
|
||||
#endif
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <map>
|
||||
#include <memory>
|
||||
#include <algorithm>
|
||||
#include <fstream>
|
||||
|
||||
#include <cuda_runtime.h>
|
||||
#include "NPP_staging.hpp"
|
||||
|
||||
|
||||
struct NCVTestReport
|
||||
{
|
||||
std::map<std::string, Ncv32u> statsNums;
|
||||
std::map<std::string, std::string> statsText;
|
||||
};
|
||||
|
||||
|
||||
class INCVTest
|
||||
{
|
||||
public:
|
||||
virtual bool executeTest(NCVTestReport &report) = 0;
|
||||
virtual std::string getName() const = 0;
|
||||
virtual ~INCVTest(){}
|
||||
};
|
||||
|
||||
|
||||
class NCVTestProvider : public INCVTest
|
||||
{
|
||||
public:
|
||||
|
||||
NCVTestProvider(std::string testName_)
|
||||
:
|
||||
testName(testName_)
|
||||
{
|
||||
int devId;
|
||||
ncvAssertPrintReturn(cudaSuccess == cudaGetDevice(&devId), "Error returned from cudaGetDevice", );
|
||||
ncvAssertPrintReturn(cudaSuccess == cudaGetDeviceProperties(&this->devProp, devId), "Error returned from cudaGetDeviceProperties", );
|
||||
}
|
||||
|
||||
virtual bool init() = 0;
|
||||
virtual bool process() = 0;
|
||||
virtual bool deinit() = 0;
|
||||
virtual bool toString(std::ofstream &strOut) = 0;
|
||||
|
||||
virtual std::string getName() const
|
||||
{
|
||||
return this->testName;
|
||||
}
|
||||
|
||||
virtual ~NCVTestProvider()
|
||||
{
|
||||
deinitMemory();
|
||||
}
|
||||
|
||||
virtual bool executeTest(NCVTestReport &report)
|
||||
{
|
||||
bool res;
|
||||
report.statsText["rcode"] = "FAILED";
|
||||
|
||||
res = initMemory(report);
|
||||
if (!res)
|
||||
{
|
||||
dumpToFile(report);
|
||||
deinitMemory();
|
||||
return false;
|
||||
}
|
||||
|
||||
res = init();
|
||||
if (!res)
|
||||
{
|
||||
dumpToFile(report);
|
||||
deinit();
|
||||
deinitMemory();
|
||||
return false;
|
||||
}
|
||||
|
||||
res = process();
|
||||
if (!res)
|
||||
{
|
||||
dumpToFile(report);
|
||||
deinit();
|
||||
deinitMemory();
|
||||
return false;
|
||||
}
|
||||
|
||||
res = deinit();
|
||||
if (!res)
|
||||
{
|
||||
dumpToFile(report);
|
||||
deinitMemory();
|
||||
return false;
|
||||
}
|
||||
|
||||
deinitMemory();
|
||||
|
||||
report.statsText["rcode"] = "Passed";
|
||||
return true;
|
||||
}
|
||||
|
||||
protected:
|
||||
|
||||
cudaDeviceProp devProp;
|
||||
std::auto_ptr<INCVMemAllocator> allocatorGPU;
|
||||
std::auto_ptr<INCVMemAllocator> allocatorCPU;
|
||||
|
||||
private:
|
||||
|
||||
std::string testName;
|
||||
|
||||
bool initMemory(NCVTestReport &report)
|
||||
{
|
||||
this->allocatorGPU.reset(new NCVMemStackAllocator(static_cast<Ncv32u>(devProp.textureAlignment)));
|
||||
this->allocatorCPU.reset(new NCVMemStackAllocator(static_cast<Ncv32u>(devProp.textureAlignment)));
|
||||
|
||||
if (!this->allocatorGPU.get()->isInitialized() ||
|
||||
!this->allocatorCPU.get()->isInitialized())
|
||||
{
|
||||
report.statsText["rcode"] = "Memory FAILED";
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!this->process())
|
||||
{
|
||||
report.statsText["rcode"] = "Memory FAILED";
|
||||
return false;
|
||||
}
|
||||
|
||||
Ncv32u maxGPUsize = (Ncv32u)this->allocatorGPU.get()->maxSize();
|
||||
Ncv32u maxCPUsize = (Ncv32u)this->allocatorCPU.get()->maxSize();
|
||||
|
||||
report.statsNums["MemGPU"] = maxGPUsize;
|
||||
report.statsNums["MemCPU"] = maxCPUsize;
|
||||
|
||||
this->allocatorGPU.reset(new NCVMemStackAllocator(NCVMemoryTypeDevice, maxGPUsize, static_cast<Ncv32u>(devProp.textureAlignment)));
|
||||
|
||||
this->allocatorCPU.reset(new NCVMemStackAllocator(NCVMemoryTypeHostPinned, maxCPUsize, static_cast<Ncv32u>(devProp.textureAlignment)));
|
||||
|
||||
if (!this->allocatorGPU.get()->isInitialized() ||
|
||||
!this->allocatorCPU.get()->isInitialized())
|
||||
{
|
||||
report.statsText["rcode"] = "Memory FAILED";
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void deinitMemory()
|
||||
{
|
||||
this->allocatorGPU.reset();
|
||||
this->allocatorCPU.reset();
|
||||
}
|
||||
|
||||
void dumpToFile(NCVTestReport &report)
|
||||
{
|
||||
bool bReasonMem = (0 == report.statsText["rcode"].compare("Memory FAILED"));
|
||||
std::string fname = "TestDump_";
|
||||
fname += (bReasonMem ? "m_" : "") + this->testName + ".log";
|
||||
std::ofstream stream(fname.c_str(), std::ios::trunc | std::ios::out);
|
||||
if (!stream.is_open()) return;
|
||||
|
||||
stream << "NCV Test Failure Log: " << this->testName << std::endl;
|
||||
stream << "====================================================" << std::endl << std::endl;
|
||||
stream << "Test initialization report: " << std::endl;
|
||||
for (std::map<std::string,std::string>::iterator it=report.statsText.begin();
|
||||
it != report.statsText.end(); it++)
|
||||
{
|
||||
stream << it->first << "=" << it->second << std::endl;
|
||||
}
|
||||
for (std::map<std::string,Ncv32u>::iterator it=report.statsNums.begin();
|
||||
it != report.statsNums.end(); it++)
|
||||
{
|
||||
stream << it->first << "=" << it->second << std::endl;
|
||||
}
|
||||
stream << std::endl;
|
||||
|
||||
stream << "Test initialization parameters: " << std::endl;
|
||||
bool bSerializeRes = false;
|
||||
try
|
||||
{
|
||||
bSerializeRes = this->toString(stream);
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
}
|
||||
|
||||
if (!bSerializeRes)
|
||||
{
|
||||
stream << "Couldn't retrieve object dump" << std::endl;
|
||||
}
|
||||
|
||||
stream.flush();
|
||||
}
|
||||
};
|
||||
|
||||
#endif // _ncvtest_hpp_
|
||||
@@ -1,193 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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 _ncvtestsourceprovider_hpp_
|
||||
#define _ncvtestsourceprovider_hpp_
|
||||
|
||||
#include <memory>
|
||||
|
||||
#include "NCV.hpp"
|
||||
#include <opencv2/highgui.hpp>
|
||||
|
||||
|
||||
template <class T>
|
||||
class NCVTestSourceProvider
|
||||
{
|
||||
public:
|
||||
|
||||
NCVTestSourceProvider(Ncv32u seed, T rangeLow, T rangeHigh, Ncv32u maxWidth, Ncv32u maxHeight)
|
||||
:
|
||||
bInit(false)
|
||||
{
|
||||
ncvAssertPrintReturn(rangeLow < rangeHigh, "NCVTestSourceProvider ctor:: Invalid range", );
|
||||
|
||||
int devId;
|
||||
cudaDeviceProp devProp;
|
||||
ncvAssertPrintReturn(cudaSuccess == cudaGetDevice(&devId), "Error returned from cudaGetDevice", );
|
||||
ncvAssertPrintReturn(cudaSuccess == cudaGetDeviceProperties(&devProp, devId), "Error returned from cudaGetDeviceProperties", );
|
||||
|
||||
//Ncv32u maxWpitch = alignUp(maxWidth * sizeof(T), devProp.textureAlignment);
|
||||
|
||||
allocatorCPU.reset(new NCVMemNativeAllocator(NCVMemoryTypeHostPinned, static_cast<Ncv32u>(devProp.textureAlignment)));
|
||||
data.reset(new NCVMatrixAlloc<T>(*this->allocatorCPU.get(), maxWidth, maxHeight));
|
||||
ncvAssertPrintReturn(data.get()->isMemAllocated(), "NCVTestSourceProvider ctor:: Matrix not allocated", );
|
||||
|
||||
this->dataWidth = maxWidth;
|
||||
this->dataHeight = maxHeight;
|
||||
|
||||
srand(seed);
|
||||
|
||||
for (Ncv32u i=0; i<maxHeight; i++)
|
||||
{
|
||||
for (Ncv32u j=0; j<data.get()->stride(); j++)
|
||||
{
|
||||
data.get()->ptr()[i * data.get()->stride() + j] =
|
||||
(T)(((1.0 * rand()) / RAND_MAX) * (rangeHigh - rangeLow) + rangeLow);
|
||||
}
|
||||
}
|
||||
|
||||
this->bInit = true;
|
||||
}
|
||||
|
||||
NCVTestSourceProvider(std::string pgmFilename)
|
||||
:
|
||||
bInit(false)
|
||||
{
|
||||
ncvAssertPrintReturn(sizeof(T) == 1, "NCVTestSourceProvider ctor:: PGM constructor complies only with 8bit types", );
|
||||
|
||||
cv::Mat image = cv::imread(pgmFilename);
|
||||
ncvAssertPrintReturn(!image.empty(), "NCVTestSourceProvider ctor:: PGM file error", );
|
||||
|
||||
int devId;
|
||||
cudaDeviceProp devProp;
|
||||
ncvAssertPrintReturn(cudaSuccess == cudaGetDevice(&devId), "Error returned from cudaGetDevice", );
|
||||
ncvAssertPrintReturn(cudaSuccess == cudaGetDeviceProperties(&devProp, devId), "Error returned from cudaGetDeviceProperties", );
|
||||
|
||||
allocatorCPU.reset(new NCVMemNativeAllocator(NCVMemoryTypeHostPinned, static_cast<Ncv32u>(devProp.textureAlignment)));
|
||||
data.reset(new NCVMatrixAlloc<T>(*this->allocatorCPU.get(), image.cols, image.rows));
|
||||
ncvAssertPrintReturn(data.get()->isMemAllocated(), "NCVTestSourceProvider ctor:: Matrix not allocated", );
|
||||
|
||||
this->dataWidth = image.cols;
|
||||
this->dataHeight = image.rows;
|
||||
|
||||
cv::Mat hdr(image.size(), CV_8UC1, data.get()->ptr(), data.get()->pitch());
|
||||
image.copyTo(hdr);
|
||||
|
||||
this->bInit = true;
|
||||
}
|
||||
|
||||
NcvBool fill(NCVMatrix<T> &dst)
|
||||
{
|
||||
ncvAssertReturn(this->isInit() &&
|
||||
dst.memType() == allocatorCPU.get()->memType(), false);
|
||||
|
||||
if (dst.width() == 0 || dst.height() == 0)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
for (Ncv32u i=0; i<dst.height(); i++)
|
||||
{
|
||||
Ncv32u srcLine = i % this->dataHeight;
|
||||
|
||||
Ncv32u srcFullChunks = dst.width() / this->dataWidth;
|
||||
for (Ncv32u j=0; j<srcFullChunks; j++)
|
||||
{
|
||||
memcpy(dst.ptr() + i * dst.stride() + j * this->dataWidth,
|
||||
this->data.get()->ptr() + this->data.get()->stride() * srcLine,
|
||||
this->dataWidth * sizeof(T));
|
||||
}
|
||||
|
||||
Ncv32u srcLastChunk = dst.width() % this->dataWidth;
|
||||
memcpy(dst.ptr() + i * dst.stride() + srcFullChunks * this->dataWidth,
|
||||
this->data.get()->ptr() + this->data.get()->stride() * srcLine,
|
||||
srcLastChunk * sizeof(T));
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
NcvBool fill(NCVVector<T> &dst)
|
||||
{
|
||||
ncvAssertReturn(this->isInit() &&
|
||||
dst.memType() == allocatorCPU.get()->memType(), false);
|
||||
|
||||
if (dst.length() == 0)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
Ncv32u srcLen = this->dataWidth * this->dataHeight;
|
||||
|
||||
Ncv32u srcFullChunks = (Ncv32u)dst.length() / srcLen;
|
||||
for (Ncv32u j=0; j<srcFullChunks; j++)
|
||||
{
|
||||
memcpy(dst.ptr() + j * srcLen, this->data.get()->ptr(), srcLen * sizeof(T));
|
||||
}
|
||||
|
||||
Ncv32u srcLastChunk = dst.length() % srcLen;
|
||||
memcpy(dst.ptr() + srcFullChunks * srcLen, this->data.get()->ptr(), srcLastChunk * sizeof(T));
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
~NCVTestSourceProvider()
|
||||
{
|
||||
data.reset();
|
||||
allocatorCPU.reset();
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
NcvBool isInit(void)
|
||||
{
|
||||
return this->bInit;
|
||||
}
|
||||
|
||||
NcvBool bInit;
|
||||
std::auto_ptr< INCVMemAllocator > allocatorCPU;
|
||||
std::auto_ptr< NCVMatrixAlloc<T> > data;
|
||||
Ncv32u dataWidth;
|
||||
Ncv32u dataHeight;
|
||||
};
|
||||
|
||||
#endif // _ncvtestsourceprovider_hpp_
|
||||
@@ -1,164 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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*/
|
||||
|
||||
#if !defined CUDA_DISABLER
|
||||
|
||||
#include "TestCompact.h"
|
||||
|
||||
|
||||
TestCompact::TestCompact(std::string testName_, NCVTestSourceProvider<Ncv32u> &src_,
|
||||
Ncv32u length_, Ncv32u badElem_, Ncv32u badElemPercentage_)
|
||||
:
|
||||
NCVTestProvider(testName_),
|
||||
src(src_),
|
||||
length(length_),
|
||||
badElem(badElem_),
|
||||
badElemPercentage(badElemPercentage_ > 100 ? 100 : badElemPercentage_)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
bool TestCompact::toString(std::ofstream &strOut)
|
||||
{
|
||||
strOut << "length=" << length << std::endl;
|
||||
strOut << "badElem=" << badElem << std::endl;
|
||||
strOut << "badElemPercentage=" << badElemPercentage << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool TestCompact::init()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool TestCompact::process()
|
||||
{
|
||||
NCVStatus ncvStat;
|
||||
bool rcode = false;
|
||||
|
||||
NCVVectorAlloc<Ncv32u> h_vecSrc(*this->allocatorCPU.get(), this->length);
|
||||
ncvAssertReturn(h_vecSrc.isMemAllocated(), false);
|
||||
NCVVectorAlloc<Ncv32u> d_vecSrc(*this->allocatorGPU.get(), this->length);
|
||||
ncvAssertReturn(d_vecSrc.isMemAllocated(), false);
|
||||
|
||||
NCVVectorAlloc<Ncv32u> h_vecDst(*this->allocatorCPU.get(), this->length);
|
||||
ncvAssertReturn(h_vecDst.isMemAllocated(), false);
|
||||
NCVVectorAlloc<Ncv32u> d_vecDst(*this->allocatorGPU.get(), this->length);
|
||||
ncvAssertReturn(d_vecDst.isMemAllocated(), false);
|
||||
NCVVectorAlloc<Ncv32u> h_vecDst_d(*this->allocatorCPU.get(), this->length);
|
||||
ncvAssertReturn(h_vecDst_d.isMemAllocated(), false);
|
||||
|
||||
NCV_SET_SKIP_COND(this->allocatorGPU.get()->isCounting());
|
||||
NCV_SKIP_COND_BEGIN
|
||||
ncvAssertReturn(this->src.fill(h_vecSrc), false);
|
||||
for (Ncv32u i=0; i<this->length; i++)
|
||||
{
|
||||
Ncv32u tmp = (h_vecSrc.ptr()[i]) & 0xFF;
|
||||
tmp = tmp * 99 / 255;
|
||||
if (tmp < this->badElemPercentage)
|
||||
{
|
||||
h_vecSrc.ptr()[i] = this->badElem;
|
||||
}
|
||||
}
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
NCVVectorAlloc<Ncv32u> h_dstLen(*this->allocatorCPU.get(), 1);
|
||||
ncvAssertReturn(h_dstLen.isMemAllocated(), false);
|
||||
Ncv32u bufSize;
|
||||
ncvStat = nppsStCompactGetSize_32u(this->length, &bufSize, this->devProp);
|
||||
ncvAssertReturn(NPPST_SUCCESS == ncvStat, false);
|
||||
NCVVectorAlloc<Ncv8u> d_tmpBuf(*this->allocatorGPU.get(), bufSize);
|
||||
ncvAssertReturn(d_tmpBuf.isMemAllocated(), false);
|
||||
|
||||
Ncv32u h_outElemNum_h = 0;
|
||||
|
||||
NCV_SKIP_COND_BEGIN
|
||||
ncvStat = h_vecSrc.copySolid(d_vecSrc, 0);
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
ncvStat = nppsStCompact_32u(d_vecSrc.ptr(), this->length,
|
||||
d_vecDst.ptr(), h_dstLen.ptr(), this->badElem,
|
||||
d_tmpBuf.ptr(), bufSize, this->devProp);
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
ncvStat = d_vecDst.copySolid(h_vecDst_d, 0);
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
|
||||
ncvStat = nppsStCompact_32u_host(h_vecSrc.ptr(), this->length, h_vecDst.ptr(), &h_outElemNum_h, this->badElem);
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
//bit-to-bit check
|
||||
bool bLoopVirgin = true;
|
||||
|
||||
NCV_SKIP_COND_BEGIN
|
||||
if (h_dstLen.ptr()[0] != h_outElemNum_h)
|
||||
{
|
||||
bLoopVirgin = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (Ncv32u i=0; bLoopVirgin && i < h_outElemNum_h; i++)
|
||||
{
|
||||
if (h_vecDst.ptr()[i] != h_vecDst_d.ptr()[i])
|
||||
{
|
||||
bLoopVirgin = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
if (bLoopVirgin)
|
||||
{
|
||||
rcode = true;
|
||||
}
|
||||
|
||||
return rcode;
|
||||
}
|
||||
|
||||
|
||||
bool TestCompact::deinit()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
#endif /* CUDA_DISABLER */
|
||||
@@ -1,73 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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 _testhypothesescompact_h_
|
||||
#define _testhypothesescompact_h_
|
||||
|
||||
#include "NCVTest.hpp"
|
||||
#include "NCVTestSourceProvider.hpp"
|
||||
|
||||
|
||||
class TestCompact : public NCVTestProvider
|
||||
{
|
||||
public:
|
||||
|
||||
TestCompact(std::string testName, NCVTestSourceProvider<Ncv32u> &src,
|
||||
Ncv32u length, Ncv32u badElem, Ncv32u badElemPercentage);
|
||||
|
||||
virtual bool init();
|
||||
virtual bool process();
|
||||
virtual bool deinit();
|
||||
virtual bool toString(std::ofstream &strOut);
|
||||
|
||||
private:
|
||||
TestCompact(const TestCompact&);
|
||||
TestCompact& operator=(const TestCompact&);
|
||||
|
||||
|
||||
NCVTestSourceProvider<Ncv32u> &src;
|
||||
Ncv32u length;
|
||||
Ncv32u badElem;
|
||||
Ncv32u badElemPercentage;
|
||||
};
|
||||
|
||||
#endif // _testhypothesescompact_h_
|
||||
@@ -1,199 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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*/
|
||||
|
||||
#if !defined CUDA_DISABLER
|
||||
|
||||
#include "TestDrawRects.h"
|
||||
#include "NCVHaarObjectDetection.hpp"
|
||||
|
||||
|
||||
template <class T>
|
||||
TestDrawRects<T>::TestDrawRects(std::string testName_, NCVTestSourceProvider<T> &src_,
|
||||
NCVTestSourceProvider<Ncv32u> &src32u_,
|
||||
Ncv32u width_, Ncv32u height_, Ncv32u numRects_, T color_)
|
||||
:
|
||||
NCVTestProvider(testName_),
|
||||
src(src_),
|
||||
src32u(src32u_),
|
||||
width(width_),
|
||||
height(height_),
|
||||
numRects(numRects_),
|
||||
color(color_)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
bool TestDrawRects<T>::toString(std::ofstream &strOut)
|
||||
{
|
||||
strOut << "sizeof(T)=" << sizeof(T) << std::endl;
|
||||
strOut << "width=" << width << std::endl;
|
||||
strOut << "height=" << height << std::endl;
|
||||
strOut << "numRects=" << numRects << std::endl;
|
||||
strOut << "color=" << color << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
bool TestDrawRects<T>::init()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
bool TestDrawRects<T>::process()
|
||||
{
|
||||
NCVStatus ncvStat;
|
||||
bool rcode = false;
|
||||
|
||||
NCVMatrixAlloc<T> d_img(*this->allocatorGPU.get(), this->width, this->height);
|
||||
ncvAssertReturn(d_img.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<T> h_img(*this->allocatorCPU.get(), this->width, this->height);
|
||||
ncvAssertReturn(h_img.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<T> h_img_d(*this->allocatorCPU.get(), this->width, this->height);
|
||||
ncvAssertReturn(h_img_d.isMemAllocated(), false);
|
||||
|
||||
NCVVectorAlloc<NcvRect32u> d_rects(*this->allocatorGPU.get(), this->numRects);
|
||||
ncvAssertReturn(d_rects.isMemAllocated(), false);
|
||||
NCVVectorAlloc<NcvRect32u> h_rects(*this->allocatorCPU.get(), this->numRects);
|
||||
ncvAssertReturn(h_rects.isMemAllocated(), false);
|
||||
|
||||
NCV_SET_SKIP_COND(this->allocatorGPU.get()->isCounting());
|
||||
NCV_SKIP_COND_BEGIN
|
||||
ncvAssertReturn(this->src.fill(h_img), false);
|
||||
ncvStat = h_img.copySolid(d_img, 0);
|
||||
ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
|
||||
ncvAssertCUDAReturn(cudaStreamSynchronize(0), false);
|
||||
|
||||
//fill vector of rectangles with random rects covering the input
|
||||
NCVVectorReuse<Ncv32u> h_rects_as32u(h_rects.getSegment());
|
||||
ncvAssertReturn(h_rects_as32u.isMemReused(), false);
|
||||
ncvAssertReturn(this->src32u.fill(h_rects_as32u), false);
|
||||
for (Ncv32u i=0; i<this->numRects; i++)
|
||||
{
|
||||
h_rects.ptr()[i].x = (Ncv32u)(((1.0 * h_rects.ptr()[i].x) / RAND_MAX) * (this->width-2));
|
||||
h_rects.ptr()[i].y = (Ncv32u)(((1.0 * h_rects.ptr()[i].y) / RAND_MAX) * (this->height-2));
|
||||
h_rects.ptr()[i].width = (Ncv32u)(((1.0 * h_rects.ptr()[i].width) / RAND_MAX) * (this->width+10 - h_rects.ptr()[i].x));
|
||||
h_rects.ptr()[i].height = (Ncv32u)(((1.0 * h_rects.ptr()[i].height) / RAND_MAX) * (this->height+10 - h_rects.ptr()[i].y));
|
||||
}
|
||||
ncvStat = h_rects.copySolid(d_rects, 0);
|
||||
ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
|
||||
ncvAssertCUDAReturn(cudaStreamSynchronize(0), false);
|
||||
|
||||
if (sizeof(T) == sizeof(Ncv32u))
|
||||
{
|
||||
ncvStat = ncvDrawRects_32u_device((Ncv32u *)d_img.ptr(), d_img.stride(), this->width, this->height,
|
||||
(NcvRect32u *)d_rects.ptr(), this->numRects, this->color, 0);
|
||||
}
|
||||
else if (sizeof(T) == sizeof(Ncv8u))
|
||||
{
|
||||
ncvStat = ncvDrawRects_8u_device((Ncv8u *)d_img.ptr(), d_img.stride(), this->width, this->height,
|
||||
(NcvRect32u *)d_rects.ptr(), this->numRects, (Ncv8u)this->color, 0);
|
||||
}
|
||||
else
|
||||
{
|
||||
ncvAssertPrintReturn(false, "Incorrect drawrects test instance", false);
|
||||
}
|
||||
ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
ncvStat = d_img.copySolid(h_img_d, 0);
|
||||
ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
|
||||
ncvAssertCUDAReturn(cudaStreamSynchronize(0), false);
|
||||
|
||||
NCV_SKIP_COND_BEGIN
|
||||
if (sizeof(T) == sizeof(Ncv32u))
|
||||
{
|
||||
ncvStat = ncvDrawRects_32u_host((Ncv32u *)h_img.ptr(), h_img.stride(), this->width, this->height,
|
||||
(NcvRect32u *)h_rects.ptr(), this->numRects, this->color);
|
||||
}
|
||||
else if (sizeof(T) == sizeof(Ncv8u))
|
||||
{
|
||||
ncvStat = ncvDrawRects_8u_host((Ncv8u *)h_img.ptr(), h_img.stride(), this->width, this->height,
|
||||
(NcvRect32u *)h_rects.ptr(), this->numRects, (Ncv8u)this->color);
|
||||
}
|
||||
else
|
||||
{
|
||||
ncvAssertPrintReturn(false, "Incorrect drawrects test instance", false);
|
||||
}
|
||||
ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
//bit-to-bit check
|
||||
bool bLoopVirgin = true;
|
||||
|
||||
NCV_SKIP_COND_BEGIN
|
||||
//const Ncv64f relEPS = 0.005;
|
||||
for (Ncv32u i=0; bLoopVirgin && i < h_img.height(); i++)
|
||||
{
|
||||
for (Ncv32u j=0; bLoopVirgin && j < h_img.width(); j++)
|
||||
{
|
||||
if (h_img.ptr()[h_img.stride()*i+j] != h_img_d.ptr()[h_img_d.stride()*i+j])
|
||||
{
|
||||
bLoopVirgin = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
if (bLoopVirgin)
|
||||
{
|
||||
rcode = true;
|
||||
}
|
||||
|
||||
return rcode;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
bool TestDrawRects<T>::deinit()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
template class TestDrawRects<Ncv8u>;
|
||||
template class TestDrawRects<Ncv32u>;
|
||||
|
||||
#endif /* CUDA_DISABLER */
|
||||
@@ -1,76 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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 _testdrawrects_h_
|
||||
#define _testdrawrects_h_
|
||||
|
||||
#include "NCVTest.hpp"
|
||||
#include "NCVTestSourceProvider.hpp"
|
||||
|
||||
|
||||
template <class T>
|
||||
class TestDrawRects : public NCVTestProvider
|
||||
{
|
||||
public:
|
||||
|
||||
TestDrawRects(std::string testName, NCVTestSourceProvider<T> &src, NCVTestSourceProvider<Ncv32u> &src32u,
|
||||
Ncv32u width, Ncv32u height, Ncv32u numRects, T color);
|
||||
|
||||
virtual bool init();
|
||||
virtual bool process();
|
||||
virtual bool deinit();
|
||||
virtual bool toString(std::ofstream &strOut);
|
||||
|
||||
private:
|
||||
|
||||
TestDrawRects(const TestDrawRects&);
|
||||
TestDrawRects& operator=(const TestDrawRects&);
|
||||
|
||||
NCVTestSourceProvider<T> &src;
|
||||
NCVTestSourceProvider<Ncv32u> &src32u;
|
||||
Ncv32u width;
|
||||
Ncv32u height;
|
||||
Ncv32u numRects;
|
||||
T color;
|
||||
};
|
||||
|
||||
#endif // _testdrawrects_h_
|
||||
@@ -1,347 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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*/
|
||||
|
||||
#if !defined CUDA_DISABLER
|
||||
|
||||
#include <float.h>
|
||||
|
||||
#if defined(__GNUC__) && !defined(__APPLE__) && !defined(__arm__)
|
||||
#include <fpu_control.h>
|
||||
#endif
|
||||
|
||||
namespace
|
||||
{
|
||||
// http://www.christian-seiler.de/projekte/fpmath/
|
||||
class FpuControl
|
||||
{
|
||||
public:
|
||||
FpuControl();
|
||||
~FpuControl();
|
||||
|
||||
private:
|
||||
#if defined(__GNUC__) && !defined(__APPLE__) && !defined(__arm__)
|
||||
fpu_control_t fpu_oldcw, fpu_cw;
|
||||
#elif defined(_WIN32) && !defined(_WIN64)
|
||||
unsigned int fpu_oldcw, fpu_cw;
|
||||
#endif
|
||||
};
|
||||
|
||||
FpuControl::FpuControl()
|
||||
{
|
||||
#if defined(__GNUC__) && !defined(__APPLE__) && !defined(__arm__)
|
||||
_FPU_GETCW(fpu_oldcw);
|
||||
fpu_cw = (fpu_oldcw & ~_FPU_EXTENDED & ~_FPU_DOUBLE & ~_FPU_SINGLE) | _FPU_SINGLE;
|
||||
_FPU_SETCW(fpu_cw);
|
||||
#elif defined(_WIN32) && !defined(_WIN64)
|
||||
_controlfp_s(&fpu_cw, 0, 0);
|
||||
fpu_oldcw = fpu_cw;
|
||||
_controlfp_s(&fpu_cw, _PC_24, _MCW_PC);
|
||||
#endif
|
||||
}
|
||||
|
||||
FpuControl::~FpuControl()
|
||||
{
|
||||
#if defined(__GNUC__) && !defined(__APPLE__) && !defined(__arm__)
|
||||
_FPU_SETCW(fpu_oldcw);
|
||||
#elif defined(_WIN32) && !defined(_WIN64)
|
||||
_controlfp_s(&fpu_cw, fpu_oldcw, _MCW_PC);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
#include "TestHaarCascadeApplication.h"
|
||||
#include "NCVHaarObjectDetection.hpp"
|
||||
|
||||
|
||||
TestHaarCascadeApplication::TestHaarCascadeApplication(std::string testName_, NCVTestSourceProvider<Ncv8u> &src_,
|
||||
std::string cascadeName_, Ncv32u width_, Ncv32u height_)
|
||||
:
|
||||
NCVTestProvider(testName_),
|
||||
src(src_),
|
||||
cascadeName(cascadeName_),
|
||||
width(width_),
|
||||
height(height_)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
bool TestHaarCascadeApplication::toString(std::ofstream &strOut)
|
||||
{
|
||||
strOut << "cascadeName=" << cascadeName << std::endl;
|
||||
strOut << "width=" << width << std::endl;
|
||||
strOut << "height=" << height << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool TestHaarCascadeApplication::init()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
bool TestHaarCascadeApplication::process()
|
||||
{
|
||||
NCVStatus ncvStat;
|
||||
bool rcode = false;
|
||||
|
||||
Ncv32u numStages, numNodes, numFeatures;
|
||||
|
||||
ncvStat = ncvHaarGetClassifierSize(this->cascadeName, numStages, numNodes, numFeatures);
|
||||
ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
|
||||
|
||||
NCVVectorAlloc<HaarStage64> h_HaarStages(*this->allocatorCPU.get(), numStages);
|
||||
ncvAssertReturn(h_HaarStages.isMemAllocated(), false);
|
||||
NCVVectorAlloc<HaarClassifierNode128> h_HaarNodes(*this->allocatorCPU.get(), numNodes);
|
||||
ncvAssertReturn(h_HaarNodes.isMemAllocated(), false);
|
||||
NCVVectorAlloc<HaarFeature64> h_HaarFeatures(*this->allocatorCPU.get(), numFeatures);
|
||||
ncvAssertReturn(h_HaarFeatures.isMemAllocated(), false);
|
||||
|
||||
NCVVectorAlloc<HaarStage64> d_HaarStages(*this->allocatorGPU.get(), numStages);
|
||||
ncvAssertReturn(d_HaarStages.isMemAllocated(), false);
|
||||
NCVVectorAlloc<HaarClassifierNode128> d_HaarNodes(*this->allocatorGPU.get(), numNodes);
|
||||
ncvAssertReturn(d_HaarNodes.isMemAllocated(), false);
|
||||
NCVVectorAlloc<HaarFeature64> d_HaarFeatures(*this->allocatorGPU.get(), numFeatures);
|
||||
ncvAssertReturn(d_HaarFeatures.isMemAllocated(), false);
|
||||
|
||||
HaarClassifierCascadeDescriptor haar;
|
||||
haar.ClassifierSize.width = haar.ClassifierSize.height = 1;
|
||||
haar.bNeedsTiltedII = false;
|
||||
haar.NumClassifierRootNodes = numNodes;
|
||||
haar.NumClassifierTotalNodes = numNodes;
|
||||
haar.NumFeatures = numFeatures;
|
||||
haar.NumStages = numStages;
|
||||
|
||||
NCV_SET_SKIP_COND(this->allocatorGPU.get()->isCounting());
|
||||
NCV_SKIP_COND_BEGIN
|
||||
|
||||
ncvStat = ncvHaarLoadFromFile_host(this->cascadeName, haar, h_HaarStages, h_HaarNodes, h_HaarFeatures);
|
||||
ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
|
||||
|
||||
ncvAssertReturn(NCV_SUCCESS == h_HaarStages.copySolid(d_HaarStages, 0), false);
|
||||
ncvAssertReturn(NCV_SUCCESS == h_HaarNodes.copySolid(d_HaarNodes, 0), false);
|
||||
ncvAssertReturn(NCV_SUCCESS == h_HaarFeatures.copySolid(d_HaarFeatures, 0), false);
|
||||
ncvAssertCUDAReturn(cudaStreamSynchronize(0), false);
|
||||
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
NcvSize32s srcRoi, srcIIRoi, searchRoi;
|
||||
srcRoi.width = this->width;
|
||||
srcRoi.height = this->height;
|
||||
srcIIRoi.width = srcRoi.width + 1;
|
||||
srcIIRoi.height = srcRoi.height + 1;
|
||||
searchRoi.width = srcIIRoi.width - haar.ClassifierSize.width;
|
||||
searchRoi.height = srcIIRoi.height - haar.ClassifierSize.height;
|
||||
if (searchRoi.width <= 0 || searchRoi.height <= 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
NcvSize32u searchRoiU(searchRoi.width, searchRoi.height);
|
||||
|
||||
NCVMatrixAlloc<Ncv8u> d_img(*this->allocatorGPU.get(), this->width, this->height);
|
||||
ncvAssertReturn(d_img.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<Ncv8u> h_img(*this->allocatorCPU.get(), this->width, this->height);
|
||||
ncvAssertReturn(h_img.isMemAllocated(), false);
|
||||
|
||||
Ncv32u integralWidth = this->width + 1;
|
||||
Ncv32u integralHeight = this->height + 1;
|
||||
|
||||
NCVMatrixAlloc<Ncv32u> d_integralImage(*this->allocatorGPU.get(), integralWidth, integralHeight);
|
||||
ncvAssertReturn(d_integralImage.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<Ncv64u> d_sqIntegralImage(*this->allocatorGPU.get(), integralWidth, integralHeight);
|
||||
ncvAssertReturn(d_sqIntegralImage.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<Ncv32u> h_integralImage(*this->allocatorCPU.get(), integralWidth, integralHeight);
|
||||
ncvAssertReturn(h_integralImage.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<Ncv64u> h_sqIntegralImage(*this->allocatorCPU.get(), integralWidth, integralHeight);
|
||||
ncvAssertReturn(h_sqIntegralImage.isMemAllocated(), false);
|
||||
|
||||
NCVMatrixAlloc<Ncv32f> d_rectStdDev(*this->allocatorGPU.get(), this->width, this->height);
|
||||
ncvAssertReturn(d_rectStdDev.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<Ncv32u> d_pixelMask(*this->allocatorGPU.get(), this->width, this->height);
|
||||
ncvAssertReturn(d_pixelMask.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<Ncv32f> h_rectStdDev(*this->allocatorCPU.get(), this->width, this->height);
|
||||
ncvAssertReturn(h_rectStdDev.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<Ncv32u> h_pixelMask(*this->allocatorCPU.get(), this->width, this->height);
|
||||
ncvAssertReturn(h_pixelMask.isMemAllocated(), false);
|
||||
|
||||
NCVVectorAlloc<NcvRect32u> d_hypotheses(*this->allocatorGPU.get(), this->width * this->height);
|
||||
ncvAssertReturn(d_hypotheses.isMemAllocated(), false);
|
||||
NCVVectorAlloc<NcvRect32u> h_hypotheses(*this->allocatorCPU.get(), this->width * this->height);
|
||||
ncvAssertReturn(h_hypotheses.isMemAllocated(), false);
|
||||
|
||||
NCVStatus nppStat;
|
||||
Ncv32u szTmpBufIntegral, szTmpBufSqIntegral;
|
||||
nppStat = nppiStIntegralGetSize_8u32u(NcvSize32u(this->width, this->height), &szTmpBufIntegral, this->devProp);
|
||||
ncvAssertReturn(nppStat == NPPST_SUCCESS, false);
|
||||
nppStat = nppiStSqrIntegralGetSize_8u64u(NcvSize32u(this->width, this->height), &szTmpBufSqIntegral, this->devProp);
|
||||
ncvAssertReturn(nppStat == NPPST_SUCCESS, false);
|
||||
NCVVectorAlloc<Ncv8u> d_tmpIIbuf(*this->allocatorGPU.get(), std::max(szTmpBufIntegral, szTmpBufSqIntegral));
|
||||
ncvAssertReturn(d_tmpIIbuf.isMemAllocated(), false);
|
||||
|
||||
Ncv32u detectionsOnThisScale_d = 0;
|
||||
Ncv32u detectionsOnThisScale_h = 0;
|
||||
|
||||
NCV_SKIP_COND_BEGIN
|
||||
|
||||
ncvAssertReturn(this->src.fill(h_img), false);
|
||||
ncvStat = h_img.copySolid(d_img, 0);
|
||||
ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
|
||||
ncvAssertCUDAReturn(cudaStreamSynchronize(0), false);
|
||||
|
||||
nppStat = nppiStIntegral_8u32u_C1R(d_img.ptr(), d_img.pitch(),
|
||||
d_integralImage.ptr(), d_integralImage.pitch(),
|
||||
NcvSize32u(d_img.width(), d_img.height()),
|
||||
d_tmpIIbuf.ptr(), szTmpBufIntegral, this->devProp);
|
||||
ncvAssertReturn(nppStat == NPPST_SUCCESS, false);
|
||||
|
||||
nppStat = nppiStSqrIntegral_8u64u_C1R(d_img.ptr(), d_img.pitch(),
|
||||
d_sqIntegralImage.ptr(), d_sqIntegralImage.pitch(),
|
||||
NcvSize32u(d_img.width(), d_img.height()),
|
||||
d_tmpIIbuf.ptr(), szTmpBufSqIntegral, this->devProp);
|
||||
ncvAssertReturn(nppStat == NPPST_SUCCESS, false);
|
||||
|
||||
const NcvRect32u rect(
|
||||
HAAR_STDDEV_BORDER,
|
||||
HAAR_STDDEV_BORDER,
|
||||
haar.ClassifierSize.width - 2*HAAR_STDDEV_BORDER,
|
||||
haar.ClassifierSize.height - 2*HAAR_STDDEV_BORDER);
|
||||
nppStat = nppiStRectStdDev_32f_C1R(
|
||||
d_integralImage.ptr(), d_integralImage.pitch(),
|
||||
d_sqIntegralImage.ptr(), d_sqIntegralImage.pitch(),
|
||||
d_rectStdDev.ptr(), d_rectStdDev.pitch(),
|
||||
NcvSize32u(searchRoi.width, searchRoi.height), rect,
|
||||
1.0f, true);
|
||||
ncvAssertReturn(nppStat == NPPST_SUCCESS, false);
|
||||
|
||||
ncvStat = d_integralImage.copySolid(h_integralImage, 0);
|
||||
ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
|
||||
ncvStat = d_rectStdDev.copySolid(h_rectStdDev, 0);
|
||||
ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
|
||||
|
||||
for (Ncv32u i=0; i<searchRoiU.height; i++)
|
||||
{
|
||||
for (Ncv32u j=0; j<h_pixelMask.stride(); j++)
|
||||
{
|
||||
if (j<searchRoiU.width)
|
||||
{
|
||||
h_pixelMask.ptr()[i*h_pixelMask.stride()+j] = (i << 16) | j;
|
||||
}
|
||||
else
|
||||
{
|
||||
h_pixelMask.ptr()[i*h_pixelMask.stride()+j] = OBJDET_MASK_ELEMENT_INVALID_32U;
|
||||
}
|
||||
}
|
||||
}
|
||||
ncvAssertReturn(cudaSuccess == cudaStreamSynchronize(0), false);
|
||||
|
||||
{
|
||||
// calculations here
|
||||
FpuControl fpu;
|
||||
(void) fpu;
|
||||
|
||||
ncvStat = ncvApplyHaarClassifierCascade_host(
|
||||
h_integralImage, h_rectStdDev, h_pixelMask,
|
||||
detectionsOnThisScale_h,
|
||||
haar, h_HaarStages, h_HaarNodes, h_HaarFeatures, false,
|
||||
searchRoiU, 1, 1.0f);
|
||||
ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
|
||||
}
|
||||
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
int devId;
|
||||
ncvAssertCUDAReturn(cudaGetDevice(&devId), false);
|
||||
cudaDeviceProp _devProp;
|
||||
ncvAssertCUDAReturn(cudaGetDeviceProperties(&_devProp, devId), false);
|
||||
|
||||
ncvStat = ncvApplyHaarClassifierCascade_device(
|
||||
d_integralImage, d_rectStdDev, d_pixelMask,
|
||||
detectionsOnThisScale_d,
|
||||
haar, h_HaarStages, d_HaarStages, d_HaarNodes, d_HaarFeatures, false,
|
||||
searchRoiU, 1, 1.0f,
|
||||
*this->allocatorGPU.get(), *this->allocatorCPU.get(),
|
||||
_devProp, 0);
|
||||
ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
|
||||
|
||||
NCVMatrixAlloc<Ncv32u> h_pixelMask_d(*this->allocatorCPU.get(), this->width, this->height);
|
||||
ncvAssertReturn(h_pixelMask_d.isMemAllocated(), false);
|
||||
|
||||
//bit-to-bit check
|
||||
bool bLoopVirgin = true;
|
||||
|
||||
NCV_SKIP_COND_BEGIN
|
||||
|
||||
ncvStat = d_pixelMask.copySolid(h_pixelMask_d, 0);
|
||||
ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
|
||||
|
||||
if (detectionsOnThisScale_d != detectionsOnThisScale_h)
|
||||
{
|
||||
bLoopVirgin = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
std::sort(h_pixelMask_d.ptr(), h_pixelMask_d.ptr() + detectionsOnThisScale_d);
|
||||
for (Ncv32u i=0; i<detectionsOnThisScale_d && bLoopVirgin; i++)
|
||||
{
|
||||
if (h_pixelMask.ptr()[i] != h_pixelMask_d.ptr()[i])
|
||||
{
|
||||
bLoopVirgin = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
if (bLoopVirgin)
|
||||
{
|
||||
rcode = true;
|
||||
}
|
||||
|
||||
return rcode;
|
||||
}
|
||||
|
||||
|
||||
bool TestHaarCascadeApplication::deinit()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
#endif /* CUDA_DISABLER */
|
||||
@@ -1,73 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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 _testhaarcascadeapplication_h_
|
||||
#define _testhaarcascadeapplication_h_
|
||||
|
||||
#include "NCVTest.hpp"
|
||||
#include "NCVTestSourceProvider.hpp"
|
||||
|
||||
|
||||
class TestHaarCascadeApplication : public NCVTestProvider
|
||||
{
|
||||
public:
|
||||
|
||||
TestHaarCascadeApplication(std::string testName, NCVTestSourceProvider<Ncv8u> &src,
|
||||
std::string cascadeName, Ncv32u width, Ncv32u height);
|
||||
|
||||
virtual bool init();
|
||||
virtual bool process();
|
||||
virtual bool deinit();
|
||||
virtual bool toString(std::ofstream &strOut);
|
||||
|
||||
private:
|
||||
TestHaarCascadeApplication(const TestHaarCascadeApplication&);
|
||||
TestHaarCascadeApplication& operator=(const TestHaarCascadeApplication&);
|
||||
|
||||
|
||||
NCVTestSourceProvider<Ncv8u> &src;
|
||||
std::string cascadeName;
|
||||
Ncv32u width;
|
||||
Ncv32u height;
|
||||
};
|
||||
|
||||
#endif // _testhaarcascadeapplication_h_
|
||||
@@ -1,158 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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*/
|
||||
|
||||
#if !defined CUDA_DISABLER
|
||||
|
||||
#include "TestHaarCascadeLoader.h"
|
||||
#include "NCVHaarObjectDetection.hpp"
|
||||
|
||||
|
||||
TestHaarCascadeLoader::TestHaarCascadeLoader(std::string testName_, std::string cascadeName_)
|
||||
:
|
||||
NCVTestProvider(testName_),
|
||||
cascadeName(cascadeName_)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
bool TestHaarCascadeLoader::toString(std::ofstream &strOut)
|
||||
{
|
||||
strOut << "cascadeName=" << cascadeName << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool TestHaarCascadeLoader::init()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool TestHaarCascadeLoader::process()
|
||||
{
|
||||
NCVStatus ncvStat;
|
||||
bool rcode = false;
|
||||
|
||||
Ncv32u numStages, numNodes, numFeatures;
|
||||
Ncv32u numStages_2 = 0, numNodes_2 = 0, numFeatures_2 = 0;
|
||||
|
||||
ncvStat = ncvHaarGetClassifierSize(this->cascadeName, numStages, numNodes, numFeatures);
|
||||
ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
|
||||
|
||||
NCVVectorAlloc<HaarStage64> h_HaarStages(*this->allocatorCPU.get(), numStages);
|
||||
ncvAssertReturn(h_HaarStages.isMemAllocated(), false);
|
||||
NCVVectorAlloc<HaarClassifierNode128> h_HaarNodes(*this->allocatorCPU.get(), numNodes);
|
||||
ncvAssertReturn(h_HaarNodes.isMemAllocated(), false);
|
||||
NCVVectorAlloc<HaarFeature64> h_HaarFeatures(*this->allocatorCPU.get(), numFeatures);
|
||||
ncvAssertReturn(h_HaarFeatures.isMemAllocated(), false);
|
||||
|
||||
NCVVectorAlloc<HaarStage64> h_HaarStages_2(*this->allocatorCPU.get(), numStages);
|
||||
ncvAssertReturn(h_HaarStages_2.isMemAllocated(), false);
|
||||
NCVVectorAlloc<HaarClassifierNode128> h_HaarNodes_2(*this->allocatorCPU.get(), numNodes);
|
||||
ncvAssertReturn(h_HaarNodes_2.isMemAllocated(), false);
|
||||
NCVVectorAlloc<HaarFeature64> h_HaarFeatures_2(*this->allocatorCPU.get(), numFeatures);
|
||||
ncvAssertReturn(h_HaarFeatures_2.isMemAllocated(), false);
|
||||
|
||||
HaarClassifierCascadeDescriptor haar;
|
||||
HaarClassifierCascadeDescriptor haar_2;
|
||||
|
||||
NCV_SET_SKIP_COND(this->allocatorGPU.get()->isCounting());
|
||||
NCV_SKIP_COND_BEGIN
|
||||
|
||||
const std::string testNvbinName = "test.nvbin";
|
||||
ncvStat = ncvHaarLoadFromFile_host(this->cascadeName, haar, h_HaarStages, h_HaarNodes, h_HaarFeatures);
|
||||
ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
|
||||
|
||||
ncvStat = ncvHaarStoreNVBIN_host(testNvbinName, haar, h_HaarStages, h_HaarNodes, h_HaarFeatures);
|
||||
ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
|
||||
|
||||
ncvStat = ncvHaarGetClassifierSize(testNvbinName, numStages_2, numNodes_2, numFeatures_2);
|
||||
ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
|
||||
|
||||
ncvStat = ncvHaarLoadFromFile_host(testNvbinName, haar_2, h_HaarStages_2, h_HaarNodes_2, h_HaarFeatures_2);
|
||||
ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
|
||||
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
//bit-to-bit check
|
||||
bool bLoopVirgin = true;
|
||||
|
||||
NCV_SKIP_COND_BEGIN
|
||||
|
||||
if (
|
||||
numStages_2 != numStages ||
|
||||
numNodes_2 != numNodes ||
|
||||
numFeatures_2 != numFeatures ||
|
||||
haar.NumStages != haar_2.NumStages ||
|
||||
haar.NumClassifierRootNodes != haar_2.NumClassifierRootNodes ||
|
||||
haar.NumClassifierTotalNodes != haar_2.NumClassifierTotalNodes ||
|
||||
haar.NumFeatures != haar_2.NumFeatures ||
|
||||
haar.ClassifierSize.width != haar_2.ClassifierSize.width ||
|
||||
haar.ClassifierSize.height != haar_2.ClassifierSize.height ||
|
||||
haar.bNeedsTiltedII != haar_2.bNeedsTiltedII ||
|
||||
haar.bHasStumpsOnly != haar_2.bHasStumpsOnly )
|
||||
{
|
||||
bLoopVirgin = false;
|
||||
}
|
||||
if (memcmp(h_HaarStages.ptr(), h_HaarStages_2.ptr(), haar.NumStages * sizeof(HaarStage64)) ||
|
||||
memcmp(h_HaarNodes.ptr(), h_HaarNodes_2.ptr(), haar.NumClassifierTotalNodes * sizeof(HaarClassifierNode128)) ||
|
||||
memcmp(h_HaarFeatures.ptr(), h_HaarFeatures_2.ptr(), haar.NumFeatures * sizeof(HaarFeature64)) )
|
||||
{
|
||||
bLoopVirgin = false;
|
||||
}
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
if (bLoopVirgin)
|
||||
{
|
||||
rcode = true;
|
||||
}
|
||||
|
||||
return rcode;
|
||||
}
|
||||
|
||||
|
||||
bool TestHaarCascadeLoader::deinit()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
#endif /* CUDA_DISABLER */
|
||||
@@ -1,211 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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*/
|
||||
|
||||
#if !defined CUDA_DISABLER
|
||||
|
||||
#include "TestHypothesesFilter.h"
|
||||
#include "NCVHaarObjectDetection.hpp"
|
||||
|
||||
|
||||
TestHypothesesFilter::TestHypothesesFilter(std::string testName_, NCVTestSourceProvider<Ncv32u> &src_,
|
||||
Ncv32u numDstRects_, Ncv32u minNeighbors_, Ncv32f eps_)
|
||||
:
|
||||
NCVTestProvider(testName_),
|
||||
src(src_),
|
||||
numDstRects(numDstRects_),
|
||||
minNeighbors(minNeighbors_),
|
||||
eps(eps_)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
bool TestHypothesesFilter::toString(std::ofstream &strOut)
|
||||
{
|
||||
strOut << "numDstRects=" << numDstRects << std::endl;
|
||||
strOut << "minNeighbors=" << minNeighbors << std::endl;
|
||||
strOut << "eps=" << eps << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool TestHypothesesFilter::init()
|
||||
{
|
||||
this->canvasWidth = 4096;
|
||||
this->canvasHeight = 4096;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool compareRects(const NcvRect32u &r1, const NcvRect32u &r2, Ncv32f eps)
|
||||
{
|
||||
double delta = eps*(std::min(r1.width, r2.width) + std::min(r1.height, r2.height))*0.5;
|
||||
return std::abs((Ncv32s)r1.x - (Ncv32s)r2.x) <= delta &&
|
||||
std::abs((Ncv32s)r1.y - (Ncv32s)r2.y) <= delta &&
|
||||
std::abs((Ncv32s)r1.x + (Ncv32s)r1.width - (Ncv32s)r2.x - (Ncv32s)r2.width) <= delta &&
|
||||
std::abs((Ncv32s)r1.y + (Ncv32s)r1.height - (Ncv32s)r2.y - (Ncv32s)r2.height) <= delta;
|
||||
}
|
||||
|
||||
|
||||
inline bool operator < (const NcvRect32u &a, const NcvRect32u &b)
|
||||
{
|
||||
return a.x < b.x;
|
||||
}
|
||||
|
||||
|
||||
bool TestHypothesesFilter::process()
|
||||
{
|
||||
NCVStatus ncvStat;
|
||||
bool rcode = false;
|
||||
|
||||
NCVVectorAlloc<Ncv32u> h_random32u(*this->allocatorCPU.get(), this->numDstRects * sizeof(NcvRect32u) / sizeof(Ncv32u));
|
||||
ncvAssertReturn(h_random32u.isMemAllocated(), false);
|
||||
|
||||
Ncv32u srcSlotSize = 2 * this->minNeighbors + 1;
|
||||
|
||||
NCVVectorAlloc<NcvRect32u> h_vecSrc(*this->allocatorCPU.get(), this->numDstRects*srcSlotSize);
|
||||
ncvAssertReturn(h_vecSrc.isMemAllocated(), false);
|
||||
NCVVectorAlloc<NcvRect32u> h_vecDst_groundTruth(*this->allocatorCPU.get(), this->numDstRects);
|
||||
ncvAssertReturn(h_vecDst_groundTruth.isMemAllocated(), false);
|
||||
|
||||
NCV_SET_SKIP_COND(this->allocatorCPU.get()->isCounting());
|
||||
|
||||
NCV_SKIP_COND_BEGIN
|
||||
ncvAssertReturn(this->src.fill(h_random32u), false);
|
||||
Ncv32u randCnt = 0;
|
||||
Ncv64f randVal;
|
||||
|
||||
for (Ncv32u i=0; i<this->numDstRects; i++)
|
||||
{
|
||||
h_vecDst_groundTruth.ptr()[i].x = i * this->canvasWidth / this->numDstRects + this->canvasWidth / (this->numDstRects * 4);
|
||||
h_vecDst_groundTruth.ptr()[i].y = i * this->canvasHeight / this->numDstRects + this->canvasHeight / (this->numDstRects * 4);
|
||||
h_vecDst_groundTruth.ptr()[i].width = this->canvasWidth / (this->numDstRects * 2);
|
||||
h_vecDst_groundTruth.ptr()[i].height = this->canvasHeight / (this->numDstRects * 2);
|
||||
|
||||
Ncv32u numNeighbors = this->minNeighbors + 1 + (Ncv32u)(((1.0 * h_random32u.ptr()[i]) * (this->minNeighbors + 1)) / 0xFFFFFFFF);
|
||||
numNeighbors = (numNeighbors > srcSlotSize) ? srcSlotSize : numNeighbors;
|
||||
|
||||
//fill in strong hypotheses (2 * ((1.0 * randVal) / 0xFFFFFFFF) - 1)
|
||||
for (Ncv32u j=0; j<numNeighbors; j++)
|
||||
{
|
||||
randVal = (1.0 * h_random32u.ptr()[randCnt++]) / 0xFFFFFFFF; randCnt = randCnt % h_random32u.length();
|
||||
h_vecSrc.ptr()[srcSlotSize * i + j].x =
|
||||
h_vecDst_groundTruth.ptr()[i].x +
|
||||
(Ncv32s)(h_vecDst_groundTruth.ptr()[i].width * this->eps * (randVal - 0.5));
|
||||
randVal = (1.0 * h_random32u.ptr()[randCnt++]) / 0xFFFFFFFF; randCnt = randCnt % h_random32u.length();
|
||||
h_vecSrc.ptr()[srcSlotSize * i + j].y =
|
||||
h_vecDst_groundTruth.ptr()[i].y +
|
||||
(Ncv32s)(h_vecDst_groundTruth.ptr()[i].height * this->eps * (randVal - 0.5));
|
||||
h_vecSrc.ptr()[srcSlotSize * i + j].width = h_vecDst_groundTruth.ptr()[i].width;
|
||||
h_vecSrc.ptr()[srcSlotSize * i + j].height = h_vecDst_groundTruth.ptr()[i].height;
|
||||
}
|
||||
|
||||
//generate weak hypotheses (to be removed in processing)
|
||||
for (Ncv32u j=numNeighbors; j<srcSlotSize; j++)
|
||||
{
|
||||
randVal = (1.0 * h_random32u.ptr()[randCnt++]) / 0xFFFFFFFF; randCnt = randCnt % h_random32u.length();
|
||||
h_vecSrc.ptr()[srcSlotSize * i + j].x =
|
||||
this->canvasWidth + h_vecDst_groundTruth.ptr()[i].x +
|
||||
(Ncv32s)(h_vecDst_groundTruth.ptr()[i].width * this->eps * (randVal - 0.5));
|
||||
randVal = (1.0 * h_random32u.ptr()[randCnt++]) / 0xFFFFFFFF; randCnt = randCnt % h_random32u.length();
|
||||
h_vecSrc.ptr()[srcSlotSize * i + j].y =
|
||||
this->canvasHeight + h_vecDst_groundTruth.ptr()[i].y +
|
||||
(Ncv32s)(h_vecDst_groundTruth.ptr()[i].height * this->eps * (randVal - 0.5));
|
||||
h_vecSrc.ptr()[srcSlotSize * i + j].width = h_vecDst_groundTruth.ptr()[i].width;
|
||||
h_vecSrc.ptr()[srcSlotSize * i + j].height = h_vecDst_groundTruth.ptr()[i].height;
|
||||
}
|
||||
}
|
||||
|
||||
//shuffle
|
||||
for (Ncv32u i=0; i<this->numDstRects*srcSlotSize-1; i++)
|
||||
{
|
||||
Ncv32u randValLocal = h_random32u.ptr()[randCnt++]; randCnt = randCnt % h_random32u.length();
|
||||
Ncv32u secondSwap = randValLocal % (this->numDstRects*srcSlotSize-1 - i);
|
||||
NcvRect32u tmp = h_vecSrc.ptr()[i + secondSwap];
|
||||
h_vecSrc.ptr()[i + secondSwap] = h_vecSrc.ptr()[i];
|
||||
h_vecSrc.ptr()[i] = tmp;
|
||||
}
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
Ncv32u numHypothesesSrc = static_cast<Ncv32u>(h_vecSrc.length());
|
||||
NCV_SKIP_COND_BEGIN
|
||||
ncvStat = ncvGroupRectangles_host(h_vecSrc, numHypothesesSrc, this->minNeighbors, this->eps, NULL);
|
||||
ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
//verification
|
||||
bool bLoopVirgin = true;
|
||||
|
||||
NCV_SKIP_COND_BEGIN
|
||||
if (numHypothesesSrc != this->numDstRects)
|
||||
{
|
||||
bLoopVirgin = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
std::vector<NcvRect32u> tmpRects(numHypothesesSrc);
|
||||
memcpy(&tmpRects[0], h_vecSrc.ptr(), numHypothesesSrc * sizeof(NcvRect32u));
|
||||
std::sort(tmpRects.begin(), tmpRects.end());
|
||||
for (Ncv32u i=0; i<numHypothesesSrc && bLoopVirgin; i++)
|
||||
{
|
||||
if (!compareRects(tmpRects[i], h_vecDst_groundTruth.ptr()[i], this->eps))
|
||||
{
|
||||
bLoopVirgin = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
if (bLoopVirgin)
|
||||
{
|
||||
rcode = true;
|
||||
}
|
||||
|
||||
return rcode;
|
||||
}
|
||||
|
||||
|
||||
bool TestHypothesesFilter::deinit()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
#endif /* CUDA_DISABLER */
|
||||
@@ -1,76 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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 _testhypothesesfilter_h_
|
||||
#define _testhypothesesfilter_h_
|
||||
|
||||
#include "NCVTest.hpp"
|
||||
#include "NCVTestSourceProvider.hpp"
|
||||
|
||||
|
||||
class TestHypothesesFilter : public NCVTestProvider
|
||||
{
|
||||
public:
|
||||
|
||||
TestHypothesesFilter(std::string testName, NCVTestSourceProvider<Ncv32u> &src,
|
||||
Ncv32u numDstRects, Ncv32u minNeighbors, Ncv32f eps);
|
||||
|
||||
virtual bool init();
|
||||
virtual bool process();
|
||||
virtual bool deinit();
|
||||
virtual bool toString(std::ofstream &strOut);
|
||||
|
||||
private:
|
||||
|
||||
TestHypothesesFilter(const TestHypothesesFilter&);
|
||||
TestHypothesesFilter& operator=(const TestHypothesesFilter&);
|
||||
|
||||
NCVTestSourceProvider<Ncv32u> &src;
|
||||
Ncv32u numDstRects;
|
||||
Ncv32u minNeighbors;
|
||||
Ncv32f eps;
|
||||
|
||||
Ncv32u canvasWidth;
|
||||
Ncv32u canvasHeight;
|
||||
};
|
||||
|
||||
#endif // _testhypothesesfilter_h_
|
||||
@@ -1,169 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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*/
|
||||
|
||||
#if !defined CUDA_DISABLER
|
||||
|
||||
#include "TestHypothesesGrow.h"
|
||||
#include "NCVHaarObjectDetection.hpp"
|
||||
|
||||
|
||||
TestHypothesesGrow::TestHypothesesGrow(std::string testName_, NCVTestSourceProvider<Ncv32u> &src_,
|
||||
Ncv32u rectWidth_, Ncv32u rectHeight_, Ncv32f rectScale_,
|
||||
Ncv32u maxLenSrc_, Ncv32u lenSrc_, Ncv32u maxLenDst_, Ncv32u lenDst_)
|
||||
:
|
||||
NCVTestProvider(testName_),
|
||||
src(src_),
|
||||
rectWidth(rectWidth_),
|
||||
rectHeight(rectHeight_),
|
||||
rectScale(rectScale_),
|
||||
maxLenSrc(maxLenSrc_),
|
||||
lenSrc(lenSrc_),
|
||||
maxLenDst(maxLenDst_),
|
||||
lenDst(lenDst_)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
bool TestHypothesesGrow::toString(std::ofstream &strOut)
|
||||
{
|
||||
strOut << "rectWidth=" << rectWidth << std::endl;
|
||||
strOut << "rectHeight=" << rectHeight << std::endl;
|
||||
strOut << "rectScale=" << rectScale << std::endl;
|
||||
strOut << "maxLenSrc=" << maxLenSrc << std::endl;
|
||||
strOut << "lenSrc=" << lenSrc << std::endl;
|
||||
strOut << "maxLenDst=" << maxLenDst << std::endl;
|
||||
strOut << "lenDst=" << lenDst << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool TestHypothesesGrow::init()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool TestHypothesesGrow::process()
|
||||
{
|
||||
NCVStatus ncvStat;
|
||||
bool rcode = false;
|
||||
|
||||
NCVVectorAlloc<Ncv32u> h_vecSrc(*this->allocatorCPU.get(), this->maxLenSrc);
|
||||
ncvAssertReturn(h_vecSrc.isMemAllocated(), false);
|
||||
NCVVectorAlloc<Ncv32u> d_vecSrc(*this->allocatorGPU.get(), this->maxLenSrc);
|
||||
ncvAssertReturn(d_vecSrc.isMemAllocated(), false);
|
||||
|
||||
NCVVectorAlloc<NcvRect32u> h_vecDst(*this->allocatorCPU.get(), this->maxLenDst);
|
||||
ncvAssertReturn(h_vecDst.isMemAllocated(), false);
|
||||
NCVVectorAlloc<NcvRect32u> d_vecDst(*this->allocatorGPU.get(), this->maxLenDst);
|
||||
ncvAssertReturn(d_vecDst.isMemAllocated(), false);
|
||||
NCVVectorAlloc<NcvRect32u> h_vecDst_d(*this->allocatorCPU.get(), this->maxLenDst);
|
||||
ncvAssertReturn(h_vecDst_d.isMemAllocated(), false);
|
||||
|
||||
NCV_SET_SKIP_COND(this->allocatorGPU.get()->isCounting());
|
||||
|
||||
NCV_SKIP_COND_BEGIN
|
||||
ncvAssertReturn(this->src.fill(h_vecSrc), false);
|
||||
memset(h_vecDst.ptr(), 0, h_vecDst.length() * sizeof(NcvRect32u));
|
||||
NCVVectorReuse<Ncv32u> h_vecDst_as32u(h_vecDst.getSegment(), lenDst * sizeof(NcvRect32u) / sizeof(Ncv32u));
|
||||
ncvAssertReturn(h_vecDst_as32u.isMemReused(), false);
|
||||
ncvAssertReturn(this->src.fill(h_vecDst_as32u), false);
|
||||
memcpy(h_vecDst_d.ptr(), h_vecDst.ptr(), h_vecDst.length() * sizeof(NcvRect32u));
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
ncvStat = h_vecSrc.copySolid(d_vecSrc, 0);
|
||||
ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
|
||||
ncvStat = h_vecDst.copySolid(d_vecDst, 0);
|
||||
ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
|
||||
ncvAssertCUDAReturn(cudaStreamSynchronize(0), false);
|
||||
|
||||
Ncv32u h_outElemNum_d = 0;
|
||||
Ncv32u h_outElemNum_h = 0;
|
||||
NCV_SKIP_COND_BEGIN
|
||||
h_outElemNum_d = this->lenDst;
|
||||
ncvStat = ncvGrowDetectionsVector_device(d_vecSrc, this->lenSrc,
|
||||
d_vecDst, h_outElemNum_d, this->maxLenDst,
|
||||
this->rectWidth, this->rectHeight, this->rectScale, 0);
|
||||
ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
|
||||
ncvStat = d_vecDst.copySolid(h_vecDst_d, 0);
|
||||
ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
|
||||
ncvAssertCUDAReturn(cudaStreamSynchronize(0), false);
|
||||
|
||||
h_outElemNum_h = this->lenDst;
|
||||
ncvStat = ncvGrowDetectionsVector_host(h_vecSrc, this->lenSrc,
|
||||
h_vecDst, h_outElemNum_h, this->maxLenDst,
|
||||
this->rectWidth, this->rectHeight, this->rectScale);
|
||||
ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
//bit-to-bit check
|
||||
bool bLoopVirgin = true;
|
||||
|
||||
NCV_SKIP_COND_BEGIN
|
||||
if (h_outElemNum_d != h_outElemNum_h)
|
||||
{
|
||||
bLoopVirgin = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (memcmp(h_vecDst.ptr(), h_vecDst_d.ptr(), this->maxLenDst * sizeof(NcvRect32u)))
|
||||
{
|
||||
bLoopVirgin = false;
|
||||
}
|
||||
}
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
if (bLoopVirgin)
|
||||
{
|
||||
rcode = true;
|
||||
}
|
||||
|
||||
return rcode;
|
||||
}
|
||||
|
||||
|
||||
bool TestHypothesesGrow::deinit()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
#endif /* CUDA_DISABLER */
|
||||
@@ -1,78 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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 _testhypothesesgrow_h_
|
||||
#define _testhypothesesgrow_h_
|
||||
|
||||
#include "NCVTest.hpp"
|
||||
#include "NCVTestSourceProvider.hpp"
|
||||
|
||||
|
||||
class TestHypothesesGrow : public NCVTestProvider
|
||||
{
|
||||
public:
|
||||
|
||||
TestHypothesesGrow(std::string testName, NCVTestSourceProvider<Ncv32u> &src,
|
||||
Ncv32u rectWidth, Ncv32u rectHeight, Ncv32f rectScale,
|
||||
Ncv32u maxLenSrc, Ncv32u lenSrc, Ncv32u maxLenDst, Ncv32u lenDst);
|
||||
|
||||
virtual bool init();
|
||||
virtual bool process();
|
||||
virtual bool deinit();
|
||||
virtual bool toString(std::ofstream &strOut);
|
||||
|
||||
private:
|
||||
TestHypothesesGrow(const TestHypothesesGrow&);
|
||||
TestHypothesesGrow& operator=(const TestHypothesesGrow&);
|
||||
|
||||
|
||||
NCVTestSourceProvider<Ncv32u> &src;
|
||||
Ncv32u rectWidth;
|
||||
Ncv32u rectHeight;
|
||||
Ncv32f rectScale;
|
||||
Ncv32u maxLenSrc;
|
||||
Ncv32u lenSrc;
|
||||
Ncv32u maxLenDst;
|
||||
Ncv32u lenDst;
|
||||
};
|
||||
|
||||
#endif // _testhypothesesgrow_h_
|
||||
@@ -1,220 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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*/
|
||||
|
||||
#if !defined CUDA_DISABLER
|
||||
|
||||
#include <math.h>
|
||||
#include "TestIntegralImage.h"
|
||||
|
||||
|
||||
template <class T_in, class T_out>
|
||||
TestIntegralImage<T_in, T_out>::TestIntegralImage(std::string testName_, NCVTestSourceProvider<T_in> &src_,
|
||||
Ncv32u width_, Ncv32u height_)
|
||||
:
|
||||
NCVTestProvider(testName_),
|
||||
src(src_),
|
||||
width(width_),
|
||||
height(height_)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
template <class T_in, class T_out>
|
||||
bool TestIntegralImage<T_in, T_out>::toString(std::ofstream &strOut)
|
||||
{
|
||||
strOut << "sizeof(T_in)=" << sizeof(T_in) << std::endl;
|
||||
strOut << "sizeof(T_out)=" << sizeof(T_out) << std::endl;
|
||||
strOut << "width=" << width << std::endl;
|
||||
strOut << "height=" << height << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
template <class T_in, class T_out>
|
||||
bool TestIntegralImage<T_in, T_out>::init()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
template <class T_in, class T_out>
|
||||
bool TestIntegralImage<T_in, T_out>::process()
|
||||
{
|
||||
NCVStatus ncvStat;
|
||||
bool rcode = false;
|
||||
|
||||
Ncv32u widthII = this->width + 1;
|
||||
Ncv32u heightII = this->height + 1;
|
||||
|
||||
NCVMatrixAlloc<T_in> d_img(*this->allocatorGPU.get(), this->width, this->height);
|
||||
ncvAssertReturn(d_img.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<T_in> h_img(*this->allocatorCPU.get(), this->width, this->height);
|
||||
ncvAssertReturn(h_img.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<T_out> d_imgII(*this->allocatorGPU.get(), widthII, heightII);
|
||||
ncvAssertReturn(d_imgII.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<T_out> h_imgII(*this->allocatorCPU.get(), widthII, heightII);
|
||||
ncvAssertReturn(h_imgII.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<T_out> h_imgII_d(*this->allocatorCPU.get(), widthII, heightII);
|
||||
ncvAssertReturn(h_imgII_d.isMemAllocated(), false);
|
||||
|
||||
Ncv32u bufSize;
|
||||
if (sizeof(T_in) == sizeof(Ncv8u))
|
||||
{
|
||||
ncvStat = nppiStIntegralGetSize_8u32u(NcvSize32u(this->width, this->height), &bufSize, this->devProp);
|
||||
ncvAssertReturn(NPPST_SUCCESS == ncvStat, false);
|
||||
}
|
||||
else if (sizeof(T_in) == sizeof(Ncv32f))
|
||||
{
|
||||
ncvStat = nppiStIntegralGetSize_32f32f(NcvSize32u(this->width, this->height), &bufSize, this->devProp);
|
||||
ncvAssertReturn(NPPST_SUCCESS == ncvStat, false);
|
||||
}
|
||||
else
|
||||
{
|
||||
ncvAssertPrintReturn(false, "Incorrect integral image test instance", false);
|
||||
}
|
||||
|
||||
NCVVectorAlloc<Ncv8u> d_tmpBuf(*this->allocatorGPU.get(), bufSize);
|
||||
ncvAssertReturn(d_tmpBuf.isMemAllocated(), false);
|
||||
|
||||
NCV_SET_SKIP_COND(this->allocatorGPU.get()->isCounting());
|
||||
NCV_SKIP_COND_BEGIN
|
||||
|
||||
ncvAssertReturn(this->src.fill(h_img), false);
|
||||
|
||||
ncvStat = h_img.copySolid(d_img, 0);
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
|
||||
if (sizeof(T_in) == sizeof(Ncv8u))
|
||||
{
|
||||
ncvStat = nppiStIntegral_8u32u_C1R((Ncv8u *)d_img.ptr(), d_img.pitch(),
|
||||
(Ncv32u *)d_imgII.ptr(), d_imgII.pitch(),
|
||||
NcvSize32u(this->width, this->height),
|
||||
d_tmpBuf.ptr(), bufSize, this->devProp);
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
}
|
||||
else if (sizeof(T_in) == sizeof(Ncv32f))
|
||||
{
|
||||
ncvStat = nppiStIntegral_32f32f_C1R((Ncv32f *)d_img.ptr(), d_img.pitch(),
|
||||
(Ncv32f *)d_imgII.ptr(), d_imgII.pitch(),
|
||||
NcvSize32u(this->width, this->height),
|
||||
d_tmpBuf.ptr(), bufSize, this->devProp);
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
}
|
||||
else
|
||||
{
|
||||
ncvAssertPrintReturn(false, "Incorrect integral image test instance", false);
|
||||
}
|
||||
|
||||
ncvStat = d_imgII.copySolid(h_imgII_d, 0);
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
|
||||
if (sizeof(T_in) == sizeof(Ncv8u))
|
||||
{
|
||||
ncvStat = nppiStIntegral_8u32u_C1R_host((Ncv8u *)h_img.ptr(), h_img.pitch(),
|
||||
(Ncv32u *)h_imgII.ptr(), h_imgII.pitch(),
|
||||
NcvSize32u(this->width, this->height));
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
}
|
||||
else if (sizeof(T_in) == sizeof(Ncv32f))
|
||||
{
|
||||
ncvStat = nppiStIntegral_32f32f_C1R_host((Ncv32f *)h_img.ptr(), h_img.pitch(),
|
||||
(Ncv32f *)h_imgII.ptr(), h_imgII.pitch(),
|
||||
NcvSize32u(this->width, this->height));
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
}
|
||||
else
|
||||
{
|
||||
ncvAssertPrintReturn(false, "Incorrect integral image test instance", false);
|
||||
}
|
||||
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
//bit-to-bit check
|
||||
bool bLoopVirgin = true;
|
||||
|
||||
NCV_SKIP_COND_BEGIN
|
||||
for (Ncv32u i=0; bLoopVirgin && i < h_img.height() + 1; i++)
|
||||
{
|
||||
for (Ncv32u j=0; bLoopVirgin && j < h_img.width() + 1; j++)
|
||||
{
|
||||
if (sizeof(T_in) == sizeof(Ncv8u))
|
||||
{
|
||||
if (h_imgII.ptr()[h_imgII.stride()*i+j] != h_imgII_d.ptr()[h_imgII_d.stride()*i+j])
|
||||
{
|
||||
bLoopVirgin = false;
|
||||
}
|
||||
}
|
||||
else if (sizeof(T_in) == sizeof(Ncv32f))
|
||||
{
|
||||
if (fabsf((float)h_imgII.ptr()[h_imgII.stride()*i+j] - (float)h_imgII_d.ptr()[h_imgII_d.stride()*i+j]) > 0.01f)
|
||||
{
|
||||
bLoopVirgin = false;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ncvAssertPrintReturn(false, "Incorrect integral image test instance", false);
|
||||
}
|
||||
}
|
||||
}
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
if (bLoopVirgin)
|
||||
{
|
||||
rcode = true;
|
||||
}
|
||||
|
||||
return rcode;
|
||||
}
|
||||
|
||||
|
||||
template <class T_in, class T_out>
|
||||
bool TestIntegralImage<T_in, T_out>::deinit()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
template class TestIntegralImage<Ncv8u, Ncv32u>;
|
||||
template class TestIntegralImage<Ncv32f, Ncv32f>;
|
||||
|
||||
#endif /* CUDA_DISABLER */
|
||||
@@ -1,72 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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 _testintegralimage_h_
|
||||
#define _testintegralimage_h_
|
||||
|
||||
#include "NCVTest.hpp"
|
||||
#include "NCVTestSourceProvider.hpp"
|
||||
|
||||
|
||||
template <class T_in, class T_out>
|
||||
class TestIntegralImage : public NCVTestProvider
|
||||
{
|
||||
public:
|
||||
|
||||
TestIntegralImage(std::string testName, NCVTestSourceProvider<T_in> &src,
|
||||
Ncv32u width, Ncv32u height);
|
||||
|
||||
virtual bool init();
|
||||
virtual bool process();
|
||||
virtual bool deinit();
|
||||
virtual bool toString(std::ofstream &strOut);
|
||||
|
||||
private:
|
||||
TestIntegralImage(const TestIntegralImage&);
|
||||
TestIntegralImage& operator=(const TestIntegralImage&);
|
||||
|
||||
NCVTestSourceProvider<T_in> &src;
|
||||
Ncv32u width;
|
||||
Ncv32u height;
|
||||
};
|
||||
|
||||
#endif // _testintegralimage_h_
|
||||
@@ -1,152 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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*/
|
||||
|
||||
#if !defined CUDA_DISABLER
|
||||
|
||||
#include "TestIntegralImageSquared.h"
|
||||
|
||||
|
||||
TestIntegralImageSquared::TestIntegralImageSquared(std::string testName_, NCVTestSourceProvider<Ncv8u> &src_,
|
||||
Ncv32u width_, Ncv32u height_)
|
||||
:
|
||||
NCVTestProvider(testName_),
|
||||
src(src_),
|
||||
width(width_),
|
||||
height(height_)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
bool TestIntegralImageSquared::toString(std::ofstream &strOut)
|
||||
{
|
||||
strOut << "width=" << width << std::endl;
|
||||
strOut << "height=" << height << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool TestIntegralImageSquared::init()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool TestIntegralImageSquared::process()
|
||||
{
|
||||
NCVStatus ncvStat;
|
||||
bool rcode = false;
|
||||
|
||||
Ncv32u widthSII = this->width + 1;
|
||||
Ncv32u heightSII = this->height + 1;
|
||||
|
||||
NCVMatrixAlloc<Ncv8u> d_img(*this->allocatorGPU.get(), this->width, this->height);
|
||||
ncvAssertReturn(d_img.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<Ncv8u> h_img(*this->allocatorCPU.get(), this->width, this->height);
|
||||
ncvAssertReturn(h_img.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<Ncv64u> d_imgSII(*this->allocatorGPU.get(), widthSII, heightSII);
|
||||
ncvAssertReturn(d_imgSII.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<Ncv64u> h_imgSII(*this->allocatorCPU.get(), widthSII, heightSII);
|
||||
ncvAssertReturn(h_imgSII.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<Ncv64u> h_imgSII_d(*this->allocatorCPU.get(), widthSII, heightSII);
|
||||
ncvAssertReturn(h_imgSII_d.isMemAllocated(), false);
|
||||
|
||||
Ncv32u bufSize;
|
||||
ncvStat = nppiStSqrIntegralGetSize_8u64u(NcvSize32u(this->width, this->height), &bufSize, this->devProp);
|
||||
ncvAssertReturn(NPPST_SUCCESS == ncvStat, false);
|
||||
NCVVectorAlloc<Ncv8u> d_tmpBuf(*this->allocatorGPU.get(), bufSize);
|
||||
ncvAssertReturn(d_tmpBuf.isMemAllocated(), false);
|
||||
|
||||
NCV_SET_SKIP_COND(this->allocatorGPU.get()->isCounting());
|
||||
NCV_SKIP_COND_BEGIN
|
||||
|
||||
ncvAssertReturn(this->src.fill(h_img), false);
|
||||
|
||||
ncvStat = h_img.copySolid(d_img, 0);
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
|
||||
ncvStat = nppiStSqrIntegral_8u64u_C1R(d_img.ptr(), d_img.pitch(),
|
||||
d_imgSII.ptr(), d_imgSII.pitch(),
|
||||
NcvSize32u(this->width, this->height),
|
||||
d_tmpBuf.ptr(), bufSize, this->devProp);
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
|
||||
ncvStat = d_imgSII.copySolid(h_imgSII_d, 0);
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
|
||||
ncvStat = nppiStSqrIntegral_8u64u_C1R_host(h_img.ptr(), h_img.pitch(),
|
||||
h_imgSII.ptr(), h_imgSII.pitch(),
|
||||
NcvSize32u(this->width, this->height));
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
//bit-to-bit check
|
||||
bool bLoopVirgin = true;
|
||||
|
||||
NCV_SKIP_COND_BEGIN
|
||||
for (Ncv32u i=0; bLoopVirgin && i < h_img.height() + 1; i++)
|
||||
{
|
||||
for (Ncv32u j=0; bLoopVirgin && j < h_img.width() + 1; j++)
|
||||
{
|
||||
if (h_imgSII.ptr()[h_imgSII.stride()*i+j] != h_imgSII_d.ptr()[h_imgSII_d.stride()*i+j])
|
||||
{
|
||||
bLoopVirgin = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
if (bLoopVirgin)
|
||||
{
|
||||
rcode = true;
|
||||
}
|
||||
|
||||
return rcode;
|
||||
}
|
||||
|
||||
|
||||
bool TestIntegralImageSquared::deinit()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
#endif /* CUDA_DISABLER */
|
||||
@@ -1,71 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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 _testintegralimagesquared_h_
|
||||
#define _testintegralimagesquared_h_
|
||||
|
||||
#include "NCVTest.hpp"
|
||||
#include "NCVTestSourceProvider.hpp"
|
||||
|
||||
|
||||
class TestIntegralImageSquared : public NCVTestProvider
|
||||
{
|
||||
public:
|
||||
|
||||
TestIntegralImageSquared(std::string testName, NCVTestSourceProvider<Ncv8u> &src,
|
||||
Ncv32u width, Ncv32u height);
|
||||
|
||||
virtual bool init();
|
||||
virtual bool process();
|
||||
virtual bool deinit();
|
||||
virtual bool toString(std::ofstream &strOut);
|
||||
|
||||
private:
|
||||
TestIntegralImageSquared(const TestIntegralImageSquared&);
|
||||
TestIntegralImageSquared& operator=(const TestIntegralImageSquared&);
|
||||
|
||||
NCVTestSourceProvider<Ncv8u> &src;
|
||||
Ncv32u width;
|
||||
Ncv32u height;
|
||||
};
|
||||
|
||||
#endif // _testintegralimagesquared_h_
|
||||
@@ -1,215 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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*/
|
||||
|
||||
#if !defined CUDA_DISABLER
|
||||
|
||||
#include <math.h>
|
||||
|
||||
#include "TestRectStdDev.h"
|
||||
|
||||
|
||||
TestRectStdDev::TestRectStdDev(std::string testName_, NCVTestSourceProvider<Ncv8u> &src_,
|
||||
Ncv32u width_, Ncv32u height_, NcvRect32u rect_, Ncv32f scaleFactor_,
|
||||
NcvBool bTextureCache_)
|
||||
:
|
||||
NCVTestProvider(testName_),
|
||||
src(src_),
|
||||
width(width_),
|
||||
height(height_),
|
||||
rect(rect_),
|
||||
scaleFactor(scaleFactor_),
|
||||
bTextureCache(bTextureCache_)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
bool TestRectStdDev::toString(std::ofstream &strOut)
|
||||
{
|
||||
strOut << "width=" << width << std::endl;
|
||||
strOut << "height=" << height << std::endl;
|
||||
strOut << "rect=[" << rect.x << ", " << rect.y << ", " << rect.width << ", " << rect.height << "]\n";
|
||||
strOut << "scaleFactor=" << scaleFactor << std::endl;
|
||||
strOut << "bTextureCache=" << bTextureCache << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool TestRectStdDev::init()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool TestRectStdDev::process()
|
||||
{
|
||||
NCVStatus ncvStat;
|
||||
bool rcode = false;
|
||||
|
||||
Ncv32s _normWidth = (Ncv32s)this->width - this->rect.x - this->rect.width + 1;
|
||||
Ncv32s _normHeight = (Ncv32s)this->height - this->rect.y - this->rect.height + 1;
|
||||
if (_normWidth <= 0 || _normHeight <= 0)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
Ncv32u normWidth = (Ncv32u)_normWidth;
|
||||
Ncv32u normHeight = (Ncv32u)_normHeight;
|
||||
NcvSize32u szNormRoi(normWidth, normHeight);
|
||||
|
||||
Ncv32u widthII = this->width + 1;
|
||||
Ncv32u heightII = this->height + 1;
|
||||
Ncv32u widthSII = this->width + 1;
|
||||
Ncv32u heightSII = this->height + 1;
|
||||
|
||||
NCVMatrixAlloc<Ncv8u> d_img(*this->allocatorGPU.get(), this->width, this->height);
|
||||
ncvAssertReturn(d_img.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<Ncv8u> h_img(*this->allocatorCPU.get(), this->width, this->height);
|
||||
ncvAssertReturn(h_img.isMemAllocated(), false);
|
||||
|
||||
NCVMatrixAlloc<Ncv32u> d_imgII(*this->allocatorGPU.get(), widthII, heightII);
|
||||
ncvAssertReturn(d_imgII.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<Ncv32u> h_imgII(*this->allocatorCPU.get(), widthII, heightII);
|
||||
ncvAssertReturn(h_imgII.isMemAllocated(), false);
|
||||
|
||||
NCVMatrixAlloc<Ncv64u> d_imgSII(*this->allocatorGPU.get(), widthSII, heightSII);
|
||||
ncvAssertReturn(d_imgSII.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<Ncv64u> h_imgSII(*this->allocatorCPU.get(), widthSII, heightSII);
|
||||
ncvAssertReturn(h_imgSII.isMemAllocated(), false);
|
||||
|
||||
NCVMatrixAlloc<Ncv32f> d_norm(*this->allocatorGPU.get(), normWidth, normHeight);
|
||||
ncvAssertReturn(d_norm.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<Ncv32f> h_norm(*this->allocatorCPU.get(), normWidth, normHeight);
|
||||
ncvAssertReturn(h_norm.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<Ncv32f> h_norm_d(*this->allocatorCPU.get(), normWidth, normHeight);
|
||||
ncvAssertReturn(h_norm_d.isMemAllocated(), false);
|
||||
|
||||
Ncv32u bufSizeII, bufSizeSII;
|
||||
ncvStat = nppiStIntegralGetSize_8u32u(NcvSize32u(this->width, this->height), &bufSizeII, this->devProp);
|
||||
ncvAssertReturn(NPPST_SUCCESS == ncvStat, false);
|
||||
ncvStat = nppiStSqrIntegralGetSize_8u64u(NcvSize32u(this->width, this->height), &bufSizeSII, this->devProp);
|
||||
ncvAssertReturn(NPPST_SUCCESS == ncvStat, false);
|
||||
Ncv32u bufSize = bufSizeII > bufSizeSII ? bufSizeII : bufSizeSII;
|
||||
NCVVectorAlloc<Ncv8u> d_tmpBuf(*this->allocatorGPU.get(), bufSize);
|
||||
ncvAssertReturn(d_tmpBuf.isMemAllocated(), false);
|
||||
|
||||
NCV_SET_SKIP_COND(this->allocatorGPU.get()->isCounting());
|
||||
NCV_SKIP_COND_BEGIN
|
||||
ncvAssertReturn(this->src.fill(h_img), false);
|
||||
|
||||
ncvStat = h_img.copySolid(d_img, 0);
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
|
||||
ncvStat = nppiStIntegral_8u32u_C1R(d_img.ptr(), d_img.pitch(),
|
||||
d_imgII.ptr(), d_imgII.pitch(),
|
||||
NcvSize32u(this->width, this->height),
|
||||
d_tmpBuf.ptr(), bufSize, this->devProp);
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
|
||||
ncvStat = nppiStSqrIntegral_8u64u_C1R(d_img.ptr(), d_img.pitch(),
|
||||
d_imgSII.ptr(), d_imgSII.pitch(),
|
||||
NcvSize32u(this->width, this->height),
|
||||
d_tmpBuf.ptr(), bufSize, this->devProp);
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
|
||||
ncvStat = nppiStRectStdDev_32f_C1R(d_imgII.ptr(), d_imgII.pitch(),
|
||||
d_imgSII.ptr(), d_imgSII.pitch(),
|
||||
d_norm.ptr(), d_norm.pitch(),
|
||||
szNormRoi, this->rect,
|
||||
this->scaleFactor,
|
||||
this->bTextureCache);
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
|
||||
ncvStat = d_norm.copySolid(h_norm_d, 0);
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
|
||||
ncvStat = nppiStIntegral_8u32u_C1R_host(h_img.ptr(), h_img.pitch(),
|
||||
h_imgII.ptr(), h_imgII.pitch(),
|
||||
NcvSize32u(this->width, this->height));
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
|
||||
ncvStat = nppiStSqrIntegral_8u64u_C1R_host(h_img.ptr(), h_img.pitch(),
|
||||
h_imgSII.ptr(), h_imgSII.pitch(),
|
||||
NcvSize32u(this->width, this->height));
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
|
||||
ncvStat = nppiStRectStdDev_32f_C1R_host(h_imgII.ptr(), h_imgII.pitch(),
|
||||
h_imgSII.ptr(), h_imgSII.pitch(),
|
||||
h_norm.ptr(), h_norm.pitch(),
|
||||
szNormRoi, this->rect,
|
||||
this->scaleFactor);
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
//bit-to-bit check
|
||||
bool bLoopVirgin = true;
|
||||
|
||||
NCV_SKIP_COND_BEGIN
|
||||
const Ncv64f relEPS = 0.005;
|
||||
for (Ncv32u i=0; bLoopVirgin && i < h_norm.height(); i++)
|
||||
{
|
||||
for (Ncv32u j=0; bLoopVirgin && j < h_norm.width(); j++)
|
||||
{
|
||||
Ncv64f absErr = fabs(h_norm.ptr()[h_norm.stride()*i+j] - h_norm_d.ptr()[h_norm_d.stride()*i+j]);
|
||||
Ncv64f relErr = absErr / h_norm.ptr()[h_norm.stride()*i+j];
|
||||
|
||||
if (relErr > relEPS)
|
||||
{
|
||||
bLoopVirgin = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
if (bLoopVirgin)
|
||||
{
|
||||
rcode = true;
|
||||
}
|
||||
|
||||
return rcode;
|
||||
}
|
||||
|
||||
|
||||
bool TestRectStdDev::deinit()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
#endif /* CUDA_DISABLER */
|
||||
@@ -1,76 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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 _testrectstddev_h_
|
||||
#define _testrectstddev_h_
|
||||
|
||||
#include "NCVTest.hpp"
|
||||
#include "NCVTestSourceProvider.hpp"
|
||||
|
||||
|
||||
class TestRectStdDev : public NCVTestProvider
|
||||
{
|
||||
public:
|
||||
|
||||
TestRectStdDev(std::string testName, NCVTestSourceProvider<Ncv8u> &src,
|
||||
Ncv32u width, Ncv32u height, NcvRect32u rect, Ncv32f scaleFactor,
|
||||
NcvBool bTextureCache);
|
||||
|
||||
virtual bool init();
|
||||
virtual bool process();
|
||||
virtual bool deinit();
|
||||
virtual bool toString(std::ofstream &strOut);
|
||||
|
||||
private:
|
||||
TestRectStdDev(const TestRectStdDev&);
|
||||
TestRectStdDev& operator=(const TestRectStdDev&);
|
||||
|
||||
NCVTestSourceProvider<Ncv8u> &src;
|
||||
Ncv32u width;
|
||||
Ncv32u height;
|
||||
NcvRect32u rect;
|
||||
Ncv32f scaleFactor;
|
||||
|
||||
NcvBool bTextureCache;
|
||||
};
|
||||
|
||||
#endif // _testrectstddev_h_
|
||||
@@ -1,196 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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*/
|
||||
|
||||
#if !defined CUDA_DISABLER
|
||||
|
||||
#include <math.h>
|
||||
|
||||
#include "TestResize.h"
|
||||
|
||||
|
||||
template <class T>
|
||||
TestResize<T>::TestResize(std::string testName_, NCVTestSourceProvider<T> &src_,
|
||||
Ncv32u width_, Ncv32u height_, Ncv32u scaleFactor_, NcvBool bTextureCache_)
|
||||
:
|
||||
NCVTestProvider(testName_),
|
||||
src(src_),
|
||||
width(width_),
|
||||
height(height_),
|
||||
scaleFactor(scaleFactor_),
|
||||
bTextureCache(bTextureCache_)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
bool TestResize<T>::toString(std::ofstream &strOut)
|
||||
{
|
||||
strOut << "sizeof(T)=" << sizeof(T) << std::endl;
|
||||
strOut << "width=" << width << std::endl;
|
||||
strOut << "scaleFactor=" << scaleFactor << std::endl;
|
||||
strOut << "bTextureCache=" << bTextureCache << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
bool TestResize<T>::init()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
bool TestResize<T>::process()
|
||||
{
|
||||
NCVStatus ncvStat;
|
||||
bool rcode = false;
|
||||
|
||||
Ncv32s smallWidth = this->width / this->scaleFactor;
|
||||
Ncv32s smallHeight = this->height / this->scaleFactor;
|
||||
if (smallWidth == 0 || smallHeight == 0)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
NcvSize32u srcSize(this->width, this->height);
|
||||
|
||||
NCVMatrixAlloc<T> d_img(*this->allocatorGPU.get(), this->width, this->height);
|
||||
ncvAssertReturn(d_img.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<T> h_img(*this->allocatorCPU.get(), this->width, this->height);
|
||||
ncvAssertReturn(h_img.isMemAllocated(), false);
|
||||
|
||||
NCVMatrixAlloc<T> d_small(*this->allocatorGPU.get(), smallWidth, smallHeight);
|
||||
ncvAssertReturn(d_small.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<T> h_small(*this->allocatorCPU.get(), smallWidth, smallHeight);
|
||||
ncvAssertReturn(h_small.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<T> h_small_d(*this->allocatorCPU.get(), smallWidth, smallHeight);
|
||||
ncvAssertReturn(h_small_d.isMemAllocated(), false);
|
||||
|
||||
NCV_SET_SKIP_COND(this->allocatorGPU.get()->isCounting());
|
||||
NCV_SKIP_COND_BEGIN
|
||||
ncvAssertReturn(this->src.fill(h_img), false);
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
ncvStat = h_img.copySolid(d_img, 0);
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
NCV_SKIP_COND_BEGIN
|
||||
if (sizeof(T) == sizeof(Ncv32u))
|
||||
{
|
||||
ncvStat = nppiStDecimate_32u_C1R((Ncv32u *)d_img.ptr(), d_img.pitch(),
|
||||
(Ncv32u *)d_small.ptr(), d_small.pitch(),
|
||||
srcSize, this->scaleFactor,
|
||||
this->bTextureCache);
|
||||
}
|
||||
else if (sizeof(T) == sizeof(Ncv64u))
|
||||
{
|
||||
ncvStat = nppiStDecimate_64u_C1R((Ncv64u *)d_img.ptr(), d_img.pitch(),
|
||||
(Ncv64u *)d_small.ptr(), d_small.pitch(),
|
||||
srcSize, this->scaleFactor,
|
||||
this->bTextureCache);
|
||||
}
|
||||
else
|
||||
{
|
||||
ncvAssertPrintReturn(false, "Incorrect downsample test instance", false);
|
||||
}
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
NCV_SKIP_COND_END
|
||||
ncvStat = d_small.copySolid(h_small_d, 0);
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
|
||||
NCV_SKIP_COND_BEGIN
|
||||
if (sizeof(T) == sizeof(Ncv32u))
|
||||
{
|
||||
ncvStat = nppiStDecimate_32u_C1R_host((Ncv32u *)h_img.ptr(), h_img.pitch(),
|
||||
(Ncv32u *)h_small.ptr(), h_small.pitch(),
|
||||
srcSize, this->scaleFactor);
|
||||
}
|
||||
else if (sizeof(T) == sizeof(Ncv64u))
|
||||
{
|
||||
ncvStat = nppiStDecimate_64u_C1R_host((Ncv64u *)h_img.ptr(), h_img.pitch(),
|
||||
(Ncv64u *)h_small.ptr(), h_small.pitch(),
|
||||
srcSize, this->scaleFactor);
|
||||
}
|
||||
else
|
||||
{
|
||||
ncvAssertPrintReturn(false, "Incorrect downsample test instance", false);
|
||||
}
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
//bit-to-bit check
|
||||
bool bLoopVirgin = true;
|
||||
|
||||
NCV_SKIP_COND_BEGIN
|
||||
//const Ncv64f relEPS = 0.005;
|
||||
for (Ncv32u i=0; bLoopVirgin && i < h_small.height(); i++)
|
||||
{
|
||||
for (Ncv32u j=0; bLoopVirgin && j < h_small.width(); j++)
|
||||
{
|
||||
if (h_small.ptr()[h_small.stride()*i+j] != h_small_d.ptr()[h_small_d.stride()*i+j])
|
||||
{
|
||||
bLoopVirgin = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
if (bLoopVirgin)
|
||||
{
|
||||
rcode = true;
|
||||
}
|
||||
|
||||
return rcode;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
bool TestResize<T>::deinit()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
template class TestResize<Ncv32u>;
|
||||
template class TestResize<Ncv64u>;
|
||||
|
||||
#endif /* CUDA_DISABLER */
|
||||
@@ -1,74 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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 _testresize_h_
|
||||
#define _testresize_h_
|
||||
|
||||
#include "NCVTest.hpp"
|
||||
#include "NCVTestSourceProvider.hpp"
|
||||
|
||||
template <class T>
|
||||
class TestResize : public NCVTestProvider
|
||||
{
|
||||
public:
|
||||
|
||||
TestResize(std::string testName, NCVTestSourceProvider<T> &src,
|
||||
Ncv32u width, Ncv32u height, Ncv32u scaleFactor, NcvBool bTextureCache);
|
||||
|
||||
virtual bool init();
|
||||
virtual bool process();
|
||||
virtual bool deinit();
|
||||
virtual bool toString(std::ofstream &strOut);
|
||||
|
||||
private:
|
||||
TestResize(const TestResize&);
|
||||
TestResize& operator=(const TestResize&);
|
||||
|
||||
NCVTestSourceProvider<T> &src;
|
||||
Ncv32u width;
|
||||
Ncv32u height;
|
||||
Ncv32u scaleFactor;
|
||||
|
||||
NcvBool bTextureCache;
|
||||
};
|
||||
|
||||
#endif // _testresize_h_
|
||||
@@ -1,183 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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*/
|
||||
|
||||
#if !defined CUDA_DISABLER
|
||||
|
||||
#include <math.h>
|
||||
|
||||
#include "TestTranspose.h"
|
||||
|
||||
|
||||
template <class T>
|
||||
TestTranspose<T>::TestTranspose(std::string testName_, NCVTestSourceProvider<T> &src_,
|
||||
Ncv32u width_, Ncv32u height_)
|
||||
:
|
||||
NCVTestProvider(testName_),
|
||||
src(src_),
|
||||
width(width_),
|
||||
height(height_)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
bool TestTranspose<T>::toString(std::ofstream &strOut)
|
||||
{
|
||||
strOut << "sizeof(T)=" << sizeof(T) << std::endl;
|
||||
strOut << "width=" << width << std::endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
bool TestTranspose<T>::init()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
bool TestTranspose<T>::process()
|
||||
{
|
||||
NCVStatus ncvStat;
|
||||
bool rcode = false;
|
||||
|
||||
NcvSize32u srcSize(this->width, this->height);
|
||||
|
||||
NCVMatrixAlloc<T> d_img(*this->allocatorGPU.get(), this->width, this->height);
|
||||
ncvAssertReturn(d_img.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<T> h_img(*this->allocatorCPU.get(), this->width, this->height);
|
||||
ncvAssertReturn(h_img.isMemAllocated(), false);
|
||||
|
||||
NCVMatrixAlloc<T> d_dst(*this->allocatorGPU.get(), this->height, this->width);
|
||||
ncvAssertReturn(d_dst.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<T> h_dst(*this->allocatorCPU.get(), this->height, this->width);
|
||||
ncvAssertReturn(h_dst.isMemAllocated(), false);
|
||||
NCVMatrixAlloc<T> h_dst_d(*this->allocatorCPU.get(), this->height, this->width);
|
||||
ncvAssertReturn(h_dst_d.isMemAllocated(), false);
|
||||
|
||||
NCV_SET_SKIP_COND(this->allocatorGPU.get()->isCounting());
|
||||
NCV_SKIP_COND_BEGIN
|
||||
ncvAssertReturn(this->src.fill(h_img), false);
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
ncvStat = h_img.copySolid(d_img, 0);
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
NCV_SKIP_COND_BEGIN
|
||||
if (sizeof(T) == sizeof(Ncv32u))
|
||||
{
|
||||
ncvStat = nppiStTranspose_32u_C1R((Ncv32u *)d_img.ptr(), d_img.pitch(),
|
||||
(Ncv32u *)d_dst.ptr(), d_dst.pitch(),
|
||||
NcvSize32u(this->width, this->height));
|
||||
}
|
||||
else if (sizeof(T) == sizeof(Ncv64u))
|
||||
{
|
||||
ncvStat = nppiStTranspose_64u_C1R((Ncv64u *)d_img.ptr(), d_img.pitch(),
|
||||
(Ncv64u *)d_dst.ptr(), d_dst.pitch(),
|
||||
NcvSize32u(this->width, this->height));
|
||||
}
|
||||
else
|
||||
{
|
||||
ncvAssertPrintReturn(false, "Incorrect transpose test instance", false);
|
||||
}
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
NCV_SKIP_COND_END
|
||||
ncvStat = d_dst.copySolid(h_dst_d, 0);
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
|
||||
NCV_SKIP_COND_BEGIN
|
||||
if (sizeof(T) == sizeof(Ncv32u))
|
||||
{
|
||||
ncvStat = nppiStTranspose_32u_C1R_host((Ncv32u *)h_img.ptr(), h_img.pitch(),
|
||||
(Ncv32u *)h_dst.ptr(), h_dst.pitch(),
|
||||
NcvSize32u(this->width, this->height));
|
||||
}
|
||||
else if (sizeof(T) == sizeof(Ncv64u))
|
||||
{
|
||||
ncvStat = nppiStTranspose_64u_C1R_host((Ncv64u *)h_img.ptr(), h_img.pitch(),
|
||||
(Ncv64u *)h_dst.ptr(), h_dst.pitch(),
|
||||
NcvSize32u(this->width, this->height));
|
||||
}
|
||||
else
|
||||
{
|
||||
ncvAssertPrintReturn(false, "Incorrect downsample test instance", false);
|
||||
}
|
||||
ncvAssertReturn(ncvStat == NPPST_SUCCESS, false);
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
//bit-to-bit check
|
||||
bool bLoopVirgin = true;
|
||||
|
||||
NCV_SKIP_COND_BEGIN
|
||||
//const Ncv64f relEPS = 0.005;
|
||||
for (Ncv32u i=0; bLoopVirgin && i < this->width; i++)
|
||||
{
|
||||
for (Ncv32u j=0; bLoopVirgin && j < this->height; j++)
|
||||
{
|
||||
if (h_dst.ptr()[h_dst.stride()*i+j] != h_dst_d.ptr()[h_dst_d.stride()*i+j])
|
||||
{
|
||||
bLoopVirgin = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
NCV_SKIP_COND_END
|
||||
|
||||
if (bLoopVirgin)
|
||||
{
|
||||
rcode = true;
|
||||
}
|
||||
|
||||
return rcode;
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
bool TestTranspose<T>::deinit()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
template class TestTranspose<Ncv32u>;
|
||||
template class TestTranspose<Ncv64u>;
|
||||
|
||||
#endif /* CUDA_DISABLER */
|
||||
@@ -1,73 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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 _testtranspose_h_
|
||||
#define _testtranspose_h_
|
||||
|
||||
#include "NCVTest.hpp"
|
||||
#include "NCVTestSourceProvider.hpp"
|
||||
|
||||
|
||||
template <class T>
|
||||
class TestTranspose : public NCVTestProvider
|
||||
{
|
||||
public:
|
||||
|
||||
TestTranspose(std::string testName, NCVTestSourceProvider<T> &src,
|
||||
Ncv32u width, Ncv32u height);
|
||||
|
||||
virtual bool init();
|
||||
virtual bool process();
|
||||
virtual bool deinit();
|
||||
virtual bool toString(std::ofstream &strOut);
|
||||
|
||||
private:
|
||||
|
||||
TestTranspose(const TestTranspose&);
|
||||
TestTranspose& operator=(const TestTranspose&);
|
||||
|
||||
NCVTestSourceProvider<T> &src;
|
||||
Ncv32u width;
|
||||
Ncv32u height;
|
||||
};
|
||||
|
||||
#endif // _testtranspose_h_
|
||||
@@ -1,484 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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*/
|
||||
|
||||
#if defined _MSC_VER && _MSC_VER >= 1200
|
||||
# pragma warning (disable : 4408 4201 4100)
|
||||
#endif
|
||||
|
||||
#if !defined CUDA_DISABLER
|
||||
|
||||
#include <cstdio>
|
||||
|
||||
#include "NCV.hpp"
|
||||
#include "NCVHaarObjectDetection.hpp"
|
||||
|
||||
#include "TestIntegralImage.h"
|
||||
#include "TestIntegralImageSquared.h"
|
||||
#include "TestRectStdDev.h"
|
||||
#include "TestResize.h"
|
||||
#include "TestCompact.h"
|
||||
#include "TestTranspose.h"
|
||||
|
||||
#include "TestDrawRects.h"
|
||||
#include "TestHypothesesGrow.h"
|
||||
#include "TestHypothesesFilter.h"
|
||||
#include "TestHaarCascadeLoader.h"
|
||||
#include "TestHaarCascadeApplication.h"
|
||||
|
||||
#include "NCVAutoTestLister.hpp"
|
||||
#include "NCVTestSourceProvider.hpp"
|
||||
|
||||
#include "main_test_nvidia.h"
|
||||
|
||||
static std::string path;
|
||||
|
||||
namespace {
|
||||
|
||||
template <class T_in, class T_out>
|
||||
void generateIntegralTests(NCVAutoTestLister &testLister,
|
||||
NCVTestSourceProvider<T_in> &src,
|
||||
Ncv32u maxWidth, Ncv32u maxHeight)
|
||||
{
|
||||
for (Ncv32f _i=1.0; _i<maxWidth; _i*=1.2f)
|
||||
{
|
||||
Ncv32u i = (Ncv32u)_i;
|
||||
char testName[80];
|
||||
sprintf(testName, "LinIntImgW%dH%d", i, 2);
|
||||
testLister.add(new TestIntegralImage<T_in, T_out>(testName, src, i, 2));
|
||||
}
|
||||
for (Ncv32f _i=1.0; _i<maxHeight; _i*=1.2f)
|
||||
{
|
||||
Ncv32u i = (Ncv32u)_i;
|
||||
char testName[80];
|
||||
sprintf(testName, "LinIntImgW%dH%d", 2, i);
|
||||
testLister.add(new TestIntegralImage<T_in, T_out>(testName, src, 2, i));
|
||||
}
|
||||
|
||||
testLister.add(new TestIntegralImage<T_in, T_out>("LinIntImg_VGA", src, 640, 480));
|
||||
}
|
||||
|
||||
void generateSquaredIntegralTests(NCVAutoTestLister &testLister, NCVTestSourceProvider<Ncv8u> &src,
|
||||
Ncv32u maxWidth, Ncv32u maxHeight)
|
||||
{
|
||||
for (Ncv32f _i=1.0; _i<maxWidth; _i*=1.2f)
|
||||
{
|
||||
Ncv32u i = (Ncv32u)_i;
|
||||
char testName[80];
|
||||
sprintf(testName, "SqIntImgW%dH%d", i, 32);
|
||||
testLister.add(new TestIntegralImageSquared(testName, src, i, 32));
|
||||
}
|
||||
for (Ncv32f _i=1.0; _i<maxHeight; _i*=1.2f)
|
||||
{
|
||||
Ncv32u i = (Ncv32u)_i;
|
||||
char testName[80];
|
||||
sprintf(testName, "SqIntImgW%dH%d", 32, i);
|
||||
testLister.add(new TestIntegralImageSquared(testName, src, 32, i));
|
||||
}
|
||||
|
||||
testLister.add(new TestIntegralImageSquared("SqLinIntImg_VGA", src, 640, 480));
|
||||
}
|
||||
|
||||
void generateRectStdDevTests(NCVAutoTestLister &testLister, NCVTestSourceProvider<Ncv8u> &src,
|
||||
Ncv32u maxWidth, Ncv32u maxHeight)
|
||||
{
|
||||
NcvRect32u rect(1,1,18,18);
|
||||
|
||||
for (Ncv32f _i=32; _i<maxHeight/2 && _i < maxWidth/2; _i*=1.2f)
|
||||
{
|
||||
Ncv32u i = (Ncv32u)_i;
|
||||
char testName[80];
|
||||
sprintf(testName, "RectStdDevW%dH%d", i*2, i);
|
||||
testLister.add(new TestRectStdDev(testName, src, i*2, i, rect, 1, true));
|
||||
testLister.add(new TestRectStdDev(testName, src, i*2, i, rect, 1.5, false));
|
||||
testLister.add(new TestRectStdDev(testName, src, i-1, i*2-1, rect, 1, false));
|
||||
testLister.add(new TestRectStdDev(testName, src, i-1, i*2-1, rect, 2.5, true));
|
||||
}
|
||||
|
||||
testLister.add(new TestRectStdDev("RectStdDev_VGA", src, 640, 480, rect, 1, true));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void generateResizeTests(NCVAutoTestLister &testLister, NCVTestSourceProvider<T> &src)
|
||||
{
|
||||
for (Ncv32u i=2; i<10; ++i)
|
||||
{
|
||||
char testName[80];
|
||||
sprintf(testName, "TestResize_VGA_s%d", i);
|
||||
testLister.add(new TestResize<T>(testName, src, 640, 480, i, true));
|
||||
testLister.add(new TestResize<T>(testName, src, 640, 480, i, false));
|
||||
}
|
||||
|
||||
for (Ncv32u i=2; i<10; ++i)
|
||||
{
|
||||
char testName[80];
|
||||
sprintf(testName, "TestResize_1080_s%d", i);
|
||||
testLister.add(new TestResize<T>(testName, src, 1920, 1080, i, true));
|
||||
testLister.add(new TestResize<T>(testName, src, 1920, 1080, i, false));
|
||||
}
|
||||
}
|
||||
|
||||
void generateNPPSTVectorTests(NCVAutoTestLister &testLister, NCVTestSourceProvider<Ncv32u> &src, Ncv32u maxLength)
|
||||
{
|
||||
//compaction
|
||||
for (Ncv32f _i=256.0; _i<maxLength; _i*=1.5f)
|
||||
{
|
||||
Ncv32u i = (Ncv32u)_i;
|
||||
char testName[80];
|
||||
sprintf(testName, "Compaction%d", i);
|
||||
testLister.add(new TestCompact(testName, src, i, 0xFFFFFFFF, 30));
|
||||
}
|
||||
for (Ncv32u i=1; i<260; i++)
|
||||
{
|
||||
char testName[80];
|
||||
sprintf(testName, "Compaction%d", i);
|
||||
testLister.add(new TestCompact(testName, src, i, 0xC001C0DE, 70));
|
||||
testLister.add(new TestCompact(testName, src, i, 0xC001C0DE, 0));
|
||||
testLister.add(new TestCompact(testName, src, i, 0xC001C0DE, 100));
|
||||
}
|
||||
for (Ncv32u i=256*256-10; i<256*256+10; i++)
|
||||
{
|
||||
char testName[80];
|
||||
sprintf(testName, "Compaction%d", i);
|
||||
testLister.add(new TestCompact(testName, src, i, 0xFFFFFFFF, 40));
|
||||
}
|
||||
for (Ncv32u i=256*256*256-2; i<256*256*256+2; i++)
|
||||
{
|
||||
char testName[80];
|
||||
sprintf(testName, "Compaction%d", i);
|
||||
testLister.add(new TestCompact(testName, src, i, 0x00000000, 2));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
void generateTransposeTests(NCVAutoTestLister &testLister, NCVTestSourceProvider<T> &src)
|
||||
{
|
||||
for (int i=2; i<64; i+=4)
|
||||
{
|
||||
for (int j=2; j<64; j+=4)
|
||||
{
|
||||
char testName[80];
|
||||
sprintf(testName, "TestTranspose_%dx%d", i, j);
|
||||
testLister.add(new TestTranspose<T>(testName, src, i, j));
|
||||
}
|
||||
}
|
||||
|
||||
for (int i=1; i<128; i+=1)
|
||||
{
|
||||
for (int j=1; j<2; j+=1)
|
||||
{
|
||||
char testName[80];
|
||||
sprintf(testName, "TestTranspose_%dx%d", i, j);
|
||||
testLister.add(new TestTranspose<T>(testName, src, i, j));
|
||||
}
|
||||
}
|
||||
|
||||
testLister.add(new TestTranspose<T>("TestTranspose_VGA", src, 640, 480));
|
||||
testLister.add(new TestTranspose<T>("TestTranspose_HD1080", src, 1920, 1080));
|
||||
|
||||
//regression tests
|
||||
testLister.add(new TestTranspose<T>("TestTranspose_reg_0", src, 1072, 375));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
void generateDrawRectsTests(NCVAutoTestLister &testLister,
|
||||
NCVTestSourceProvider<T> &src,
|
||||
NCVTestSourceProvider<Ncv32u> &src32u,
|
||||
Ncv32u maxWidth, Ncv32u maxHeight)
|
||||
{
|
||||
for (Ncv32f _i=16.0; _i<maxWidth; _i*=1.1f)
|
||||
{
|
||||
Ncv32u i = (Ncv32u)_i;
|
||||
Ncv32u j = maxHeight * i / maxWidth;
|
||||
if (!j) continue;
|
||||
char testName[80];
|
||||
sprintf(testName, "DrawRectsW%dH%d", i, j);
|
||||
|
||||
if (sizeof(T) == sizeof(Ncv32u))
|
||||
{
|
||||
testLister.add(new TestDrawRects<T>(testName, src, src32u, i, j, i*j/1000+1, (T)0xFFFFFFFF));
|
||||
}
|
||||
else if (sizeof(T) == sizeof(Ncv8u))
|
||||
{
|
||||
testLister.add(new TestDrawRects<T>(testName, src, src32u, i, j, i*j/1000+1, (T)0xFF));
|
||||
}
|
||||
else
|
||||
{
|
||||
ncvAssertPrintCheck(false, "Attempted to instantiate non-existing DrawRects test suite");
|
||||
}
|
||||
}
|
||||
|
||||
//test VGA
|
||||
testLister.add(new TestDrawRects<T>("DrawRects_VGA", src, src32u, 640, 480, 640*480/1000, (T)0xFF));
|
||||
}
|
||||
|
||||
void generateVectorTests(NCVAutoTestLister &testLister, NCVTestSourceProvider<Ncv32u> &src, Ncv32u maxLength)
|
||||
{
|
||||
//growth
|
||||
for (Ncv32f _i=10.0; _i<maxLength; _i*=1.5f)
|
||||
{
|
||||
Ncv32u i = (Ncv32u)_i;
|
||||
char testName[80];
|
||||
sprintf(testName, "VectorGrow%d", i);
|
||||
testLister.add(new TestHypothesesGrow(testName, src, 20, 20, 2.2f, i, i/2, i, i/4));
|
||||
testLister.add(new TestHypothesesGrow(testName, src, 10, 42, 1.2f, i, i, i, 0));
|
||||
}
|
||||
testLister.add(new TestHypothesesGrow("VectorGrow01b", src, 10, 42, 1.2f, 10, 0, 10, 1));
|
||||
testLister.add(new TestHypothesesGrow("VectorGrow11b", src, 10, 42, 1.2f, 10, 1, 10, 1));
|
||||
testLister.add(new TestHypothesesGrow("VectorGrow10b", src, 10, 42, 1.2f, 10, 1, 10, 0));
|
||||
testLister.add(new TestHypothesesGrow("VectorGrow00b", src, 10, 42, 1.2f, 10, 0, 10, 0));
|
||||
}
|
||||
|
||||
void generateHypothesesFiltrationTests(NCVAutoTestLister &testLister, NCVTestSourceProvider<Ncv32u> &src, Ncv32u maxLength)
|
||||
{
|
||||
for (Ncv32f _i=1.0; _i<maxLength; _i*=1.1f)
|
||||
{
|
||||
Ncv32u i = (Ncv32u)_i;
|
||||
char testName[80];
|
||||
sprintf(testName, "HypFilter%d", i);
|
||||
testLister.add(new TestHypothesesFilter(testName, src, i, 3, 0.2f));
|
||||
testLister.add(new TestHypothesesFilter(testName, src, i, 0, 0.2f));
|
||||
testLister.add(new TestHypothesesFilter(testName, src, i, 1, 0.1f));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void generateHaarLoaderTests(NCVAutoTestLister &testLister)
|
||||
{
|
||||
testLister.add(new TestHaarCascadeLoader("haarcascade_eye.xml", path + "haarcascade_eye.xml"));
|
||||
testLister.add(new TestHaarCascadeLoader("haarcascade_frontalface_alt.xml", path + "haarcascade_frontalface_alt.xml"));
|
||||
testLister.add(new TestHaarCascadeLoader("haarcascade_frontalface_alt2.xml", path + "haarcascade_frontalface_alt2.xml"));
|
||||
testLister.add(new TestHaarCascadeLoader("haarcascade_frontalface_alt_tree.xml", path + "haarcascade_frontalface_alt_tree.xml"));
|
||||
testLister.add(new TestHaarCascadeLoader("haarcascade_eye_tree_eyeglasses.xml", path + "haarcascade_eye_tree_eyeglasses.xml"));
|
||||
}
|
||||
|
||||
void generateHaarApplicationTests(NCVAutoTestLister &testLister, NCVTestSourceProvider<Ncv8u> &src,
|
||||
Ncv32u maxWidth, Ncv32u maxHeight)
|
||||
{
|
||||
(void)maxHeight;
|
||||
for (Ncv32u i=100; i<512; i+=41)
|
||||
{
|
||||
for (Ncv32u j=100; j<128; j+=25)
|
||||
{
|
||||
char testName[80];
|
||||
sprintf(testName, "HaarAppl%d_%d", i, j);
|
||||
testLister.add(new TestHaarCascadeApplication(testName, src, path + "haarcascade_frontalface_alt.xml", j, i));
|
||||
}
|
||||
}
|
||||
for (Ncv32f _i=20.0; _i<maxWidth; _i*=1.5f)
|
||||
{
|
||||
Ncv32u i = (Ncv32u)_i;
|
||||
char testName[80];
|
||||
sprintf(testName, "HaarAppl%d", i);
|
||||
testLister.add(new TestHaarCascadeApplication(testName, src, path + "haarcascade_frontalface_alt.xml", i, i));
|
||||
}
|
||||
}
|
||||
|
||||
static void devNullOutput(const cv::String& msg)
|
||||
{
|
||||
(void)msg;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
bool nvidia_NPPST_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel)
|
||||
{
|
||||
path = test_data_path.c_str();
|
||||
ncvSetDebugOutputHandler(devNullOutput);
|
||||
|
||||
NCVAutoTestLister testListerII("NPPST Integral Image", outputLevel);
|
||||
|
||||
NCVTestSourceProvider<Ncv8u> testSrcRandom_8u(2010, 0, 255, 2048, 2048);
|
||||
NCVTestSourceProvider<Ncv32f> testSrcRandom_32f(2010, -1.0f, 1.0f, 2048, 2048);
|
||||
|
||||
generateIntegralTests<Ncv8u, Ncv32u>(testListerII, testSrcRandom_8u, 2048, 2048);
|
||||
generateIntegralTests<Ncv32f, Ncv32f>(testListerII, testSrcRandom_32f, 2048, 2048);
|
||||
|
||||
return testListerII.invoke();
|
||||
}
|
||||
|
||||
bool nvidia_NPPST_Squared_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel)
|
||||
{
|
||||
path = test_data_path;
|
||||
ncvSetDebugOutputHandler(devNullOutput);
|
||||
|
||||
NCVAutoTestLister testListerSII("NPPST Squared Integral Image", outputLevel);
|
||||
|
||||
NCVTestSourceProvider<Ncv8u> testSrcRandom_8u(2010, 0, 255, 2048, 2048);
|
||||
|
||||
generateSquaredIntegralTests(testListerSII, testSrcRandom_8u, 2048, 2048);
|
||||
|
||||
return testListerSII.invoke();
|
||||
}
|
||||
|
||||
bool nvidia_NPPST_RectStdDev(const std::string& test_data_path, OutputLevel outputLevel)
|
||||
{
|
||||
path = test_data_path;
|
||||
ncvSetDebugOutputHandler(devNullOutput);
|
||||
|
||||
NCVAutoTestLister testListerRStdDev("NPPST RectStdDev", outputLevel);
|
||||
|
||||
NCVTestSourceProvider<Ncv8u> testSrcRandom_8u(2010, 0, 255, 2048, 2048);
|
||||
|
||||
generateRectStdDevTests(testListerRStdDev, testSrcRandom_8u, 2048, 2048);
|
||||
|
||||
return testListerRStdDev.invoke();
|
||||
}
|
||||
|
||||
bool nvidia_NPPST_Resize(const std::string& test_data_path, OutputLevel outputLevel)
|
||||
{
|
||||
path = test_data_path;
|
||||
ncvSetDebugOutputHandler(devNullOutput);
|
||||
|
||||
NCVAutoTestLister testListerResize("NPPST Resize", outputLevel);
|
||||
|
||||
NCVTestSourceProvider<Ncv32u> testSrcRandom_32u(2010, 0, 0xFFFFFFFF, 2048, 2048);
|
||||
NCVTestSourceProvider<Ncv64u> testSrcRandom_64u(2010, 0, -1, 2048, 2048);
|
||||
|
||||
generateResizeTests(testListerResize, testSrcRandom_32u);
|
||||
generateResizeTests(testListerResize, testSrcRandom_64u);
|
||||
|
||||
return testListerResize.invoke();
|
||||
}
|
||||
|
||||
bool nvidia_NPPST_Vector_Operations(const std::string& test_data_path, OutputLevel outputLevel)
|
||||
{
|
||||
path = test_data_path;
|
||||
ncvSetDebugOutputHandler(devNullOutput);
|
||||
|
||||
NCVAutoTestLister testListerNPPSTVectorOperations("NPPST Vector Operations", outputLevel);
|
||||
|
||||
NCVTestSourceProvider<Ncv32u> testSrcRandom_32u(2010, 0, 0xFFFFFFFF, 2048, 2048);
|
||||
|
||||
generateNPPSTVectorTests(testListerNPPSTVectorOperations, testSrcRandom_32u, 2048*2048);
|
||||
|
||||
return testListerNPPSTVectorOperations.invoke();
|
||||
}
|
||||
|
||||
bool nvidia_NPPST_Transpose(const std::string& test_data_path, OutputLevel outputLevel)
|
||||
{
|
||||
path = test_data_path;
|
||||
ncvSetDebugOutputHandler(devNullOutput);
|
||||
|
||||
NCVAutoTestLister testListerTranspose("NPPST Transpose", outputLevel);
|
||||
|
||||
NCVTestSourceProvider<Ncv32u> testSrcRandom_32u(2010, 0, 0xFFFFFFFF, 2048, 2048);
|
||||
NCVTestSourceProvider<Ncv64u> testSrcRandom_64u(2010, 0, -1, 2048, 2048);
|
||||
|
||||
generateTransposeTests(testListerTranspose, testSrcRandom_32u);
|
||||
generateTransposeTests(testListerTranspose, testSrcRandom_64u);
|
||||
|
||||
return testListerTranspose.invoke();
|
||||
}
|
||||
|
||||
bool nvidia_NCV_Vector_Operations(const std::string& test_data_path, OutputLevel outputLevel)
|
||||
{
|
||||
path = test_data_path;
|
||||
ncvSetDebugOutputHandler(devNullOutput);
|
||||
|
||||
NCVAutoTestLister testListerVectorOperations("Vector Operations", outputLevel);
|
||||
|
||||
NCVTestSourceProvider<Ncv32u> testSrcRandom_32u(2010, 0, 0xFFFFFFFF, 2048, 2048);
|
||||
|
||||
generateVectorTests(testListerVectorOperations, testSrcRandom_32u, 2048*2048);
|
||||
|
||||
return testListerVectorOperations.invoke();
|
||||
|
||||
}
|
||||
|
||||
bool nvidia_NCV_Haar_Cascade_Loader(const std::string& test_data_path, OutputLevel outputLevel)
|
||||
{
|
||||
path = test_data_path;
|
||||
ncvSetDebugOutputHandler(devNullOutput);
|
||||
|
||||
NCVAutoTestLister testListerHaarLoader("Haar Cascade Loader", outputLevel);
|
||||
|
||||
generateHaarLoaderTests(testListerHaarLoader);
|
||||
|
||||
return testListerHaarLoader.invoke();
|
||||
}
|
||||
|
||||
bool nvidia_NCV_Haar_Cascade_Application(const std::string& test_data_path, OutputLevel outputLevel)
|
||||
{
|
||||
path = test_data_path;
|
||||
ncvSetDebugOutputHandler(devNullOutput);
|
||||
|
||||
NCVAutoTestLister testListerHaarAppl("Haar Cascade Application", outputLevel);
|
||||
|
||||
NCVTestSourceProvider<Ncv8u> testSrcFacesVGA_8u(path + "group_1_640x480_VGA.pgm");
|
||||
|
||||
generateHaarApplicationTests(testListerHaarAppl, testSrcFacesVGA_8u, 640, 480);
|
||||
|
||||
return testListerHaarAppl.invoke();
|
||||
}
|
||||
|
||||
bool nvidia_NCV_Hypotheses_Filtration(const std::string& test_data_path, OutputLevel outputLevel)
|
||||
{
|
||||
path = test_data_path;
|
||||
ncvSetDebugOutputHandler(devNullOutput);
|
||||
|
||||
NCVAutoTestLister testListerHypFiltration("Hypotheses Filtration", outputLevel);
|
||||
|
||||
NCVTestSourceProvider<Ncv32u> testSrcRandom_32u(2010, 0, 0xFFFFFFFF, 2048, 2048);
|
||||
|
||||
generateHypothesesFiltrationTests(testListerHypFiltration, testSrcRandom_32u, 512);
|
||||
|
||||
return testListerHypFiltration.invoke();
|
||||
}
|
||||
|
||||
bool nvidia_NCV_Visualization(const std::string& test_data_path, OutputLevel outputLevel)
|
||||
{
|
||||
path = test_data_path;
|
||||
ncvSetDebugOutputHandler(devNullOutput);
|
||||
|
||||
NCVAutoTestLister testListerVisualize("Visualization", outputLevel);
|
||||
|
||||
NCVTestSourceProvider<Ncv8u> testSrcRandom_8u(2010, 0, 255, 2048, 2048);
|
||||
NCVTestSourceProvider<Ncv32u> testSrcRandom_32u(2010, 0, RAND_MAX, 2048, 2048);
|
||||
|
||||
generateDrawRectsTests(testListerVisualize, testSrcRandom_8u, testSrcRandom_32u, 2048, 2048);
|
||||
generateDrawRectsTests(testListerVisualize, testSrcRandom_32u, testSrcRandom_32u, 2048, 2048);
|
||||
|
||||
return testListerVisualize.invoke();
|
||||
}
|
||||
|
||||
#endif /* CUDA_DISABLER */
|
||||
@@ -40,27 +40,6 @@
|
||||
//
|
||||
//M*/
|
||||
|
||||
#ifndef _testhaarcascadeloader_h_
|
||||
#define _testhaarcascadeloader_h_
|
||||
#include "test_precomp.hpp"
|
||||
|
||||
#include "NCVTest.hpp"
|
||||
#include "NCVTestSourceProvider.hpp"
|
||||
|
||||
|
||||
class TestHaarCascadeLoader : public NCVTestProvider
|
||||
{
|
||||
public:
|
||||
|
||||
TestHaarCascadeLoader(std::string testName, std::string cascadeName);
|
||||
|
||||
virtual bool init();
|
||||
virtual bool process();
|
||||
virtual bool deinit();
|
||||
virtual bool toString(std::ofstream &strOut);
|
||||
|
||||
private:
|
||||
|
||||
std::string cascadeName;
|
||||
};
|
||||
|
||||
#endif // _testhaarcascadeloader_h_
|
||||
CV_GPU_TEST_MAIN("gpu")
|
||||
@@ -1,152 +0,0 @@
|
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., 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 "test_precomp.hpp"
|
||||
|
||||
#ifdef HAVE_CUDA
|
||||
|
||||
OutputLevel nvidiaTestOutputLevel = OutputLevelNone;
|
||||
|
||||
using namespace cvtest;
|
||||
using namespace testing;
|
||||
|
||||
struct NVidiaTest : TestWithParam<cv::gpu::DeviceInfo>
|
||||
{
|
||||
cv::gpu::DeviceInfo devInfo;
|
||||
|
||||
std::string _path;
|
||||
|
||||
virtual void SetUp()
|
||||
{
|
||||
devInfo = GetParam();
|
||||
|
||||
cv::gpu::setDevice(devInfo.deviceID());
|
||||
_path = TS::ptr()->get_data_path().c_str();
|
||||
_path = _path + "haarcascade/";
|
||||
}
|
||||
};
|
||||
|
||||
struct NPPST : NVidiaTest {};
|
||||
struct NCV : NVidiaTest {};
|
||||
|
||||
GPU_TEST_P(NPPST, Integral)
|
||||
{
|
||||
bool res = nvidia_NPPST_Integral_Image(_path, nvidiaTestOutputLevel);
|
||||
|
||||
ASSERT_TRUE(res);
|
||||
}
|
||||
|
||||
GPU_TEST_P(NPPST, SquaredIntegral)
|
||||
{
|
||||
bool res = nvidia_NPPST_Squared_Integral_Image(_path, nvidiaTestOutputLevel);
|
||||
|
||||
ASSERT_TRUE(res);
|
||||
}
|
||||
|
||||
GPU_TEST_P(NPPST, RectStdDev)
|
||||
{
|
||||
bool res = nvidia_NPPST_RectStdDev(_path, nvidiaTestOutputLevel);
|
||||
|
||||
ASSERT_TRUE(res);
|
||||
}
|
||||
|
||||
GPU_TEST_P(NPPST, Resize)
|
||||
{
|
||||
bool res = nvidia_NPPST_Resize(_path, nvidiaTestOutputLevel);
|
||||
|
||||
ASSERT_TRUE(res);
|
||||
}
|
||||
|
||||
GPU_TEST_P(NPPST, VectorOperations)
|
||||
{
|
||||
bool res = nvidia_NPPST_Vector_Operations(_path, nvidiaTestOutputLevel);
|
||||
|
||||
ASSERT_TRUE(res);
|
||||
}
|
||||
|
||||
GPU_TEST_P(NPPST, Transpose)
|
||||
{
|
||||
bool res = nvidia_NPPST_Transpose(_path, nvidiaTestOutputLevel);
|
||||
|
||||
ASSERT_TRUE(res);
|
||||
}
|
||||
|
||||
GPU_TEST_P(NCV, VectorOperations)
|
||||
{
|
||||
bool res = nvidia_NCV_Vector_Operations(_path, nvidiaTestOutputLevel);
|
||||
|
||||
ASSERT_TRUE(res);
|
||||
}
|
||||
|
||||
GPU_TEST_P(NCV, HaarCascadeLoader)
|
||||
{
|
||||
bool res = nvidia_NCV_Haar_Cascade_Loader(_path, nvidiaTestOutputLevel);
|
||||
|
||||
ASSERT_TRUE(res);
|
||||
}
|
||||
|
||||
GPU_TEST_P(NCV, HaarCascadeApplication)
|
||||
{
|
||||
bool res = nvidia_NCV_Haar_Cascade_Application(_path, nvidiaTestOutputLevel);
|
||||
|
||||
ASSERT_TRUE(res);
|
||||
}
|
||||
|
||||
GPU_TEST_P(NCV, HypothesesFiltration)
|
||||
{
|
||||
bool res = nvidia_NCV_Hypotheses_Filtration(_path, nvidiaTestOutputLevel);
|
||||
|
||||
ASSERT_TRUE(res);
|
||||
}
|
||||
|
||||
GPU_TEST_P(NCV, Visualization)
|
||||
{
|
||||
// this functionality doesn't used in gpu module
|
||||
bool res = nvidia_NCV_Visualization(_path, nvidiaTestOutputLevel);
|
||||
|
||||
ASSERT_TRUE(res);
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(GPU_NVidia, NPPST, ALL_DEVICES);
|
||||
INSTANTIATE_TEST_CASE_P(GPU_NVidia, NCV, ALL_DEVICES);
|
||||
|
||||
#endif // HAVE_CUDA
|
||||
@@ -75,7 +75,6 @@
|
||||
#include "opencv2/gpu.hpp"
|
||||
|
||||
#include "interpolation.hpp"
|
||||
#include "main_test_nvidia.h"
|
||||
|
||||
#include "opencv2/core/gpu_private.hpp"
|
||||
|
||||
|
||||
Reference in New Issue
Block a user