generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch '2.4'

Browse Source
This commit is contained in:
Andrey Kamaev 2012-10-25 15:32:48 +04:00
commit 729d76ad09
9 changed files with 283 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
modules/core/include/opencv2/core/core.hpp
View File

@ -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;

10
modules/core/include/opencv2/core/internal.hpp
View File

@ -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; \
\

16
modules/core/include/opencv2/core/operations.hpp
View File

@ -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;

200
modules/core/src/algorithm.cpp
View File

@ -114,7 +114,7 @@ template<typename _ValueTp> inline const _ValueTp* findstr(const sorted_vector<s
b = c;
}
if( strcmp(vec.vec[a].first.c_str(), key) == 0 )
if( ( a < vec.vec.size() ) && ( strcmp(vec.vec[a].first.c_str(), key) == 0 ))
return &vec.vec[a].second;
return 0;
}
@ -251,6 +251,79 @@ void Algorithm::set(const char* parameter, const Ptr<Algorithm>& value)
info()->set(this, parameter, ParamType<Algorithm>::type, &value);
}
void Algorithm::setInt(const string& parameter, int value)
{
info()->set(this, parameter.c_str(), ParamType<int>::type, &value);
}
void Algorithm::setDouble(const string& parameter, double value)
{
info()->set(this, parameter.c_str(), ParamType<double>::type, &value);
}
void Algorithm::setBool(const string& parameter, bool value)
{
info()->set(this, parameter.c_str(), ParamType<bool>::type, &value);
}
void Algorithm::setString(const string& parameter, const string& value)
{
info()->set(this, parameter.c_str(), ParamType<string>::type, &value);
}
void Algorithm::setMat(const string& parameter, const Mat& value)
{
info()->set(this, parameter.c_str(), ParamType<Mat>::type, &value);
}
void Algorithm::setMatVector(const string& parameter, const vector<Mat>& value)
{
info()->set(this, parameter.c_str(), ParamType<vector<Mat> >::type, &value);
}
void Algorithm::setAlgorithm(const string& parameter, const Ptr<Algorithm>& value)
{
info()->set(this, parameter.c_str(), ParamType<Algorithm>::type, &value);
}
void Algorithm::setInt(const char* parameter, int value)
{
info()->set(this, parameter, ParamType<int>::type, &value);
}
void Algorithm::setDouble(const char* parameter, double value)
{
info()->set(this, parameter, ParamType<double>::type, &value);
}
void Algorithm::setBool(const char* parameter, bool value)
{
info()->set(this, parameter, ParamType<bool>::type, &value);
}
void Algorithm::setString(const char* parameter, const string& value)
{
info()->set(this, parameter, ParamType<string>::type, &value);
}
void Algorithm::setMat(const char* parameter, const Mat& value)
{
info()->set(this, parameter, ParamType<Mat>::type, &value);
}
void Algorithm::setMatVector(const char* parameter, const vector<Mat>& value)
{
info()->set(this, parameter, ParamType<vector<Mat> >::type, &value);
}
void Algorithm::setAlgorithm(const char* parameter, const Ptr<Algorithm>& value)
{
info()->set(this, parameter, ParamType<Algorithm>::type, &value);
}
int Algorithm::getInt(const string& parameter) const
{
return get<int>(parameter);
@ -441,6 +514,59 @@ union GetSetParam
void (Algorithm::*set_algo)(const Ptr<Algorithm>&);
};
static string getNameOfType(int argType);
static string getNameOfType(int argType)
{
switch(argType)
{
case Param::INT: return "integer";
case Param::BOOLEAN: return "boolean";
case Param::REAL: return "double";
case Param::STRING: return "string";
case Param::MAT: return "cv::Mat";
case Param::MAT_VECTOR: return "std::vector<cv::Mat>";
case Param::ALGORITHM: return "algorithm";
default: CV_Error(CV_StsBadArg, "Wrong argument type");
}
return "";
}
static string getErrorMessageForWrongArgumentInSetter(string algoName, string paramName, int paramType, int argType);
static string getErrorMessageForWrongArgumentInSetter(string algoName, string paramName, int paramType, int argType)
{
string message = string("Argument error: the setter")
+ " method was called for the parameter '" + paramName + "' of the algorithm '" + algoName
+"', the parameter has " + getNameOfType(paramType) + " type, ";
if (paramType == Param::INT || paramType == Param::BOOLEAN || paramType == Param::REAL)
{
message += "so it should be set by integer, boolean, or double value, ";
}
message += "but the setter was called with " + getNameOfType(argType) + " value";
return message;
}
static string getErrorMessageForWrongArgumentInGetter(string algoName, string paramName, int paramType, int argType);
static string getErrorMessageForWrongArgumentInGetter(string algoName, string paramName, int paramType, int argType)
{
string message = string("Argument error: the getter")
+ " method was called for the parameter '" + paramName + "' of the algorithm '" + algoName
+"', the parameter has " + getNameOfType(paramType) + " type, ";
if (paramType == Param::BOOLEAN)
{
message += "so it should be get as integer, boolean, or double value, ";
}
else if (paramType == Param::INT)
{
message += "so it should be get as integer or double value, ";
}
message += "but the getter was called to get a " + getNameOfType(argType) + " value";
return message;
}
void AlgorithmInfo::set(Algorithm* algo, const char* parameter, int argType, const void* value, bool force) const
{
const Param* p = findstr(data->params, parameter);
@ -456,7 +582,11 @@ void AlgorithmInfo::set(Algorithm* algo, const char* parameter, int argType, con
if( argType == Param::INT || argType == Param::BOOLEAN || argType == Param::REAL )
{
CV_Assert( p->type == Param::INT || p->type == Param::REAL || p->type == Param::BOOLEAN );
if ( !( p->type == Param::INT || p->type == Param::REAL || p->type == Param::BOOLEAN) )
{
string message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType);
CV_Error(CV_StsBadArg, message);
}
if( p->type == Param::INT )
{
@ -491,7 +621,11 @@ void AlgorithmInfo::set(Algorithm* algo, const char* parameter, int argType, con
}
else if( argType == Param::STRING )
{
CV_Assert( p->type == Param::STRING );
if( p->type != Param::STRING )
{
string message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType);
CV_Error(CV_StsBadArg, message);
}
const string& val = *(const string*)value;
if( p->setter )
@ -501,7 +635,11 @@ void AlgorithmInfo::set(Algorithm* algo, const char* parameter, int argType, con
}
else if( argType == Param::MAT )
{
CV_Assert( p->type == Param::MAT );
if( p->type != Param::MAT )
{
string message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType);
CV_Error(CV_StsBadArg, message);
}
const Mat& val = *(const Mat*)value;
if( p->setter )
@ -511,7 +649,11 @@ void AlgorithmInfo::set(Algorithm* algo, const char* parameter, int argType, con
}
else if( argType == Param::MAT_VECTOR )
{
CV_Assert( p->type == Param::MAT_VECTOR );
if( p->type != Param::MAT_VECTOR )
{
string message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType);
CV_Error(CV_StsBadArg, message);
}
const vector<Mat>& val = *(const vector<Mat>*)value;
if( p->setter )
@ -521,7 +663,11 @@ void AlgorithmInfo::set(Algorithm* algo, const char* parameter, int argType, con
}
else if( argType == Param::ALGORITHM )
{
CV_Assert( p->type == Param::ALGORITHM );
if( p->type != Param::ALGORITHM )
{
string message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType);
CV_Error(CV_StsBadArg, message);
}
const Ptr<Algorithm>& val = *(const Ptr<Algorithm>*)value;
if( p->setter )
@ -546,7 +692,11 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp
{
if( p->type == Param::INT )
{
CV_Assert( argType == Param::INT || argType == Param::REAL );
if (!( argType == Param::INT || argType == Param::REAL ))
{
string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
CV_Error(CV_StsBadArg, message);
}
int val = p->getter ? (algo->*f.get_int)() : *(int*)((uchar*)algo + p->offset);
if( argType == Param::INT )
@ -556,7 +706,11 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp
}
else if( p->type == Param::BOOLEAN )
{
CV_Assert( argType == Param::INT || argType == Param::BOOLEAN || argType == Param::REAL );
if (!( argType == Param::INT || argType == Param::BOOLEAN || argType == Param::REAL ))
{
string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
CV_Error(CV_StsBadArg, message);
}
bool val = p->getter ? (algo->*f.get_bool)() : *(bool*)((uchar*)algo + p->offset);
if( argType == Param::INT )
@ -568,7 +722,11 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp
}
else
{
CV_Assert( argType == Param::REAL );
if( argType != Param::REAL )
{
string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
CV_Error(CV_StsBadArg, message);
}
double val = p->getter ? (algo->*f.get_double)() : *(double*)((uchar*)algo + p->offset);
*(double*)value = val;
@ -576,28 +734,44 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp
}
else if( argType == Param::STRING )
{
CV_Assert( p->type == Param::STRING );
if( p->type != Param::STRING )
{
string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
CV_Error(CV_StsBadArg, message);
}
*(string*)value = p->getter ? (algo->*f.get_string)() :
*(string*)((uchar*)algo + p->offset);
}
else if( argType == Param::MAT )
{
CV_Assert( p->type == Param::MAT );
if( p->type != Param::MAT )
{
string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
CV_Error(CV_StsBadArg, message);
}
*(Mat*)value = p->getter ? (algo->*f.get_mat)() :
*(Mat*)((uchar*)algo + p->offset);
}
else if( argType == Param::MAT_VECTOR )
{
CV_Assert( p->type == Param::MAT_VECTOR );
if( p->type != Param::MAT_VECTOR )
{
string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
CV_Error(CV_StsBadArg, message);
}
*(vector<Mat>*)value = p->getter ? (algo->*f.get_mat_vector)() :
*(vector<Mat>*)((uchar*)algo + p->offset);
}
else if( argType == Param::ALGORITHM )
{
CV_Assert( p->type == Param::ALGORITHM );
if( p->type != Param::ALGORITHM )
{
string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
CV_Error(CV_StsBadArg, message);
}
*(Ptr<Algorithm>*)value = p->getter ? (algo->*f.get_algo)() :
*(Ptr<Algorithm>*)((uchar*)algo + p->offset);

36
modules/ocl/CMakeLists.txt
View File

@ -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(
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}
DEPENDS ${CL_FILES} ${cl2cpp_script})
ENDIF()
add_custom_command(
OUTPUT ${kernels_cpp}
COMMAND ${CMAKE_COMMAND} -DCL_DIR="${CMAKE_CURRENT_SOURCE_DIR}/src/kernels" -DOUTPUT="${kernels_cpp}" -P ${cl2cpp_script}
DEPENDS ${CL_FILES} ${cl2cpp_script})
file(GLOB lib_hdrs "include/opencv2/${name}/*.hpp" "include/opencv2/${name}/*.h")
file(GLOB lib_srcs "src/*.cpp")
@ -35,7 +27,7 @@ source_group("Src\\Host" FILES ${lib_srcs} ${lib_int_hdrs} ${kernels_cpp})
if (HAVE_OPENCL)
set(ocl_link_libs ${OPENCL_LIBRARIES})
if(OPENCL_INCLUDE_DIR)
ocv_include_directories(${OPENCL_INCLUDE_DIR})
ocv_include_directories(${OPENCL_INCLUDE_DIR})
endif()
if (HAVE_CLAMDFFT)
set(ocl_link_libs ${ocl_link_libs} ${CLAMDFFT_LIBRARIES})
@ -47,17 +39,12 @@ 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}
DESTINATION include/opencv2/${name}
COMPONENT main)
DESTINATION include/opencv2/${name}
COMPONENT main)
ocv_add_precompiled_headers(${the_module})
@ -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 ##################################################
################################################################################################################
@ -76,4 +64,4 @@ file(GLOB perf_srcs "perf/*.cpp")
file(GLOB perf_hdrs "perf/*.hpp" "perf/*.h")
ocv_add_perf_tests(FILES "Include" ${perf_hdrs}
FILES "Src" ${perf_srcs})
FILES "Src" ${perf_srcs})

34
modules/ocl/cl2cpp.cmake Normal file
View File

@ -0,0 +1,34 @@
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")

40
modules/ocl/cl2cpp.js
View File

@ -1,40 +0,0 @@
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);

55
modules/ocl/cl2cpp.py
View File

@ -1,55 +0,0 @@
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()

10
modules/ocl/src/precomp.hpp
View File

@ -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__