Chiebot-Mirror
/
opencv
mirror of https://github.com/opencv/opencv.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #524 from LeonidBeynenson:add_float_and_unsigned_parameters_to_cv_algorithm

Browse Source
pull/552/head
Andrey Kamaev 12 years ago committed by OpenCV Buildbot
parent 11b83d4000 41dc829341
commit 0d12f451be
4 changed files with 402 additions and 23 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 29
      modules/core/include/opencv2/core/core.hpp
  2. 375
      modules/core/src/algorithm.cpp
  3. 1
      modules/features2d/include/opencv2/features2d/features2d.hpp
  4. 20
      modules/features2d/src/features2d_init.cpp

29
modules/core/include/opencv2/core/core.hpp
Unescape View File

@ -4479,6 +4479,26 @@ public:
Ptr<Algorithm> (Algorithm::*getter)()=0,
void (Algorithm::*setter)(const Ptr<Algorithm>&)=0,
const string& help=string());
void addParam(Algorithm& algo, const char* name,
float& value, bool readOnly=false,
float (Algorithm::*getter)()=0,
void (Algorithm::*setter)(float)=0,
const string& help=string());
void addParam(Algorithm& algo, const char* name,
unsigned int& value, bool readOnly=false,
unsigned int (Algorithm::*getter)()=0,
void (Algorithm::*setter)(unsigned int)=0,
const string& help=string());
void addParam(Algorithm& algo, const char* name,
uint64& value, bool readOnly=false,
uint64 (Algorithm::*getter)()=0,
void (Algorithm::*setter)(uint64)=0,
const string& help=string());
void addParam(Algorithm& algo, const char* name,
uchar& value, bool readOnly=false,
uchar (Algorithm::*getter)()=0,
void (Algorithm::*setter)(uchar)=0,
const string& help=string());
template<typename _Tp, typename _Base> void addParam(Algorithm& algo, const char* name,
Ptr<_Tp>& value, bool readOnly=false,
Ptr<_Tp> (Algorithm::*getter)()=0,
@ -4498,7 +4518,7 @@ protected:
struct CV_EXPORTS Param
{
enum { INT=0, BOOLEAN=1, REAL=2, STRING=3, MAT=4, MAT_VECTOR=5, ALGORITHM=6, FLOAT=7, UNSIGNED_INT=8, UINT64=9, SHORT=10 };
enum { INT=0, BOOLEAN=1, REAL=2, STRING=3, MAT=4, MAT_VECTOR=5, ALGORITHM=6, FLOAT=7, UNSIGNED_INT=8, UINT64=9, SHORT=10, UCHAR=11 };
Param();
Param(int _type, bool _readonly, int _offset,
@ -4601,6 +4621,13 @@ template<> struct ParamType<uint64>
enum { type = Param::UINT64 };
};
template<> struct ParamType<uchar>
{
typedef uchar const_param_type;
typedef uchar member_type;
enum { type = Param::UCHAR };
};
/*!
"\nThe CommandLineParser class is designed for command line arguments parsing\n"

375
modules/core/src/algorithm.cpp
Unescape View File

@ -324,6 +324,7 @@ void Algorithm::setAlgorithm(const char* parameter, const Ptr<Algorithm>& value)
int Algorithm::getInt(const string& parameter) const
{
return get<int>(parameter);
@ -431,6 +432,14 @@ void AlgorithmInfo::write(const Algorithm* algo, FileStorage& fs) const
Ptr<Algorithm> nestedAlgo = algo->get<Algorithm>(pname);
nestedAlgo->write(fs);
}
else if( p.type == Param::FLOAT)
cv::write(fs, pname, algo->getDouble(pname));
else if( p.type == Param::UNSIGNED_INT)
cv::write(fs, pname, algo->getInt(pname));//TODO: implement cv::write(, , unsigned int)
else if( p.type == Param::UINT64)
cv::write(fs, pname, algo->getInt(pname));//TODO: implement cv::write(, , uint64)
else if( p.type == Param::UCHAR)
cv::write(fs, pname, algo->getInt(pname));
else
{
string msg = format("unknown/unsupported type of '%s' parameter == %d", pname.c_str(), p.type);
@ -490,6 +499,26 @@ void AlgorithmInfo::read(Algorithm* algo, const FileNode& fn) const
nestedAlgo->read(n);
info->set(algo, pname.c_str(), p.type, &nestedAlgo, true);
}
else if( p.type == Param::FLOAT )
{
float val = (float)n;
info->set(algo, pname.c_str(), p.type, &val, true);
}
else if( p.type == Param::UNSIGNED_INT )
{
unsigned int val = (unsigned int)((int)n);//TODO: implement conversion (unsigned int)FileNode
info->set(algo, pname.c_str(), p.type, &val, true);
}
else if( p.type == Param::UINT64)
{
uint64 val = (uint64)((int)n);//TODO: implement conversion (uint64)FileNode
info->set(algo, pname.c_str(), p.type, &val, true);
}
else if( p.type == Param::UCHAR)
{
uchar val = (uchar)((int)n);
info->set(algo, pname.c_str(), p.type, &val, true);
}
else
{
string msg = format("unknown/unsupported type of '%s' parameter == %d", pname.c_str(), p.type);
@ -512,6 +541,10 @@ union GetSetParam
Mat (Algorithm::*get_mat)() const;
vector<Mat> (Algorithm::*get_mat_vector)() const;
Ptr<Algorithm> (Algorithm::*get_algo)() const;
float (Algorithm::*get_float)() const;
unsigned int (Algorithm::*get_uint)() const;
uint64 (Algorithm::*get_uint64)() const;
uchar (Algorithm::*get_uchar)() const;
void (Algorithm::*set_int)(int);
void (Algorithm::*set_bool)(bool);
@ -520,6 +553,10 @@ union GetSetParam
void (Algorithm::*set_mat)(const Mat&);
void (Algorithm::*set_mat_vector)(const vector<Mat>&);
void (Algorithm::*set_algo)(const Ptr<Algorithm>&);
void (Algorithm::*set_float)(float);
void (Algorithm::*set_uint)(unsigned int);
void (Algorithm::*set_uint64)(uint64);
void (Algorithm::*set_uchar)(uchar);
};
static string getNameOfType(int argType);
@ -536,6 +573,10 @@ static string getNameOfType(int argType)
case Param::MAT: return "cv::Mat";
case Param::MAT_VECTOR: return "std::vector<cv::Mat>";
case Param::ALGORITHM: return "algorithm";
case Param::FLOAT: return "float";
case Param::UNSIGNED_INT: return "unsigned int";
case Param::UINT64: return "unsigned int64";
case Param::UCHAR: return "unsigned char";
default: CV_Error(CV_StsBadArg, "Wrong argument type");
}
return "";
@ -547,9 +588,10 @@ static string getErrorMessageForWrongArgumentInSetter(string algoName, string pa
+ " 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)
if (paramType == Param::INT || paramType == Param::BOOLEAN || paramType == Param::REAL
|| paramType == Param::FLOAT || paramType == Param::UNSIGNED_INT || paramType == Param::UINT64 || paramType == Param::UCHAR)
{
message += "so it should be set by integer, boolean, or double value, ";
message += "so it should be set by integer, unsigned integer, uint64, unsigned char, boolean, float or double value, ";
}
else if (paramType == Param::SHORT)
{
@ -569,16 +611,20 @@ static string getErrorMessageForWrongArgumentInGetter(string algoName, string pa
if (paramType == Param::BOOLEAN)
{
message += "so it should be get as integer, boolean, or double value, ";
message += "so it should be get as integer, unsigned integer, uint64, boolean, unsigned char, float or double value, ";
}
else if (paramType == Param::INT)
else if (paramType == Param::INT || paramType == Param::UNSIGNED_INT || paramType == Param::UINT64 || paramType == Param::UCHAR)
{
message += "so it should be get as integer or double value, ";
message += "so it should be get as integer, unsigned integer, uint64, unsigned char, float or double value, ";
}
else if (paramType == Param::SHORT)
{
message += "so it should be get as integer value, ";
}
else if (paramType == Param::FLOAT || paramType == Param::REAL)
{
message += "so it should be get as float or double value, ";
}
message += "but the getter was called to get a " + getNameOfType(argType) + " value";
return message;
@ -597,9 +643,12 @@ void AlgorithmInfo::set(Algorithm* algo, const char* parameter, int argType, con
GetSetParam f;
f.set_int = p->setter;
if( argType == Param::INT || argType == Param::BOOLEAN || argType == Param::REAL || argType == Param::SHORT )
if( argType == Param::INT || argType == Param::BOOLEAN || argType == Param::REAL || argType == Param::SHORT
|| argType == Param::FLOAT || argType == Param::UNSIGNED_INT || argType == Param::UINT64 || argType == Param::UCHAR)
{
if ( !( p->type == Param::INT || p->type == Param::REAL || p->type == Param::BOOLEAN || (p->type == Param::SHORT && argType == Param::INT)) )
if ( !( p->type == Param::INT || p->type == Param::REAL || p->type == Param::BOOLEAN
|| p->type == Param::UNSIGNED_INT || p->type == Param::UINT64 || p->type == Param::FLOAT || argType == Param::UCHAR
|| (p->type == Param::SHORT && argType == Param::INT)) )
{
string message = getErrorMessageForWrongArgumentInSetter(algo->name(), parameter, p->type, argType);
CV_Error(CV_StsBadArg, message);
@ -607,9 +656,21 @@ void AlgorithmInfo::set(Algorithm* algo, const char* parameter, int argType, con
if( p->type == Param::INT )
{
bool is_ok = true;
int val = argType == Param::INT ? *(const int*)value :
argType == Param::BOOLEAN ? (int)*(const bool*)value :
saturate_cast<int>(*(const double*)value);
argType == Param::BOOLEAN ? (int)*(const bool*)value :
argType == Param::REAL ? saturate_cast<int>(*(const double*)value) :
argType == Param::FLOAT ? saturate_cast<int>(*(const float*)value) :
argType == Param::UNSIGNED_INT ? (int)*(const unsigned int*)value :
argType == Param::UINT64 ? (int)*(const uint64*)value :
argType == Param::UCHAR ? (int)*(const uchar*)value :
(int)(is_ok = false);
if (!is_ok)
{
CV_Error(CV_StsBadArg, "Wrong argument type in the setter");
}
if( p->setter )
(algo->*f.set_int)(val);
else
@ -617,6 +678,7 @@ void AlgorithmInfo::set(Algorithm* algo, const char* parameter, int argType, con
}
else if( p->type == Param::SHORT )
{
CV_DbgAssert(argType == Param::INT);
int val = *(const int*)value;
if( p->setter )
(algo->*f.set_int)(val);
@ -625,24 +687,133 @@ void AlgorithmInfo::set(Algorithm* algo, const char* parameter, int argType, con
}
else if( p->type == Param::BOOLEAN )
{
bool is_ok = true;
bool val = argType == Param::INT ? *(const int*)value != 0 :
argType == Param::BOOLEAN ? *(const bool*)value :
*(const double*)value != 0;
argType == Param::REAL ? (*(const double*)value != 0) :
argType == Param::FLOAT ? (*(const float*)value != 0) :
argType == Param::UNSIGNED_INT ? (*(const unsigned int*)value != 0):
argType == Param::UINT64 ? (*(const uint64*)value != 0):
argType == Param::UCHAR ? (*(const uchar*)value != 0):
(int)(is_ok = false);
if (!is_ok)
{
CV_Error(CV_StsBadArg, "Wrong argument type in the setter");
}
if( p->setter )
(algo->*f.set_bool)(val);
else
*(bool*)((uchar*)algo + p->offset) = val;
}
else
else if( p->type == Param::REAL )
{
bool is_ok = true;
double val = argType == Param::INT ? (double)*(const int*)value :
argType == Param::BOOLEAN ? (double)*(const bool*)value :
*(const double*)value;
argType == Param::REAL ? (double)(*(const double*)value ) :
argType == Param::FLOAT ? (double)(*(const float*)value ) :
argType == Param::UNSIGNED_INT ? (double)(*(const unsigned int*)value ) :
argType == Param::UINT64 ? (double)(*(const uint64*)value ) :
argType == Param::UCHAR ? (double)(*(const uchar*)value ) :
(double)(is_ok = false);
if (!is_ok)
{
CV_Error(CV_StsBadArg, "Wrong argument type in the setter");
}
if( p->setter )
(algo->*f.set_double)(val);
else
*(double*)((uchar*)algo + p->offset) = val;
}
else if( p->type == Param::FLOAT )
{
bool is_ok = true;
double val = argType == Param::INT ? (double)*(const int*)value :
argType == Param::BOOLEAN ? (double)*(const bool*)value :
argType == Param::REAL ? (double)(*(const double*)value ) :
argType == Param::FLOAT ? (double)(*(const float*)value ) :
argType == Param::UNSIGNED_INT ? (double)(*(const unsigned int*)value ) :
argType == Param::UINT64 ? (double)(*(const uint64*)value ) :
argType == Param::UCHAR ? (double)(*(const uchar*)value ) :
(double)(is_ok = false);
if (!is_ok)
{
CV_Error(CV_StsBadArg, "Wrong argument type in the setter");
}
if( p->setter )
(algo->*f.set_float)((float)val);
else
*(float*)((uchar*)algo + p->offset) = (float)val;
}
else if( p->type == Param::UNSIGNED_INT )
{
bool is_ok = true;
unsigned int val = argType == Param::INT ? (unsigned int)*(const int*)value :
argType == Param::BOOLEAN ? (unsigned int)*(const bool*)value :
argType == Param::REAL ? saturate_cast<unsigned int>(*(const double*)value ) :
argType == Param::FLOAT ? saturate_cast<unsigned int>(*(const float*)value ) :
argType == Param::UNSIGNED_INT ? (unsigned int)(*(const unsigned int*)value ) :
argType == Param::UINT64 ? (unsigned int)(*(const uint64*)value ) :
argType == Param::UCHAR ? (unsigned int)(*(const uchar*)value ) :
(int)(is_ok = false);
if (!is_ok)
{
CV_Error(CV_StsBadArg, "Wrong argument type in the setter");
}
if( p->setter )
(algo->*f.set_uint)(val);
else
*(unsigned int*)((uchar*)algo + p->offset) = val;
}
else if( p->type == Param::UINT64 )
{
bool is_ok = true;
uint64 val = argType == Param::INT ? (uint64)*(const int*)value :
argType == Param::BOOLEAN ? (uint64)*(const bool*)value :
argType == Param::REAL ? saturate_cast<uint64>(*(const double*)value ) :
argType == Param::FLOAT ? saturate_cast<uint64>(*(const float*)value ) :
argType == Param::UNSIGNED_INT ? (uint64)(*(const unsigned int*)value ) :
argType == Param::UINT64 ? (uint64)(*(const uint64*)value ) :
argType == Param::UCHAR ? (uint64)(*(const uchar*)value ) :
(int)(is_ok = false);
if (!is_ok)
{
CV_Error(CV_StsBadArg, "Wrong argument type in the setter");
}
if( p->setter )
(algo->*f.set_uint64)(val);
else
*(uint64*)((uchar*)algo + p->offset) = val;
}
else if( p->type == Param::UCHAR )
{
bool is_ok = true;
uchar val = argType == Param::INT ? (uchar)*(const int*)value :
argType == Param::BOOLEAN ? (uchar)*(const bool*)value :
argType == Param::REAL ? saturate_cast<uchar>(*(const double*)value ) :
argType == Param::FLOAT ? saturate_cast<uchar>(*(const float*)value ) :
argType == Param::UNSIGNED_INT ? (uchar)(*(const unsigned int*)value ) :
argType == Param::UINT64 ? (uchar)(*(const uint64*)value ) :
argType == Param::UCHAR ? (uchar)(*(const uchar*)value ) :
(int)(is_ok = false);
if (!is_ok)
{
CV_Error(CV_StsBadArg, "Wrong argument type in the setter");
}
if( p->setter )
(algo->*f.set_uchar)(val);
else
*(uchar*)((uchar*)algo + p->offset) = val;
}
else
CV_Error(CV_StsBadArg, "Wrong parameter type in the setter");
}
else if( argType == Param::STRING )
{
@ -713,11 +884,12 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp
GetSetParam f;
f.get_int = p->getter;
if( argType == Param::INT || argType == Param::BOOLEAN || argType == Param::REAL )
if( argType == Param::INT || argType == Param::BOOLEAN || argType == Param::REAL || argType == Param::SHORT
|| argType == Param::FLOAT || argType == Param::UNSIGNED_INT || argType == Param::UINT64 || argType == Param::UCHAR)
{
if( p->type == Param::INT )
{
if (!( argType == Param::INT || argType == Param::REAL ))
if (!( argType == Param::INT || argType == Param::REAL || argType == Param::FLOAT || argType == Param::UNSIGNED_INT || argType == Param::UINT64 || argType == Param::UCHAR))
{
string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
CV_Error(CV_StsBadArg, message);
@ -725,9 +897,20 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp
int val = p->getter ? (algo->*f.get_int)() : *(int*)((uchar*)algo + p->offset);
if( argType == Param::INT )
*(int*)value = val;
*(int*)value = (int)val;
else if ( argType == Param::REAL )
*(double*)value = (double)val;
else if ( argType == Param::FLOAT)
*(float*)value = (float)val;
else if ( argType == Param::UNSIGNED_INT )
*(unsigned int*)value = (unsigned int)val;
else if ( argType == Param::UINT64 )
*(uint64*)value = (uint64)val;
else if ( argType == Param::UCHAR)
*(uchar*)value = (uchar)val;
else
*(double*)value = val;
CV_Error(CV_StsBadArg, "Wrong argument type");
}
else if( p->type == Param::SHORT )
{
@ -742,7 +925,7 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp
}
else if( p->type == Param::BOOLEAN )
{
if (!( argType == Param::INT || argType == Param::BOOLEAN || argType == Param::REAL ))
if (!( argType == Param::INT || argType == Param::BOOLEAN || argType == Param::REAL || argType == Param::FLOAT || argType == Param::UNSIGNED_INT || argType == Param::UINT64 || argType == Param::UCHAR))
{
string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
CV_Error(CV_StsBadArg, message);
@ -753,20 +936,126 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argTyp
*(int*)value = (int)val;
else if( argType == Param::BOOLEAN )
*(bool*)value = val;
else
else if ( argType == Param::REAL )
*(double*)value = (int)val;
else if ( argType == Param::FLOAT)
*(float*)value = (float)((int)val);
else if ( argType == Param::UNSIGNED_INT )
*(unsigned int*)value = (unsigned int)val;
else if ( argType == Param::UINT64 )
*(uint64*)value = (int)val;
else if ( argType == Param::UCHAR)
*(uchar*)value = (uchar)val;
else
CV_Error(CV_StsBadArg, "Wrong argument type");
}
else
else if( p->type == Param::REAL )
{
if( argType != Param::REAL )
if(!( argType == Param::REAL || argType == Param::FLOAT))
{
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;
if ( argType == Param::REAL )
*(double*)value = val;
else if ( argType == Param::FLOAT)
*(float*)value = (float)val;
else
CV_Error(CV_StsBadArg, "Wrong argument type");
}
else if( p->type == Param::FLOAT )
{
if(!( argType == Param::REAL || argType == Param::FLOAT))
{
string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
CV_Error(CV_StsBadArg, message);
}
float val = p->getter ? (algo->*f.get_float)() : *(float*)((uchar*)algo + p->offset);
if ( argType == Param::REAL )
*(double*)value = (double)val;
else if ( argType == Param::FLOAT)
*(float*)value = (float)val;
else
CV_Error(CV_StsBadArg, "Wrong argument type");
}
else if( p->type == Param::UNSIGNED_INT )
{
if (!( argType == Param::INT || argType == Param::REAL || argType == Param::FLOAT || argType == Param::UNSIGNED_INT || argType == Param::UINT64 || argType == Param::UCHAR))
{
string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
CV_Error(CV_StsBadArg, message);
}
unsigned int val = p->getter ? (algo->*f.get_uint)() : *(unsigned int*)((uchar*)algo + p->offset);
if( argType == Param::INT )
*(int*)value = (int)val;
else if ( argType == Param::REAL )
*(double*)value = (double)val;
else if ( argType == Param::FLOAT)
*(float*)value = (float)val;
else if ( argType == Param::UNSIGNED_INT )
*(unsigned int*)value = (unsigned int)val;
else if ( argType == Param::UINT64 )
*(uint64*)value = (uint64)val;
else if ( argType == Param::UCHAR)
*(uchar*)value = (uchar)val;
else
CV_Error(CV_StsBadArg, "Wrong argument type");
}
else if( p->type == Param::UINT64 )
{
if (!( argType == Param::INT || argType == Param::REAL || argType == Param::FLOAT || argType == Param::UNSIGNED_INT || argType == Param::UINT64 || argType == Param::UCHAR))
{
string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
CV_Error(CV_StsBadArg, message);
}
uint64 val = p->getter ? (algo->*f.get_uint64)() : *(uint64*)((uchar*)algo + p->offset);
if( argType == Param::INT )
*(int*)value = (int)val;
else if ( argType == Param::REAL )
*(double*)value = (double)val;
else if ( argType == Param::FLOAT)
*(float*)value = (float)val;
else if ( argType == Param::UNSIGNED_INT )
*(unsigned int*)value = (unsigned int)val;
else if ( argType == Param::UINT64 )
*(uint64*)value = (uint64)val;
else if ( argType == Param::UCHAR)
*(uchar*)value = (uchar)val;
else
CV_Error(CV_StsBadArg, "Wrong argument type");
}
else if( p->type == Param::UCHAR )
{
if (!( argType == Param::INT || argType == Param::REAL || argType == Param::FLOAT || argType == Param::UNSIGNED_INT || argType == Param::UINT64 || argType == Param::UCHAR))
{
string message = getErrorMessageForWrongArgumentInGetter(algo->name(), parameter, p->type, argType);
CV_Error(CV_StsBadArg, message);
}
uchar val = p->getter ? (algo->*f.get_uchar)() : *(uchar*)((uchar*)algo + p->offset);
if( argType == Param::INT )
*(int*)value = val;
else if ( argType == Param::REAL )
*(double*)value = val;
else if ( argType == Param::FLOAT)
*(float*)value = val;
else if ( argType == Param::UNSIGNED_INT )
*(unsigned int*)value = val;
else if ( argType == Param::UINT64 )
*(uint64*)value = val;
else if ( argType == Param::UCHAR)
*(uchar*)value = val;
else
CV_Error(CV_StsBadArg, "Wrong argument type");
}
else
CV_Error(CV_StsBadArg, "Unknown/unsupported parameter type");
}
else if( argType == Param::STRING )
{
@ -852,7 +1141,9 @@ void AlgorithmInfo::addParam_(Algorithm& algo, const char* parameter, int argTyp
CV_Assert( argType == Param::INT || argType == Param::BOOLEAN ||
argType == Param::REAL || argType == Param::STRING ||
argType == Param::MAT || argType == Param::MAT_VECTOR ||
argType == Param::ALGORITHM || argType == Param::SHORT );
argType == Param::ALGORITHM || argType == Param::SHORT
|| argType == Param::FLOAT || argType == Param::UNSIGNED_INT || argType == Param::UINT64
|| argType == Param::UCHAR);
data->params.add(string(parameter), Param(argType, readOnly,
(int)((size_t)value - (size_t)(void*)&algo),
getter, setter, help));
@ -939,6 +1230,46 @@ void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
(Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
}
void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
float& value, bool readOnly,
float (Algorithm::*getter)(),
void (Algorithm::*setter)(float),
const string& help)
{
addParam_(algo, parameter, ParamType<float>::type, &value, readOnly,
(Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
}
void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
unsigned int& value, bool readOnly,
unsigned int (Algorithm::*getter)(),
void (Algorithm::*setter)(unsigned int),
const string& help)
{
addParam_(algo, parameter, ParamType<unsigned int>::type, &value, readOnly,
(Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
}
void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
uint64& value, bool readOnly,
uint64 (Algorithm::*getter)(),
void (Algorithm::*setter)(uint64),
const string& help)
{
addParam_(algo, parameter, ParamType<uint64>::type, &value, readOnly,
(Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
}
void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
uchar& value, bool readOnly,
uchar (Algorithm::*getter)(),
void (Algorithm::*setter)(uchar),
const string& help)
{
addParam_(algo, parameter, ParamType<uchar>::type, &value, readOnly,
(Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
}
}
/* End of file. */

1
modules/features2d/include/opencv2/features2d/features2d.hpp
Unescape View File

@ -658,6 +658,7 @@ protected:
virtual void findBlobs(const Mat &image, const Mat &binaryImage, vector<Center> &centers) const;
Params params;
AlgorithmInfo* info() const;
};

20
modules/features2d/src/features2d_init.cpp
Unescape View File

@ -130,6 +130,26 @@ CV_INIT_ALGORITHM(GFTTDetector, "Feature2D.GFTT",
///////////////////////////////////////////////////////////////////////////////////////////////////////////
CV_INIT_ALGORITHM(SimpleBlobDetector, "Feature2D.SimpleBlob",
obj.info()->addParam(obj, "thresholdStep", obj.params.thresholdStep);
obj.info()->addParam(obj, "minThreshold", obj.params.minThreshold);
obj.info()->addParam(obj, "maxThreshold", obj.params.maxThreshold);
obj.info()->addParam_(obj, "minRepeatability", (sizeof(size_t) == sizeof(uint64))?Param::UINT64 : Param::UNSIGNED_INT, &obj.params.minRepeatability, false, 0, 0);
obj.info()->addParam(obj, "minDistBetweenBlobs", obj.params.minDistBetweenBlobs);
obj.info()->addParam(obj, "filterByColor", obj.params.filterByColor);
obj.info()->addParam(obj, "blobColor", obj.params.blobColor);
obj.info()->addParam(obj, "filterByArea", obj.params.filterByArea);
obj.info()->addParam(obj, "maxArea", obj.params.maxArea);
obj.info()->addParam(obj, "filterByCircularity", obj.params.filterByCircularity);
obj.info()->addParam(obj, "maxCircularity", obj.params.maxCircularity);
obj.info()->addParam(obj, "filterByInertia", obj.params.filterByInertia);
obj.info()->addParam(obj, "maxInertiaRatio", obj.params.maxInertiaRatio);
obj.info()->addParam(obj, "filterByConvexity", obj.params.filterByConvexity);
obj.info()->addParam(obj, "maxConvexity", obj.params.maxConvexity);
);
///////////////////////////////////////////////////////////////////////////////////////////////////////////
class CV_EXPORTS HarrisDetector : public GFTTDetector
{
public:

Write Preview
Loading…
Cancel
Save