created GPU new-style test project, ported StereoBP test

modules/gpu/CMakeLists.txt

@@ -147,4 +147,8 @@ install(FILES ${lib_hdrs}
 #	DESTINATION include/opencv2/${name}/device
 #	COMPONENT main)
 
-
+# Test files processing is in the separated directory to avoid 'Src' source 
+# filter creation in Visual Studio 
+if(BUILD_TESTS AND NOT ANDROID AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/test)
+	add_subdirectory(test)
+endif()

modules/gpu/test/CMakeLists.txt

@@ -0,0 +1,53 @@
+set(the_target "opencv_test_${name}")	
+project(${the_target})
+
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../include"
+                    "${CMAKE_CURRENT_SOURCE_DIR}/.."
+                    "${CMAKE_CURRENT_BINARY_DIR}")						
+
+set(test_deps opencv_${name} opencv_ts opencv_highgui ${DEPS})
+foreach(d ${test_deps})
+    if(${d} MATCHES "opencv_")
+        if(${d} MATCHES "opencv_lapack")
+        else()
+            string(REPLACE "opencv_" "${CMAKE_CURRENT_SOURCE_DIR}/../../" d_dir ${d})
+            include_directories("${d_dir}/include")
+        endif()
+    endif()
+endforeach()
+
+file(GLOB test_srcs "*.cpp")
+file(GLOB test_hdrs "*.h*")
+
+add_executable(${the_target} ${test_srcs} ${test_hdrs})
+
+if(PCHSupport_FOUND)
+    set(pch_header ${CMAKE_CURRENT_SOURCE_DIR}/test_precomp.hpp)
+    if(${CMAKE_GENERATOR} MATCHES "Visual*" OR ${CMAKE_GENERATOR} MATCHES "Xcode*")
+        if(${CMAKE_GENERATOR} MATCHES "Visual*")
+            set(${the_target}_pch "test_precomp.cpp")
+        endif()            
+        add_native_precompiled_header(${the_target} ${pch_header})
+    elseif(CMAKE_COMPILER_IS_GNUCXX AND ${CMAKE_GENERATOR} MATCHES ".*Makefiles")
+        add_precompiled_header(${the_target} ${pch_header})
+    endif()
+endif()
+
+# Additional target properties
+set_target_properties(${the_target} PROPERTIES
+    DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
+    RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin/"
+    )
+
+add_dependencies(${the_target} ${test_deps})
+
+# Add the required libraries for linking:
+target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} ${test_deps})
+
+enable_testing()
+get_target_property(LOC ${the_target} LOCATION)
+add_test(${the_target} "${LOC}")
+
+if(WIN32)
+    install(TARGETS ${the_target} RUNTIME DESTINATION bin COMPONENT main)
+endif()

modules/gpu/test/test_main.cpp

@@ -0,0 +1,3 @@
+#include "test_precomp.hpp"
+
+CV_TEST_MAIN("gpu")

modules/gpu/test/test_precomp.cpp

@@ -0,0 +1 @@
+#include "test_precomp.hpp"

modules/gpu/test/test_precomp.hpp

@@ -0,0 +1,31 @@
+#ifndef __OPENCV_TEST_PRECOMP_HPP__
+#define __OPENCV_TEST_PRECOMP_HPP__
+
+#include "opencv2/ts/ts.hpp"
+#include "opencv2/gpu/gpu.hpp"
+#include "opencv2/highgui/highgui.hpp"
+
+static inline bool check_and_treat_gpu_exception(const cv::Exception& e, cvtest::TS* ts)
+{
+    switch (e.code)
+    {
+    case CV_GpuNotSupported: 
+        ts->printf(cvtest::TS::LOG, "\nGpu not supported by the library"); 
+        break;
+
+    case CV_GpuApiCallError: 
+        ts->printf(cvtest::TS::LOG, "\nGPU Error: %s", e.what());
+        break;
+
+    case CV_GpuNppCallError: 
+        ts->printf(cvtest::TS::LOG, "\nNPP Error: %s", e.what());
+        break;
+
+    default:
+        return false;
+    }
+    ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);                        
+    return true;
+}
+
+#endif

modules/gpu/test/test_stereo_bp.cpp

@@ -0,0 +1,91 @@
+/*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.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation 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"
+
+struct CV_GpuStereoBPTest : public cvtest::BaseTest
+{
+    void run(int )
+    {
+        cv::Mat img_l = cv::imread(std::string(ts->get_data_path()) + "stereobp/aloe-L.png");
+        cv::Mat img_r = cv::imread(std::string(ts->get_data_path()) + "stereobp/aloe-R.png");
+        cv::Mat img_template = cv::imread(std::string(ts->get_data_path()) + "stereobp/aloe-disp.png", 0);
+
+        if (img_l.empty() || img_r.empty() || img_template.empty())
+        {
+            ts->set_failed_test_info(cvtest::TS::FAIL_MISSING_TEST_DATA);
+            return;
+        }
+
+        try
+        {
+            {cv::Mat temp; cv::cvtColor(img_l, temp, CV_BGR2BGRA); cv::swap(temp, img_l);}
+            {cv::Mat temp; cv::cvtColor(img_r, temp, CV_BGR2BGRA); cv::swap(temp, img_r);}
+
+            cv::gpu::GpuMat disp;
+            cv::gpu::StereoBeliefPropagation bpm(64, 8, 2, 25, 0.1f, 15, 1, CV_16S);
+
+            bpm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), disp);
+
+            //cv::imwrite(std::string(ts->get_data_path()) + "stereobp/aloe-disp.png", disp);
+
+            disp.convertTo(disp, img_template.type());
+
+	    double norm = cv::norm(disp, img_template, cv::NORM_INF);
+		if (norm >= 0.5)
+	    {
+		ts->printf(cvtest::TS::LOG, "\nStereoBP norm = %f\n", norm);
+		ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);
+		return;
+	    }
+	}
+	catch(const cv::Exception& e)
+	{
+	    if (!check_and_treat_gpu_exception(e, ts))
+		throw;
+	    return;
+	}
+
+        ts->set_failed_test_info(cvtest::TS::OK);
+    }
+};
+
+TEST(StereoBP, StereoBP) { CV_GpuStereoBPTest test; test.safe_run(); }

modules/objdetect/test/test_precomp.hpp

@@ -3,8 +3,7 @@
 
 #include "opencv2/ts/ts.hpp"
 #include "opencv2/objdetect/objdetect.hpp"
-#include "opencv2/imgproc/imgproc_c.h"
+#include "opencv2/imgproc/imgproc.hpp"
 #include "opencv2/highgui/highgui.hpp"
-#include <iostream>
 
 #endif

tests/CMakeLists.txt

@@ -9,6 +9,6 @@
 #    set (BUILD_TESTS_GPU OFF CACHE BOOL "Build tests GPU")
 	
 #    if(BUILD_TESTS_GPU AND WITH_CUDA)
-        add_subdirectory(gpu)
+#        add_subdirectory(gpu)
 #	 endif()
 #endif()