{ \r
namespace gpu \r
{\r
- template <bool UseSmart> struct TransformChooser;\r
- template<> struct TransformChooser<false>\r
+ template <bool UseSmart> struct TransformDispatcher;\r
+ template<> struct TransformDispatcher<false>\r
{\r
template <typename T, typename D, typename UnOp, typename Mask>\r
static void call(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, UnOp op, const Mask& mask, \r
cudaSafeCall( cudaThreadSynchronize() ); \r
}\r
};\r
- template<> struct TransformChooser<true>\r
+ template<> struct TransformDispatcher<true>\r
{\r
template <typename T, typename D, typename UnOp, typename Mask>\r
static void call(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, UnOp op, const Mask& mask, \r
static void transform_caller(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, UnOp op, const Mask& mask, \r
cudaStream_t stream = 0)\r
{\r
- TransformChooser<device::VecTraits<T>::cn == 1 && device::VecTraits<D>::cn == 1 && device::UnReadWriteTraits<T, D>::shift != 1>::call(src, dst, op, mask, stream);\r
+ TransformDispatcher<device::VecTraits<T>::cn == 1 && device::VecTraits<D>::cn == 1 && device::UnReadWriteTraits<T, D>::shift != 1>::call(src, dst, op, mask, stream);\r
}\r
\r
template <typename T, typename D, typename UnOp>\r
static void transform_caller(const DevMem2D_<T1>& src1, const DevMem2D_<T2>& src2, const DevMem2D_<D>& dst, \r
BinOp op, const Mask& mask, cudaStream_t stream = 0)\r
{\r
- TransformChooser<device::VecTraits<T1>::cn == 1 && device::VecTraits<T2>::cn == 1 && device::VecTraits<D>::cn == 1 && device::BinReadWriteTraits<T1, T2, D>::shift != 1>::call(src1, src2, dst, op, mask, stream);\r
+ TransformDispatcher<device::VecTraits<T1>::cn == 1 && device::VecTraits<T2>::cn == 1 && device::VecTraits<D>::cn == 1 && device::BinReadWriteTraits<T1, T2, D>::shift != 1>::call(src1, src2, dst, op, mask, stream);\r
}\r
\r
template <typename T1, typename T2, typename D, typename BinOp>\r
\r
featureCounter(0), maxCounter(0)\r
{\r
- CV_Assert(img.type() == CV_8UC1);\r
+ CV_Assert(!img.empty() && img.type() == CV_8UC1);\r
CV_Assert(mask.empty() || (mask.size() == img.size() && mask.type() == CV_8UC1));\r
CV_Assert(nOctaves > 0 && nIntervals > 2);\r
CV_Assert(DeviceInfo().has(ATOMICS));\r
max_features = static_cast<int>(img.size().area() * featuresRatio);\r
max_candidates = static_cast<int>(1.5 * max_features);\r
\r
+ CV_Assert(max_features > 0);\r
+\r
featuresBuffer.create(1, max_features, CV_32FC(6));\r
maxPosBuffer.create(1, max_candidates, CV_32SC4);\r
\r
featureCounter = std::min(featureCounter, static_cast<unsigned int>(max_features));\r
}\r
\r
- featuresBuffer.colRange(0, featureCounter).copyTo(keypoints);\r
+ if (featureCounter > 0)\r
+ featuresBuffer.colRange(0, featureCounter).copyTo(keypoints);\r
+ else\r
+ keypoints.release();\r
}\r
\r
void findOrientation(GpuMat& keypoints)\r
\r
void cv::gpu::SURF_GPU::uploadKeypoints(const vector<KeyPoint>& keypoints, GpuMat& keypointsGPU)\r
{\r
- Mat keypointsCPU(1, keypoints.size(), CV_32FC(6));\r
-\r
- const KeyPoint* keypoints_ptr = &keypoints[0];\r
- KeyPoint_GPU* keypointsCPU_ptr = keypointsCPU.ptr<KeyPoint_GPU>();\r
- for (size_t i = 0; i < keypoints.size(); ++i, ++keypoints_ptr, ++keypointsCPU_ptr)\r
+ if (keypoints.empty())\r
+ keypointsGPU.release();\r
+ else\r
{\r
- const KeyPoint& kp = *keypoints_ptr;\r
- KeyPoint_GPU& gkp = *keypointsCPU_ptr;\r
+ Mat keypointsCPU(1, keypoints.size(), CV_32FC(6));\r
\r
- gkp.x = kp.pt.x;\r
- gkp.y = kp.pt.y;\r
+ const KeyPoint* keypoints_ptr = &keypoints[0];\r
+ KeyPoint_GPU* keypointsCPU_ptr = keypointsCPU.ptr<KeyPoint_GPU>();\r
+ for (size_t i = 0; i < keypoints.size(); ++i, ++keypoints_ptr, ++keypointsCPU_ptr)\r
+ {\r
+ const KeyPoint& kp = *keypoints_ptr;\r
+ KeyPoint_GPU& gkp = *keypointsCPU_ptr;\r
\r
- gkp.size = kp.size;\r
+ gkp.x = kp.pt.x;\r
+ gkp.y = kp.pt.y;\r
\r
- gkp.octave = static_cast<float>(kp.octave);\r
- gkp.angle = kp.angle;\r
- gkp.response = kp.response;\r
- }\r
+ gkp.size = kp.size;\r
\r
- keypointsGPU.upload(keypointsCPU);\r
+ gkp.octave = static_cast<float>(kp.octave);\r
+ gkp.angle = kp.angle;\r
+ gkp.response = kp.response;\r
+ }\r
+\r
+ keypointsGPU.upload(keypointsCPU);\r
+ }\r
}\r
\r
void cv::gpu::SURF_GPU::downloadKeypoints(const GpuMat& keypointsGPU, vector<KeyPoint>& keypoints)\r
{\r
- CV_Assert(keypointsGPU.type() == CV_32FC(6) && keypointsGPU.rows == 1);\r
+ if (keypointsGPU.empty())\r
+ keypoints.clear();\r
+ else\r
+ {\r
+ CV_Assert(keypointsGPU.type() == CV_32FC(6) && keypointsGPU.isContinuous());\r
\r
- Mat keypointsCPU = keypointsGPU;\r
- keypoints.resize(keypointsGPU.cols);\r
+ Mat keypointsCPU = keypointsGPU;\r
+ keypoints.resize(keypointsGPU.cols);\r
\r
- KeyPoint* keypoints_ptr = &keypoints[0];\r
- const KeyPoint_GPU* keypointsCPU_ptr = keypointsCPU.ptr<KeyPoint_GPU>();\r
- for (int i = 0; i < keypointsGPU.cols; ++i, ++keypoints_ptr, ++keypointsCPU_ptr)\r
- {\r
- KeyPoint& kp = *keypoints_ptr;\r
- const KeyPoint_GPU& gkp = *keypointsCPU_ptr;\r
+ KeyPoint* keypoints_ptr = &keypoints[0];\r
+ const KeyPoint_GPU* keypointsCPU_ptr = keypointsCPU.ptr<KeyPoint_GPU>();\r
+ for (int i = 0; i < keypointsGPU.cols; ++i, ++keypoints_ptr, ++keypointsCPU_ptr)\r
+ {\r
+ KeyPoint& kp = *keypoints_ptr;\r
+ const KeyPoint_GPU& gkp = *keypointsCPU_ptr;\r
\r
- kp.pt.x = gkp.x;\r
- kp.pt.y = gkp.y;\r
+ kp.pt.x = gkp.x;\r
+ kp.pt.y = gkp.y;\r
\r
- kp.size = gkp.size;\r
+ kp.size = gkp.size;\r
\r
- kp.octave = static_cast<int>(gkp.octave);\r
- kp.angle = gkp.angle;\r
- kp.response = gkp.response;\r
+ kp.octave = static_cast<int>(gkp.octave);\r
+ kp.angle = gkp.angle;\r
+ kp.response = gkp.response;\r
+ }\r
}\r
}\r
\r
void cv::gpu::SURF_GPU::downloadDescriptors(const GpuMat& descriptorsGPU, vector<float>& descriptors)\r
{\r
- CV_Assert(descriptorsGPU.type() == CV_32F);\r
+ if (descriptorsGPU.empty())\r
+ descriptors.clear();\r
+ else\r
+ {\r
+ CV_Assert(descriptorsGPU.type() == CV_32F);\r
\r
- descriptors.resize(descriptorsGPU.rows * descriptorsGPU.cols);\r
- Mat descriptorsCPU(descriptorsGPU.size(), CV_32F, &descriptors[0]);\r
- descriptorsGPU.download(descriptorsCPU);\r
+ descriptors.resize(descriptorsGPU.rows * descriptorsGPU.cols);\r
+ Mat descriptorsCPU(descriptorsGPU.size(), CV_32F, &descriptors[0]);\r
+ descriptorsGPU.download(descriptorsCPU);\r
+ }\r
}\r
\r
void cv::gpu::SURF_GPU::operator()(const GpuMat& img, const GpuMat& mask, GpuMat& keypoints)\r
{\r
- SURF_GPU_Invoker surf(*this, img, mask);\r
+ if (!img.empty())\r
+ {\r
+ SURF_GPU_Invoker surf(*this, img, mask);\r
\r
- surf.detectKeypoints(keypoints);\r
+ surf.detectKeypoints(keypoints);\r
\r
- surf.findOrientation(keypoints);\r
+ surf.findOrientation(keypoints);\r
+ }\r
}\r
\r
void cv::gpu::SURF_GPU::operator()(const GpuMat& img, const GpuMat& mask, GpuMat& keypoints, GpuMat& descriptors, \r
bool useProvidedKeypoints, bool calcOrientation)\r
{\r
- SURF_GPU_Invoker surf(*this, img, mask);\r
- \r
- if (!useProvidedKeypoints)\r
- surf.detectKeypoints(keypoints);\r
- \r
- if (calcOrientation)\r
- surf.findOrientation(keypoints);\r
+ if (!img.empty())\r
+ {\r
+ SURF_GPU_Invoker surf(*this, img, mask);\r
+ \r
+ if (!useProvidedKeypoints)\r
+ surf.detectKeypoints(keypoints);\r
+ \r
+ if (calcOrientation)\r
+ surf.findOrientation(keypoints);\r
\r
- surf.computeDescriptors(keypoints, descriptors, descriptorSize());\r
+ surf.computeDescriptors(keypoints, descriptors, descriptorSize());\r
+ }\r
}\r
\r
void cv::gpu::SURF_GPU::operator()(const GpuMat& img, const GpuMat& mask, vector<KeyPoint>& keypoints)\r
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin/"
)
-add_dependencies(${the_target} opencv_ts opencv_gpu opencv_highgui opencv_imgproc)
+add_dependencies(${the_target} opencv_ts opencv_gpu opencv_highgui opencv_imgproc opencv_calib3d)
# Add the required libraries for linking:
-target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} opencv_ts opencv_gpu opencv_highgui opencv_imgproc)
+target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} opencv_ts opencv_gpu opencv_highgui opencv_imgproc opencv_calib3d)
enable_testing()
get_target_property(LOC ${the_target} LOCATION)
--- /dev/null
+/*M///////////////////////////////////////////////////////////////////////////////////////\r
+//\r
+// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.\r
+//\r
+// By downloading, copying, installing or using the software you agree to this license.\r
+// If you do not agree to this license, do not download, install,\r
+// copy or use the software.\r
+//\r
+//\r
+// Intel License Agreement\r
+// For Open Source Computer Vision Library\r
+//\r
+// Copyright (C) 2000, Intel Corporation, all rights reserved.\r
+// Third party copyrights are property of their respective owners.\r
+//\r
+// Redistribution and use in source and binary forms, with or without modification,\r
+// are permitted provided that the following conditions are met:\r
+//\r
+// * Redistribution's of source code must retain the above copyright notice,\r
+// this list of conditions and the following disclaimer.\r
+//\r
+// * Redistribution's in binary form must reproduce the above copyright notice,\r
+// this list of conditions and the following disclaimer in the documentation\r
+// and/or other materials provided with the distribution.\r
+//\r
+// * The name of Intel Corporation may not be used to endorse or promote products\r
+// derived from this software without specific prior written permission.\r
+//\r
+// This software is provided by the copyright holders and contributors "as is" and\r
+// any express or implied warranties, including, but not limited to, the implied\r
+// warranties of merchantability and fitness for a particular purpose are disclaimed.\r
+// In no event shall the Intel Corporation or contributors be liable for any direct,\r
+// indirect, incidental, special, exemplary, or consequential damages\r
+// (including, but not limited to, procurement of substitute goods or services;\r
+// loss of use, data, or profits; or business interruption) however caused\r
+// and on any theory of liability, whether in contract, strict liability,\r
+// or tort (including negligence or otherwise) arising in any way out of\r
+// the use of this software, even if advised of the possibility of such damage.\r
+//\r
+//M*/\r
+\r
+#include "gputest.hpp"\r
+#include <string>\r
+\r
+using namespace cv;\r
+using namespace cv::gpu;\r
+using namespace std;\r
+\r
+const string FEATURES2D_DIR = "features2d";\r
+const string IMAGE_FILENAME = "aloe.png";\r
+const string VALID_FILE_NAME = "surf.xml.gz";\r
+\r
+class CV_GPU_SURFTest : public CvTest\r
+{\r
+public:\r
+ CV_GPU_SURFTest() :\r
+ CvTest( "GPU-SURF", "SURF_GPU") \r
+ {\r
+ }\r
+\r
+protected:\r
+ bool isSimilarKeypoints(const KeyPoint& p1, const KeyPoint& p2);\r
+ void compareKeypointSets(const vector<KeyPoint>& validKeypoints, const vector<KeyPoint>& calcKeypoints,\r
+ const Mat& validDescriptors, const Mat& calcDescriptors);\r
+\r
+ void emptyDataTest(SURF_GPU& fdetector);\r
+ void regressionTest(SURF_GPU& fdetector);\r
+\r
+ virtual void run(int);\r
+};\r
+\r
+void CV_GPU_SURFTest::emptyDataTest(SURF_GPU& fdetector)\r
+{\r
+ GpuMat image;\r
+ vector<KeyPoint> keypoints;\r
+ vector<float> descriptors;\r
+ try\r
+ {\r
+ fdetector(image, GpuMat(), keypoints, descriptors);\r
+ }\r
+ catch(...)\r
+ {\r
+ ts->printf( CvTS::LOG, "detect() on empty image must not generate exception (1).\n" );\r
+ ts->set_failed_test_info( CvTS::FAIL_INVALID_OUTPUT );\r
+ }\r
+\r
+ if( !keypoints.empty() )\r
+ {\r
+ ts->printf( CvTS::LOG, "detect() on empty image must return empty keypoints vector (1).\n" );\r
+ ts->set_failed_test_info( CvTS::FAIL_INVALID_OUTPUT );\r
+ return;\r
+ }\r
+\r
+ if( !descriptors.empty() )\r
+ {\r
+ ts->printf( CvTS::LOG, "detect() on empty image must return empty descriptors vector (1).\n" );\r
+ ts->set_failed_test_info( CvTS::FAIL_INVALID_OUTPUT );\r
+ return;\r
+ }\r
+}\r
+\r
+bool CV_GPU_SURFTest::isSimilarKeypoints(const KeyPoint& p1, const KeyPoint& p2)\r
+{\r
+ const float maxPtDif = 1.f;\r
+ const float maxSizeDif = 1.f;\r
+ const float maxAngleDif = 2.f;\r
+ const float maxResponseDif = 0.1f;\r
+\r
+ float dist = (float)norm( p1.pt - p2.pt );\r
+ return (dist < maxPtDif &&\r
+ fabs(p1.size - p2.size) < maxSizeDif &&\r
+ abs(p1.angle - p2.angle) < maxAngleDif &&\r
+ abs(p1.response - p2.response) < maxResponseDif &&\r
+ p1.octave == p2.octave &&\r
+ p1.class_id == p2.class_id );\r
+}\r
+\r
+void CV_GPU_SURFTest::compareKeypointSets(const vector<KeyPoint>& validKeypoints, const vector<KeyPoint>& calcKeypoints, \r
+ const Mat& validDescriptors, const Mat& calcDescriptors)\r
+{\r
+ if (validKeypoints.size() != calcKeypoints.size())\r
+ {\r
+ ts->printf(CvTS::LOG, "Keypoints sizes doesn't equal (validCount = %d, calcCount = %d).\n",\r
+ validKeypoints.size(), calcKeypoints.size());\r
+ ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT);\r
+ return;\r
+ }\r
+ if (validDescriptors.size() != calcDescriptors.size())\r
+ {\r
+ ts->printf(CvTS::LOG, "Descriptors sizes doesn't equal.\n");\r
+ ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT);\r
+ return;\r
+ }\r
+ for (size_t v = 0; v < validKeypoints.size(); v++)\r
+ {\r
+ int nearestIdx = -1;\r
+ float minDist = std::numeric_limits<float>::max();\r
+\r
+ for (size_t c = 0; c < calcKeypoints.size(); c++)\r
+ {\r
+ float curDist = (float)norm(calcKeypoints[c].pt - validKeypoints[v].pt);\r
+ if (curDist < minDist)\r
+ {\r
+ minDist = curDist;\r
+ nearestIdx = c;\r
+ }\r
+ }\r
+\r
+ assert(minDist >= 0);\r
+ if (!isSimilarKeypoints(validKeypoints[v], calcKeypoints[nearestIdx]))\r
+ {\r
+ ts->set_failed_test_info( CvTS::FAIL_BAD_ACCURACY );\r
+ return;\r
+ }\r
+\r
+ if (norm(validDescriptors.row(v), calcDescriptors.row(nearestIdx), NORM_L2) > 1.0f)\r
+ {\r
+ ts->set_failed_test_info( CvTS::FAIL_BAD_ACCURACY );\r
+ return;\r
+ }\r
+ }\r
+}\r
+\r
+void CV_GPU_SURFTest::regressionTest(SURF_GPU& fdetector)\r
+{\r
+ string imgFilename = string(ts->get_data_path()) + FEATURES2D_DIR + "/" + IMAGE_FILENAME;\r
+ string resFilename = string(ts->get_data_path()) + FEATURES2D_DIR + "/" + VALID_FILE_NAME;\r
+\r
+ // Read the test image.\r
+ GpuMat image(imread(imgFilename, 0));\r
+ if (image.empty())\r
+ {\r
+ ts->printf( CvTS::LOG, "Image %s can not be read.\n", imgFilename.c_str() );\r
+ ts->set_failed_test_info( CvTS::FAIL_INVALID_TEST_DATA );\r
+ return;\r
+ }\r
+\r
+ FileStorage fs(resFilename, FileStorage::READ);\r
+\r
+ // Compute keypoints.\r
+ GpuMat mask(image.size(), CV_8UC1, Scalar::all(1));\r
+ mask(Range(0, image.rows / 2), Range(0, image.cols / 2)).setTo(Scalar::all(0));\r
+ vector<KeyPoint> calcKeypoints;\r
+ GpuMat calcDespcriptors;\r
+ fdetector(image, mask, calcKeypoints, calcDespcriptors);\r
+\r
+ if (fs.isOpened()) // Compare computed and valid keypoints.\r
+ {\r
+ // Read validation keypoints set.\r
+ vector<KeyPoint> validKeypoints;\r
+ Mat validDespcriptors;\r
+ read(fs["keypoints"], validKeypoints);\r
+ read(fs["descriptors"], validDespcriptors);\r
+ if (validKeypoints.empty() || validDespcriptors.empty())\r
+ {\r
+ ts->printf(CvTS::LOG, "Validation file can not be read.\n");\r
+ ts->set_failed_test_info(CvTS::FAIL_INVALID_TEST_DATA);\r
+ return;\r
+ }\r
+\r
+ compareKeypointSets(validKeypoints, calcKeypoints, validDespcriptors, calcDespcriptors);\r
+ }\r
+ else // Write detector parameters and computed keypoints as validation data.\r
+ {\r
+ fs.open(resFilename, FileStorage::WRITE);\r
+ if (!fs.isOpened())\r
+ {\r
+ ts->printf(CvTS::LOG, "File %s can not be opened to write.\n", resFilename.c_str());\r
+ ts->set_failed_test_info(CvTS::FAIL_INVALID_TEST_DATA);\r
+ return;\r
+ }\r
+ else\r
+ {\r
+ write(fs, "keypoints", calcKeypoints);\r
+ write(fs, "descriptors", (Mat)calcDespcriptors);\r
+ }\r
+ }\r
+}\r
+\r
+void CV_GPU_SURFTest::run( int /*start_from*/ )\r
+{\r
+ SURF_GPU fdetector;\r
+\r
+ emptyDataTest(fdetector);\r
+ regressionTest(fdetector);\r
+}\r
+\r
+CV_GPU_SURFTest CV_GPU_SURF_test;\r
#include <opencv2/highgui/highgui.hpp>\r
#include <opencv2/imgproc/imgproc.hpp>\r
#include <opencv2/features2d/features2d.hpp>\r
+#include <opencv2/calib3d/calib3d.hpp>\r
#include "cxts.h"\r
\r
/****************************************************************************************/\r
}\r
};\r
\r
+////////////////////////////////////////////////////////////////////////////////\r
+// reprojectImageTo3D\r
+class CV_GpuReprojectImageTo3DTest : public CvTest\r
+{\r
+public:\r
+ CV_GpuReprojectImageTo3DTest() : CvTest("GPU-ReprojectImageTo3D", "reprojectImageTo3D") {}\r
+\r
+protected:\r
+ void run(int)\r
+ {\r
+ Mat disp(320, 240, CV_8UC1);\r
+\r
+ RNG rng(*ts->get_rng());\r
+ rng.fill(disp, RNG::UNIFORM, Scalar(5), Scalar(30));\r
+\r
+ Mat Q(4, 4, CV_32FC1);\r
+ rng.fill(Q, RNG::UNIFORM, Scalar(0.1), Scalar(1));\r
+\r
+ Mat cpures;\r
+ GpuMat gpures;\r
+\r
+ reprojectImageTo3D(disp, cpures, Q, false);\r
+ reprojectImageTo3D(GpuMat(disp), gpures, Q);\r
+\r
+ Mat temp = gpures;\r
+\r
+ for (int y = 0; y < cpures.rows; ++y)\r
+ {\r
+ const Vec3f* cpu_row = cpures.ptr<Vec3f>(y);\r
+ const Vec4f* gpu_row = temp.ptr<Vec4f>(y);\r
+ for (int x = 0; x < cpures.cols; ++x)\r
+ {\r
+ Vec3f a = cpu_row[x];\r
+ Vec4f b = gpu_row[x];\r
+\r
+ if (fabs(a[0] - b[0]) > 1e-5 || fabs(a[1] - b[1]) > 1e-5 || fabs(a[2] - b[2]) > 1e-5)\r
+ {\r
+ ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT);\r
+ return;\r
+ }\r
+ }\r
+ }\r
+ }\r
+};\r
+\r
/////////////////////////////////////////////////////////////////////////////\r
/////////////////// tests registration /////////////////////////////////////\r
/////////////////////////////////////////////////////////////////////////////\r
CV_GpuCornerMinEigenValTest CV_GpuCornerMinEigenVal_test;\r
CV_GpuColumnSumTest CV_GpuColumnSum_test;\r
CV_GpuNormTest CV_GpuNormTest_test;\r
+CV_GpuReprojectImageTo3DTest CV_GpuReprojectImageTo3D_test;\r