fixed SURF_GPU (fails on empty data)
authorVladislav Vinogradov <no@email>
Mon, 7 Feb 2011 10:12:04 +0000 (10:12 +0000)
committerVladislav Vinogradov <no@email>
Mon, 7 Feb 2011 10:12:04 +0000 (10:12 +0000)
added test for SURF_GPU and reprojectImageTo3D

modules/gpu/src/opencv2/gpu/device/transform.hpp
modules/gpu/src/surf.cpp
tests/gpu/CMakeLists.txt
tests/gpu/src/features2d.cpp [new file with mode: 0644]
tests/gpu/src/gputest.hpp
tests/gpu/src/imgproc_gpu.cpp

index 79ed094..5ddf18e 100644 (file)
@@ -315,8 +315,8 @@ namespace cv
 { \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
@@ -350,7 +350,7 @@ namespace cv
                     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
@@ -393,7 +393,7 @@ namespace cv
         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
@@ -412,7 +412,7 @@ namespace cv
         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
index fc2313f..b5ab0d9 100644 (file)
@@ -101,7 +101,7 @@ namespace
 \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
@@ -109,6 +109,8 @@ namespace
             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
@@ -202,7 +204,10 @@ namespace
                 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
@@ -252,83 +257,104 @@ int cv::gpu::SURF_GPU::descriptorSize() const
 \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
index ca0e601..6e172c7 100644 (file)
@@ -51,10 +51,10 @@ set_target_properties(${the_target} PROPERTIES
        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)
diff --git a/tests/gpu/src/features2d.cpp b/tests/gpu/src/features2d.cpp
new file mode 100644 (file)
index 0000000..8a75447
--- /dev/null
@@ -0,0 +1,228 @@
+/*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
index 360fba6..50f388c 100644 (file)
@@ -52,6 +52,7 @@
 #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
index 0414c48..10db183 100644 (file)
@@ -912,6 +912,51 @@ struct CV_GpuNormTest : CvTest
     }\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
@@ -933,3 +978,4 @@ CV_GpuCornerHarrisTest CV_GpuCornerHarris_test;
 CV_GpuCornerMinEigenValTest CV_GpuCornerMinEigenVal_test;\r
 CV_GpuColumnSumTest CV_GpuColumnSum_test;\r
 CV_GpuNormTest CV_GpuNormTest_test;\r
+CV_GpuReprojectImageTo3DTest CV_GpuReprojectImageTo3D_test;\r