Merge branch '2.4'

modules/core/include/opencv2/core/core.hpp

@@ -4340,15 +4340,24 @@ public:
     CV_WRAP vector<Mat> getMatVector(const string& name) const;
     CV_WRAP Ptr<Algorithm> getAlgorithm(const string& name) const;
 
-    CV_WRAP_AS(setInt) void set(const string& name, int value);
-    CV_WRAP_AS(setDouble) void set(const string& name, double value);
-    CV_WRAP_AS(setBool) void set(const string& name, bool value);
-    CV_WRAP_AS(setString) void set(const string& name, const string& value);
-    CV_WRAP_AS(setMat) void set(const string& name, const Mat& value);
-    CV_WRAP_AS(setMatVector) void set(const string& name, const vector<Mat>& value);
-    CV_WRAP_AS(setAlgorithm) void set(const string& name, const Ptr<Algorithm>& value);
+    void set(const string& name, int value);
+    void set(const string& name, double value);
+    void set(const string& name, bool value);
+    void set(const string& name, const string& value);
+    void set(const string& name, const Mat& value);
+    void set(const string& name, const vector<Mat>& value);
+    void set(const string& name, const Ptr<Algorithm>& value);
     template<typename _Tp> void set(const string& name, const Ptr<_Tp>& value);
 
+    CV_WRAP void setInt(const string& name, int value);
+    CV_WRAP void setDouble(const string& name, double value);
+    CV_WRAP void setBool(const string& name, bool value);
+    CV_WRAP void setString(const string& name, const string& value);
+    CV_WRAP void setMat(const string& name, const Mat& value);
+    CV_WRAP void setMatVector(const string& name, const vector<Mat>& value);
+    CV_WRAP void setAlgorithm(const string& name, const Ptr<Algorithm>& value);
+    template<typename _Tp> void setAlgorithm(const string& name, const Ptr<_Tp>& value);
+
     void set(const char* name, int value);
     void set(const char* name, double value);
     void set(const char* name, bool value);
@@ -4358,6 +4367,15 @@ public:
     void set(const char* name, const Ptr<Algorithm>& value);
     template<typename _Tp> void set(const char* name, const Ptr<_Tp>& value);
 
+    void setInt(const char* name, int value);
+    void setDouble(const char* name, double value);
+    void setBool(const char* name, bool value);
+    void setString(const char* name, const string& value);
+    void setMat(const char* name, const Mat& value);
+    void setMatVector(const char* name, const vector<Mat>& value);
+    void setAlgorithm(const char* name, const Ptr<Algorithm>& value);
+    template<typename _Tp> void setAlgorithm(const char* name, const Ptr<_Tp>& value);
+
     CV_WRAP string paramHelp(const string& name) const;
     int paramType(const char* name) const;
     CV_WRAP int paramType(const string& name) const;

modules/core/include/opencv2/core/internal.hpp

@@ -263,20 +263,20 @@ namespace cv
 } //namespace cv
 
 #define CV_INIT_ALGORITHM(classname, algname, memberinit) \
-    static Algorithm* create##classname() \
+    static ::cv::Algorithm* create##classname() \
     { \
         return new classname; \
     } \
     \
-    static AlgorithmInfo& classname##_info() \
+    static ::cv::AlgorithmInfo& classname##_info() \
     { \
-        static AlgorithmInfo classname##_info_var(algname, create##classname); \
+        static ::cv::AlgorithmInfo classname##_info_var(algname, create##classname); \
         return classname##_info_var; \
     } \
     \
-    static AlgorithmInfo& classname##_info_auto = classname##_info(); \
+    static ::cv::AlgorithmInfo& classname##_info_auto = classname##_info(); \
     \
-    AlgorithmInfo* classname::info() const \
+    ::cv::AlgorithmInfo* classname::info() const \
     { \
         static volatile bool initialized = false; \
         \

modules/core/include/opencv2/core/operations.hpp

@@ -3921,6 +3921,22 @@ inline void Algorithm::set(const string& _name, const Ptr<_Tp>& value)
     this->set<_Tp>(_name.c_str(), value);
 }
 
