Chiebot-Mirror
/
opencv
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Update CommandLineParser class

Browse Source
pull/13383/head
Kirill Kornyakov 14 years ago
parent 4b4053705d
commit fe279279e6
2 changed files with 97 additions and 152 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. 149
      modules/core/include/opencv2/core/core.hpp
  2. 100
      modules/core/src/cmdparser.cpp

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

@ -4171,126 +4171,85 @@ protected:
The class is used for reading command arguments.
Supports the following syntax:
//-k 10 1 2 --x 0.001 --size 640 480 --inputFile lena.jpg
//-k=10 --x 0.001 --inputFile lena.jpg
int k = parser.get<int>("--k | -k", -1);
vector<int> kValues=parser.getVec<int>("--k | -k");
double x = parser.get<double>("--x");
cv::Size size = parser.get<cv::Size>("--size");
string inputFile = parser.get<string>("--inputFile");
*/
class CV_EXPORTS CommandLineParser
{
public:
//! the default constructor
CommandLineParser(int argc, const char* argv[]);
//! allows to check if parameter is given
bool has(const std::string& keys) const;
public:
//! get parameter
template<typename _Tp>
_Tp get(const std::string& name)
{
return fromStringsVec<_Tp>(getVec<std::string>(name));
}
//! get parameter with default value
template<typename _Tp>
_Tp get(const std::string& name, const _Tp& default_value)
{
if (!has(name))
return default_value;
return get<_Tp>(name);
}
//! the default constructor
CommandLineParser(int argc, const char* argv[]);
//! get a vector of values for specified key
template<typename _Tp>
std::vector<_Tp> getVec(const std::string& keys);
//! allows to check if parameter is given
bool has(const std::string& keys) const;
protected:
std::map<std::string, std::vector<std::string> > data;
template<typename _Tp>
static _Tp fromStringSimple(const std::string& str)//the default conversion function
{
_Tp res;
std::stringstream s1(str);
s1 >> res;
return res;
}
template<typename _Tp>
static _Tp fromString(const std::string& str)
{
return fromStringSimple<_Tp>(str);
}
//! get parameter, if parameter is not given get default parameter
template<typename _Tp>
_Tp get(const std::string& name, const _Tp& default_value = _Tp())
{
std::string str = getString(name);
if (!has(name))
return default_value;
return analizeValue<_Tp>(str);
}
template<typename _Tp>
static _Tp fromStringNumber(const std::string& str)//the default conversion function for numbers
{
_Tp dummy_val=0; dummy_val+=1;
protected:
std::map<std::string, std::vector<std::string> > data;
std::string getString(const std::string& name) const;
if (str.empty())
CV_Error(CV_StsParseError, "Empty string cannot be converted to a number");
template<typename _Tp>
_Tp analizeValue(const std::string& str);
const char* c_str=str.c_str();
if((!isdigit(c_str[0]))
&&
(
(c_str[0]!='-') || (strlen(c_str) <= 1) || ( !isdigit(c_str[1]) )
)
)
template<typename _Tp>
static _Tp getData(const std::string& str)
{
CV_Error(CV_StsParseError, "The string '"+ str +"' cannot be converted to a number");
_Tp res;
std::stringstream s1(str);
s1 >> res;
return res;
}
return fromStringSimple<_Tp>(str);
}
template<typename _Tp>
static _Tp fromStringNumber(const std::string& str)//the default conversion function for numbers
{
template<typename _Tp>
static _Tp fromStringsVec(const std::vector<std::string>& vec_str)
{
if (vec_str.empty())
CV_Error(CV_StsParseError, "Cannot convert from an empty vector");
return fromString<_Tp>(vec_str[0]);
}
};
if (str.empty())
CV_Error(CV_StsParseError, "Empty string cannot be converted to a number");
template<> CV_EXPORTS
std::vector<std::string> CommandLineParser::getVec<std::string>(const std::string& keys);
const char* c_str=str.c_str();
if((!isdigit(c_str[0]))
&&
(
(c_str[0]!='-') || (strlen(c_str) <= 1) || ( !isdigit(c_str[1]) )
)
)
template<typename _Tp> inline
std::vector<_Tp> CommandLineParser::getVec(const std::string& keys)
{
if (!has(keys))
return std::vector<_Tp>();
{
CV_Error(CV_StsParseError, "The string '"+ str +"' cannot be converted to a number");
}
std::vector<std::string> v=getVec<std::string>(keys);
return getData<_Tp>(str);
}
std::vector<_Tp> res;
for(size_t i=0; i < v.size(); i++)
{
_Tp val=fromString<_Tp>(v[i]);
res.push_back(val);
}
return res;
}
};
template<> CV_EXPORTS
std::string CommandLineParser::fromString<std::string>(const std::string& str);
template<> CV_EXPORTS
std::string CommandLineParser::analizeValue<std::string>(const std::string& str);
template<> CV_EXPORTS
int CommandLineParser::fromString<int>(const std::string& str);
template<> CV_EXPORTS
int CommandLineParser::analizeValue<int>(const std::string& str);
template<> CV_EXPORTS
unsigned int CommandLineParser::fromString<unsigned int>(const std::string& str);
template<> CV_EXPORTS
unsigned CommandLineParser::analizeValue<unsigned int>(const std::string& str);
template<> CV_EXPORTS
double CommandLineParser::fromString<double>(const std::string& str);
template<> CV_EXPORTS
float CommandLineParser::analizeValue<float>(const std::string& str);
template<> CV_EXPORTS
cv::Size CommandLineParser::fromStringsVec<cv::Size>(const std::vector<std::string>& str);
template<> CV_EXPORTS
double CommandLineParser::analizeValue<double>(const std::string& str);
}