+template<typename _Tp>
+inline void Algorithm::setAlgorithm(const char* _name, const Ptr<_Tp>& value)
+{
+    Ptr<Algorithm> algo_ptr = value. template ptr<cv::Algorithm>();
+    if (algo_ptr.empty()) {
+        CV_Error( CV_StsUnsupportedFormat, "unknown/unsupported Ptr type of the second parameter of the method Algorithm::set");
+    }
+    info()->set(this, _name, ParamType<Algorithm>::type, &algo_ptr);
+}
+
+template<typename _Tp>
+inline void Algorithm::setAlgorithm(const string& _name, const Ptr<_Tp>& value)
+{
+    this->set<_Tp>(_name.c_str(), value);
+}
+
 template<typename _Tp> inline typename ParamType<_Tp>::member_type Algorithm::get(const string& _name) const
 {
     typename ParamType<_Tp>::member_type value;

modules/ocl/CMakeLists.txt

@@ -4,26 +4,18 @@ if(NOT HAVE_OPENCL)
 endif()
 
 set(the_description "OpenCL-accelerated Computer Vision")
-ocv_add_module(ocl opencv_core opencv_imgproc opencv_calib3d opencv_objdetect opencv_video opencv_nonfree opencv_ts)
+ocv_add_module(ocl opencv_core opencv_imgproc opencv_features2d opencv_objdetect opencv_video)
 
 ocv_module_include_directories()
 
 file(GLOB CL_FILES "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels/*.cl")
 set(kernels_cpp "${CMAKE_CURRENT_BINARY_DIR}/kernels.cpp")
-set(cl2cpp_script "${CMAKE_CURRENT_SOURCE_DIR}/cl2cpp.py")
-set(cl2cpp_script_W32 "${CMAKE_CURRENT_SOURCE_DIR}/cl2cpp.js")
+set(cl2cpp_script "${CMAKE_CURRENT_SOURCE_DIR}/cl2cpp.cmake")
 
-IF(0)
-   add_custom_command(
+add_custom_command(
   OUTPUT ${kernels_cpp}
-   COMMAND wscript.exe ${cl2cpp_script_W32} "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels" ${kernels_cpp}
-   DEPENDS ${CL_FILES} ${cl2cpp_script_W32})
-else()
-   add_custom_command(
-   OUTPUT ${kernels_cpp}
-   COMMAND ${PYTHON_EXECUTABLE} ${cl2cpp_script} "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels" ${kernels_cpp}
+  COMMAND ${CMAKE_COMMAND} -DCL_DIR="${CMAKE_CURRENT_SOURCE_DIR}/src/kernels" -DOUTPUT="${kernels_cpp}" -P ${cl2cpp_script}
   DEPENDS ${CL_FILES} ${cl2cpp_script})
-ENDIF()
 
 file(GLOB lib_hdrs     "include/opencv2/${name}/*.hpp" "include/opencv2/${name}/*.h")
 file(GLOB lib_srcs     "src/*.cpp")
@@ -47,12 +39,7 @@ if (HAVE_OPENCL)
   endif()
 endif()
 
-ocv_set_module_sources(
-    HEADERS ${lib_hdrs}
-    SOURCES ${lib_int_hdrs} ${lib_srcs}
-    )
-
-set(OPENCV_MODULE_opencv_ocl_SOURCES ${OPENCV_MODULE_opencv_ocl_SOURCES} ${kernels_cpp})
+ocv_set_module_sources(HEADERS ${lib_hdrs} SOURCES ${lib_int_hdrs} ${lib_srcs} ${kernels_cpp})
 ocv_create_module(${ocl_link_libs})
 
 install(FILES ${lib_hdrs}
@@ -69,6 +56,7 @@ file(GLOB test_hdrs "test/*.hpp" "test/*.h")
 
 ocv_add_accuracy_tests(FILES "Include" ${test_hdrs}
                        FILES "Src" ${test_srcs})
+
 ################################################################################################################
 ################################   OpenCL Module Performance  ##################################################
 ################################################################################################################

modules/ocl/cl2cpp.cmake

+file(GLOB cl_list "${CL_DIR}/*.cl" )
+
+file(WRITE ${OUTPUT} "// This file is auto-generated. Do not edit!
+
+namespace cv
+{
+namespace ocl
+{
+")
+
+foreach(cl ${cl_list})
+  get_filename_component(cl_filename "${cl}" NAME_WE)
+  #message("${cl_filename}")
+
+  file(READ "${cl}" lines)
+
+  string(REPLACE "\r" "" lines "${lines}\n")
+  string(REPLACE "\t" "  " lines "${lines}")
+
+  string(REGEX REPLACE "/\\*([^*]/|\\*[^/]|[^*/])*\\*/" ""   lines "${lines}") # multiline comments
+  string(REGEX REPLACE "[ ]*//[^\n]*\n"                 "\n" lines "${lines}") # single-line comments
+  string(REGEX REPLACE "\n[ ]*(\n[ ]*)*"                "\n" lines "${lines}") # empty lines & leading whitespace
+  string(REGEX REPLACE "^\n"                            ""   lines "${lines}") # leading new line
+
+  string(REPLACE "\\" "\\\\" lines "${lines}")
+  string(REPLACE "\"" "\\\"" lines "${lines}")
+  string(REPLACE "\n" "\\n\"\n\"" lines "${lines}")
+
+  string(REGEX REPLACE "\"$" "" lines "${lines}") # unneeded " at the eof
+
+  file(APPEND ${OUTPUT} "const char* ${cl_filename}=\"${lines};\n")
+endforeach()
+
+file(APPEND ${OUTPUT} "}\n}\n")
\ No newline at end of file

modules/ocl/cl2cpp.js

-var fso = new ActiveXObject("Scripting.FileSystemObject"), shell = new ActiveXObject("WScript.Shell"), args = WScript.Arguments, indir = args[0], outname = args[1], outDir, scriptFullPath = WScript.ScriptFullName;
-function getDir(a) {
-	return a.substring(0, a.lastIndexOf("\\") || a.lastIndexOf("/"))
-}
-if (!indir || !outname) {
-	var scriptPath = getDir(WScript.ScriptFullName.toString()),
-	indir = indir || scriptPath + "/src/kernels";
-	outname || (outname = scriptPath + "/kernels.cpp", outDir = scriptPath)
-} else {
-	outDir = getDir(outname);
-	try {
-		fso.CreateFolder(outDir)
-	} catch (err) {}
-	
-}
-var infldr = fso.GetFolder(indir), clrx = /([\w-]+)\.cl$/i, stripBeginningRx = /^(\s)+/i, stripSinglelineMstyle = /\/\*.*?\*\//ig, outStream = fso.OpenTextFile(outname, 2, !0, -2);
-outStream.write("// This file is auto-generated. Do not edit!\n\nnamespace cv{\n\tnamespace ocl{\n");
-for (var res, cl_file, l, state, countFiles = 0, codeRows = 0, removedRows = 0, filei = new Enumerator(infldr.Files); !filei.atEnd(); filei.moveNext())
-	if (cl_file = filei.item(), res = cl_file.Name.match(clrx)) {
-		var cl_filename = res[1],
-		inStream = cl_file.OpenAsTextStream(1);
-		outStream.writeLine("\t\tconst char* " + cl_filename + "=");
-		state = 0;
-		for (countFiles++; !inStream.AtEndOfStream; ) {
-			l = inStream.readLine();
-			stripSinglelineMstyle.lastIndex = 0;
-			l = l.replace(stripSinglelineMstyle, "");
-			var mline = l.indexOf("/*");
-			0 <= mline ? (l = l.substr(0, mline),
-				state = 1) : (mline = l.indexOf("*/"), 0 <= mline && (l = l.substr(mline + 2), state = 0));
-			var slineBegin = l.indexOf("//");
-			0 <= slineBegin && (l = l.substr(0, slineBegin));
-			1 == state || !l ? removedRows++ : (l = l.replace(stripBeginningRx, "$1"), l = l.replace("\\", "\\\\"), l = l.replace("\r", ""), l = l.replace('"', '\\"'), l = l.replace("\t", "  "), codeRows++, outStream.writeLine('\t\t\t"' + l + '\\n"'))
-		}
-		outStream.writeLine("\t\t;");
-		inStream.close()
-	}
-outStream.writeLine("\t\t}\n\t}");
-outStream.close();
-shell.Popup("Merging OpenCL Kernels into cpp file has been FINISHED!\nFiles : " + countFiles + "\nCode rows : " + codeRows + "\nRemoved rows : " + removedRows, 1, "OpenCL Kernels to cpp file", 64);

modules/ocl/cl2cpp.py

-import os, os.path, sys, glob
-
-indir = sys.argv[1]
-outname = sys.argv[2]
-#indir = "/Users/vp/work/ocv/opencv/modules/ocl/src/kernels"
-#outname = "/Users/vp/work/ocv.build/xcode/modules/ocl/kernels.cpp"
-
-try:
-    os.mkdir(os.path.dirname(outname))
-except OSError:
-    pass
-
-cl_list = glob.glob(os.path.join(indir, "*.cl"))
-kfile = open(outname, "wt")
-
-kfile.write("""// This file is auto-generated. Do not edit!
-
-namespace cv
-{
-namespace ocl
-{
-""")
-
-for cl in cl_list:
-    cl_file = open(cl, "rt")
-    cl_filename = os.path.basename(cl)
-    cl_filename = cl_filename[:cl_filename.rfind(".")]
-    kfile.write("const char* %s=" % cl_filename)
-    state = 0
-
-    for cl_line in cl_file.readlines():
-        l = cl_line.strip()
-        # skip the leading comments
-        if l.startswith("//") and l.find("*/") < 0:
-            if state == 0:
-                state = 1
-        else:
-            if state == 1 or l.find("*/") >= 0:
-                state = 2
-
-        if state == 1:
-            continue
-
-        l = l.replace("\\", "\\\\")
-        l = l.replace("\r", "")
-        l = l.replace("\"", "\\\"")
-        l = l.replace("\t", "  ")
-        kfile.write("\"%s\\n\"\n" % l)
-    kfile.write(";\n")
-    cl_file.close()
-
-kfile.write("""}
-}
-""")
-kfile.close()

modules/ocl/src/precomp.hpp

@@ -63,16 +63,14 @@
 #include <exception>
 #include <stdio.h>
 
-#include "opencv2/ocl/ocl.hpp"
-
-#include "opencv2/imgproc/imgproc.hpp"
-
-#include "opencv2/objdetect/objdetect.hpp"
 #include "opencv2/imgproc/imgproc.hpp"
 #include "opencv2/imgproc/imgproc_c.h"
 #include "opencv2/core/core_c.h"
-//#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/objdetect/objdetect.hpp"
+#include "opencv2/ocl/ocl.hpp"
+
 #include "opencv2/core/internal.hpp"
+//#include "opencv2/highgui/highgui.hpp"
 
 #define __ATI__