100
modules/core/src/cmdparser.cpp
Unescape View File

@ -32,7 +32,7 @@ void PreprocessArgs(int _argc, const char* _argv[], int& argc, char**& argv)
find_symbol = buffer_string.find('=');
if (find_symbol == -1)
buffer_vector.push_back(buffer_string);
else if (find_symbol == 0 || find_symbol == ((int)buffer_string.length() - 1))
else if (find_symbol == 0 || find_symbol == (buffer_string.length() - 1))
{
buffer_string.erase(find_symbol, (find_symbol + 1));
if(!buffer_string.empty())
@ -45,6 +45,7 @@ void PreprocessArgs(int _argc, const char* _argv[], int& argc, char**& argv)
buffer_vector.push_back(buffer_string);
buffer2_string.erase(0, find_symbol + 1);
buffer_vector.push_back(buffer2_string);
}
}
@ -57,78 +58,70 @@ void PreprocessArgs(int _argc, const char* _argv[], int& argc, char**& argv)
}
}
CommandLineParser::CommandLineParser(int _argc, const char* _argv[])
{
std::string cur_name;
bool was_pushed=false;
int argc;
char** argv;
PreprocessArgs(_argc, _argv, argc, argv);
for(int i=1; i < argc; i++)
{
if(!argv[i])
break;
if( (argv[i][0]== '-') && (strlen(argv[i]) > 1) &&
((argv[i][1] < '0') || (argv[i][1] > '9')) )
{
if (!cur_name.empty() && !was_pushed)
{
data[cur_name].push_back("");
}
cur_name=argv[i];
while (cur_name.find('-') == 0)
{
cur_name.erase(0,1);
}
for(int i=1; i < argc; i++) {
was_pushed=false;
if(!argv[i])
break;
if (data.find(cur_name) != data.end())
if( (argv[i][0]== '-') && (strlen(argv[i]) > 1)
&&
( (argv[i][1] < '0') || (argv[i][1] > '9')) )
{
string str_exception = "dublicating parameters for name='" + cur_name + "'";
CV_Error(CV_StsParseError, str_exception);
if (!cur_name.empty() && !was_pushed) {
data[cur_name].push_back("");
}
cur_name=argv[i];
while (cur_name.find('-') == 0)
{
cur_name.erase(0,1);
}
was_pushed=false;
if (data.find(cur_name) != data.end()) {
string str_exception="dublicating parameters for name='" + cur_name + "'";
CV_Error(CV_StsParseError, str_exception);
}
continue;
}
continue;
}
data[cur_name].push_back(argv[i]);
was_pushed=true;
data[cur_name].push_back(argv[i]);
was_pushed=true;
}
if (!cur_name.empty() && !was_pushed)
data[cur_name].push_back("");
data[cur_name].push_back("");
}
bool CommandLineParser::has(const std::string& keys) const
{
vector<string> names=split_string(keys, " |");
for(size_t j=0; j < names.size(); j++)
{
for(size_t j=0; j < names.size(); j++) {
if (data.find(names[j])!=data.end())
return true;
}
return false;
}
template<>
std::vector<std::string> CommandLineParser::getVec<std::string>(const std::string& keys)
std::string CommandLineParser::getString(const std::string& keys) const
{
vector<string> names=split_string(keys, " |");
int found_index=-1;
for(size_t j=0; j < names.size(); j++)
{
for(size_t j=0; j < names.size(); j++) {
const string& cur_name=names[j];
bool is_cur_found=has(cur_name);
if (is_cur_found && (found_index >= 0))
{
string str_exception = "dublicating parameters for "
"name='" + names[found_index] + "' and name='"+cur_name+"'";
if (is_cur_found && (found_index >= 0)) {
string str_exception="dublicating parameters for "
"name='" + names[found_index] + "' and name='"+cur_name+"'";
CV_Error(CV_StsParseError, str_exception);
}
@ -137,45 +130,38 @@ std::vector<std::string> CommandLineParser::getVec<std::string>(const std::strin
}
if (found_index<0)
return vector<string>();
return data.find(names[found_index])->second;
return string();
return data.find(names[found_index])->second[0];
}
template<>
std::string CommandLineParser::fromString<std::string>(const std::string& str)
std::string CommandLineParser::analizeValue<std::string>(const std::string& str)
{
return str;
}
template<>
int CommandLineParser::fromString<int>(const std::string& str)
int CommandLineParser::analizeValue<int>(const std::string& str)
{
return fromStringNumber<int>(str);
}
template<>
unsigned int CommandLineParser::fromString<unsigned int>(const std::string& str)
unsigned int CommandLineParser::analizeValue<unsigned int>(const std::string& str)
{
return fromStringNumber<unsigned int>(str);
}
template<>
double CommandLineParser::fromString<double>(const std::string& str)
float CommandLineParser::analizeValue<float>(const std::string& str)
{
return fromStringNumber<double>(str);
return fromStringNumber<float>(str);
}
template<>
cv::Size CommandLineParser::fromStringsVec<cv::Size>(const std::vector<std::string>& vec_str)
double CommandLineParser::analizeValue<double>(const std::string& str)
{
if (vec_str.size() < 2)
CV_Error(CV_StsParseError, "Cannot convert vector of string to cv::Size : less than two strings");
cv::Size res;
res.width=fromString<int>(vec_str[0]);
res.height=fromString<int>(vec_str[1]);
return res;
return fromStringNumber<double>(str);
}

Write Preview
Loading…
Cancel
Save