Skip to content

O
opencv
Commit 0598f33a authored by Vadim Pisarevsky's avatar Vadim Pisarevsky
Browse files
Options

refactored command line parser, fixed the docs

parent b16b50d6
Show whitespace changes
Inline Side-by-side
Showing with 313 additions and 283 deletions
modules/core/doc/command_line_parser.rst
View file @ 0598f33a
...@@ -58,15 +58,15 @@ The sample below demonstrates how to use CommandLineParser: ...@@ -58,15 +58,15 @@ The sample below demonstrates how to use CommandLineParser:
} }
int N = parser.get<int>("N"); int N = parser.get<int>("N");
double fps = parser.get<double>parser("fps"); double fps = parser.get<double>("fps");
std::string path = parser.get<std::string>("path"); std::string path = parser.get<std::string>("path");
use_time_stamp = parserer.has("timestamp"); use_time_stamp = parser.has("timestamp");
std::string img1 = parser.get<string>(1); std::string img1 = parser.get<string>(0);
std::string img2 = parser.get<string>(2); std::string img2 = parser.get<string>(1);
int repeat = parser.get<int>(3); int repeat = parser.get<int>(2);
if (!parser.check()) if (!parser.check())
{ {
......
modules/core/include/opencv2/core/core.hpp
View file @ 0598f33a
...@@ -221,7 +221,7 @@ CV_EXPORTS void setNumThreads(int nthreads); ...@@ -221,7 +221,7 @@ CV_EXPORTS void setNumThreads(int nthreads);
CV_EXPORTS int getNumThreads(); CV_EXPORTS int getNumThreads();
CV_EXPORTS int getThreadNum(); CV_EXPORTS int getThreadNum();
CV_EXPORTS_W const std::string& getBuildInformation(); CV_EXPORTS_W const string& getBuildInformation();
//! Returns the number of ticks. //! Returns the number of ticks.
...@@ -4434,7 +4434,7 @@ protected: ...@@ -4434,7 +4434,7 @@ protected:
struct CV_EXPORTS Param struct CV_EXPORTS Param
{ {
enum { INT=0, BOOLEAN=1, REAL=2, STRING=3, MAT=4, MAT_VECTOR=5, ALGORITHM=6 }; enum { INT=0, BOOLEAN=1, REAL=2, STRING=3, MAT=4, MAT_VECTOR=5, ALGORITHM=6, FLOAT=7, UNSIGNED_INT=8, UINT64=9 };
Param(); Param();
Param(int _type, bool _readonly, int _offset, Param(int _type, bool _readonly, int _offset,
...@@ -4505,142 +4505,73 @@ template<> struct ParamType<Algorithm> ...@@ -4505,142 +4505,73 @@ template<> struct ParamType<Algorithm>
enum { type = Param::ALGORITHM }; enum { type = Param::ALGORITHM };
}; };
// The CommandLineParser class is designed for command line arguments parsing template<> struct ParamType<float>
class CV_EXPORTS CommandLineParserParams
{ {
public: typedef float const_param_type;
std::string help_message; typedef float member_type;
std::string def_value;
std::vector<std::string> keys; enum { type = Param::FLOAT };
int number;
}; };
template <typename T> template<> struct ParamType<unsigned>
std::string get_type_name() { return "UNKNOW"; } {
typedef unsigned const_param_type;
typedef unsigned member_type;
bool cmp_params(const CommandLineParserParams & p1, const CommandLineParserParams & p2); enum { type = Param::UNSIGNED_INT };
};
template<typename T> template<> struct ParamType<uint64>
T from_str(const std::string & str)
{ {
T value; typedef uint64 const_param_type;
std::stringstream ss(str); typedef uint64 member_type;
ss >> value;
if (ss.fail()) enum { type = Param::UINT64 };
{ };
std::string err_msg =
std::string("can not convert: [")
+ str
+ std::string("] to [")
+ get_type_name<T>()
+ std::string("]");
CV_Error(CV_StsBadArg, err_msg);
}
return value;
}
template<> std::string from_str(const std::string & str);
template<typename T> // The CommandLineParser class is designed for command line arguments parsing
std::string to_str(T value)
{
std::ostringstream os;
os << value;
return os.str();
}
class CV_EXPORTS CommandLineParser class CV_EXPORTS CommandLineParser
{ {
public: public:
CommandLineParser(int argc, const char * const argv[], const std::string keys); CommandLineParser(int argc, const char* const argv[], const string& keys);
CommandLineParser(const CommandLineParser& parser);
CommandLineParser& operator = (const CommandLineParser& parser);
std::string getPathToApplication(); string getPathToApplication() const;
template <typename T> template <typename T>
T get(const std::string& name, bool space_delete = true) T get(const string& name, bool space_delete = true) const
{
try
{
for (size_t i = 0; i < data.size(); i++)
{ {
for (size_t j = 0; j < data[i].keys.size(); j++) T val = T();
{ getByName(name, space_delete, ParamType<T>::type, (void*)&val);
if (name.compare(data[i].keys[j]) == 0) return val;
{
std::string v = data[i].def_value;
if (space_delete == true) v = cat_string(v);
return from_str<T>(v);
}
}
}
error = true;
error_message += "Unknown parametes " + name + "\n";
}
catch (std::exception& e)
{
error = true;
error_message += "Exception: " + std::string(e.what()) + "\n";
}
return T();
} }
template <typename T> template <typename T>
T get(int index, bool space_delete = true) T get(int index, bool space_delete = true) const
{
try
{
for (size_t i = 0; i < data.size(); i++)
{
if (data[i].number == index - 1)
{
std::string v = data[i].def_value;
if (space_delete == true) v = cat_string(v);
return from_str<T>(v);
}
}
error = true;
error_message += "Unknown parametes #" + to_str<int>(index) + "\n";
}
catch(std::exception & e)
{ {
error = true; T val = T();
error_message += "Exception: " + std::string(e.what()) + "\n"; getByIndex(index, space_delete, ParamType<T>::type, (void*)&val);
return val;
} }
return T();
}
bool has(const std::string& name);
bool check();
void about(std::string message);
void printMessage();
void printErrors();
protected: bool has(const string& name) const;
bool error;
std::string error_message;
std::string about_message;
std::string path_to_app;
std::string app_name;
std::vector<CommandLineParserParams> data; bool check() const;
std::vector<std::string> split_range_string(std::string str, char fs, char ss); void about(const string& message);
std::vector<std::string> split_string(std::string str, char symbol = ' ', bool create_empty_item = false);
std::string cat_string(std::string str);
void apply_params(std::string key, std::string value); void printMessage() const;
void apply_params(int i, std::string value); void printErrors() const;
void sort_params(); protected:
void getByName(const string& name, bool space_delete, int type, void* dst) const;
void getByIndex(int index, bool space_delete, int type, void* dst) const;
struct Impl;
Impl* impl;
}; };
/////////////////////////////// Parallel Primitives ////////////////////////////////// /////////////////////////////// Parallel Primitives //////////////////////////////////
......
modules/core/src/command_line_parser.cpp
View file @ 0598f33a
...@@ -5,8 +5,137 @@ ...@@ -5,8 +5,137 @@
namespace cv namespace cv
{ {
bool cmp_params(const CommandLineParserParams & p1, const CommandLineParserParams & p2)
struct CommandLineParserParams
{
public:
string help_message;
string def_value;
vector<string> keys;
int number;
};
struct CommandLineParser::Impl
{
bool error;
string error_message;
string about_message;
string path_to_app;
string app_name;
vector<CommandLineParserParams> data;
vector<string> split_range_string(const string& str, char fs, char ss) const;
vector<string> split_string(const string& str, char symbol = ' ', bool create_empty_item = false) const;
string cat_string(const string& str) const;
void apply_params(const string& key, const string& value);
void apply_params(int i, string value);
void sort_params();
int refcount;
};
static string get_type_name(int type)
{
if( type == Param::INT )
return "int";
if( type == Param::UNSIGNED_INT )
return "unsigned";
if( type == Param::UINT64 )
return "unsigned long long";
if( type == Param::FLOAT )
return "float";
if( type == Param::REAL )
return "double";
if( type == Param::STRING )
return "string";
return "unknown";
}
static void from_str(const string& str, int type, void* dst)
{
std::stringstream ss(str);
if( type == Param::INT )
ss >> *(int*)dst;
else if( type == Param::UNSIGNED_INT )
ss >> *(unsigned*)dst;
else if( type == Param::UINT64 )
ss >> *(uint64*)dst;
else if( type == Param::FLOAT )
ss >> *(float*)dst;
else if( type == Param::REAL )
ss >> *(double*)dst;
else if( type == Param::STRING )
ss >> *(string*)dst;
if (ss.fail())
{
string err_msg = "can not convert: [" + str +
+ "] to [" + get_type_name(type) + "]";
CV_Error(CV_StsBadArg, err_msg);
}
}
void CommandLineParser::getByName(const string& name, bool space_delete, int type, void* dst) const
{
try
{
for (size_t i = 0; i < impl->data.size(); i++)
{
for (size_t j = 0; j < impl->data[i].keys.size(); j++)
{
if (name.compare(impl->data[i].keys[j]) == 0)
{
string v = impl->data[i].def_value;
if (space_delete)
v = impl->cat_string(v);
from_str(v, type, dst);
return;
}
}
}
impl->error = true;
impl->error_message += "Unknown parametes " + name + "\n";
}
catch (std::exception& e)
{
impl->error = true;
impl->error_message += "Exception: " + string(e.what()) + "\n";
}
}
void CommandLineParser::getByIndex(int index, bool space_delete, int type, void* dst) const
{
try
{
for (size_t i = 0; i < impl->data.size(); i++)
{ {
if (impl->data[i].number == index)
{
string v = impl->data[i].def_value;
if (space_delete == true) v = impl->cat_string(v);
from_str(v, type, dst);
return;
}
}
impl->error = true;
impl->error_message += "Unknown parametes #" + format("%d", index) + "\n";
}
catch(std::exception & e)
{
impl->error = true;
impl->error_message += "Exception: " + string(e.what()) + "\n";
}
}
static bool cmp_params(const CommandLineParserParams & p1, const CommandLineParserParams & p2)
{
if (p1.number > p2.number) if (p1.number > p2.number)
return false; return false;
...@@ -19,37 +148,40 @@ namespace cv ...@@ -19,37 +148,40 @@ namespace cv
} }
return true; return true;
} }
CommandLineParser::CommandLineParser(int argc, const char* const argv[], const string& keys)
{
impl = new Impl;
impl->refcount = 1;
CommandLineParser::CommandLineParser(int argc, const char * const argv[], const std::string keys)
{
// path to application // path to application
size_t pos_s = std::string(argv[0]).find_last_of("/\\"); size_t pos_s = string(argv[0]).find_last_of("/\\");
if (pos_s == std::string::npos) if (pos_s == string::npos)
{ {
path_to_app = ""; impl->path_to_app = "";
app_name = std::string(argv[0]); impl->app_name = string(argv[0]);
} }
else else
{ {
path_to_app = std::string(argv[0]).substr(0, pos_s); impl->path_to_app = string(argv[0]).substr(0, pos_s);
app_name = std::string(argv[0]).substr(pos_s + 1, std::string(argv[0]).length() - pos_s); impl->app_name = string(argv[0]).substr(pos_s + 1, string(argv[0]).length() - pos_s);
} }
error = false; impl->error = false;
error_message = ""; impl->error_message = "";
// parse keys // parse keys
std::vector<std::string> k = split_range_string(keys, '{', '}'); vector<string> k = impl->split_range_string(keys, '{', '}');
int jj = 0; int jj = 0;
for (size_t i = 0; i < k.size(); i++) for (size_t i = 0; i < k.size(); i++)
{ {
std::vector<std::string> l = split_string(k[i], '|', true); vector<string> l = impl->split_string(k[i], '|', true);
CommandLineParserParams p; CommandLineParserParams p;
p.keys = split_string(l[0]); p.keys = impl->split_string(l[0]);
p.def_value = l[1]; p.def_value = l[1];
p.help_message = cat_string(l[2]); p.help_message = impl->cat_string(l[2]);
p.number = -1; p.number = -1;
if (p.keys[0][0] == '@') if (p.keys[0][0] == '@')
{ {
...@@ -57,24 +189,24 @@ namespace cv ...@@ -57,24 +189,24 @@ namespace cv
jj++; jj++;
} }
data.push_back(p); impl->data.push_back(p);
} }
// parse argv // parse argv
jj = 0; jj = 0;
for (int i = 1; i < argc; i++) for (int i = 1; i < argc; i++)
{ {
std::string s = std::string(argv[i]); string s = string(argv[i]);
if (s.find('=') != std::string::npos && s.find('=') < s.length()) if (s.find('=') != string::npos && s.find('=') < s.length())
{ {
std::vector<std::string> k_v = split_string(s, '=', true); vector<string> k_v = impl->split_string(s, '=', true);
for (int h = 0; h < 2; h++) for (int h = 0; h < 2; h++)
{ {
if (k_v[0][0] == '-') if (k_v[0][0] == '-')
k_v[0] = k_v[0].substr(1, k_v[0].length() -1); k_v[0] = k_v[0].substr(1, k_v[0].length() -1);
} }
apply_params(k_v[0], k_v[1]); impl->apply_params(k_v[0], k_v[1]);
} }
else if (s.length() > 1 && s[0] == '-') else if (s.length() > 1 && s[0] == '-')
{ {
...@@ -83,25 +215,44 @@ namespace cv ...@@ -83,25 +215,44 @@ namespace cv
if (s[0] == '-') if (s[0] == '-')
s = s.substr(1, s.length() - 1); s = s.substr(1, s.length() - 1);
} }
apply_params(s, "true"); impl->apply_params(s, "true");
} }
else if (s[0] != '-') else if (s[0] != '-')
{ {
apply_params(jj, s); impl->apply_params(jj, s);
jj++; jj++;
} }
} }
sort_params(); impl->sort_params();
} }
void CommandLineParser::about(std::string message)
CommandLineParser::CommandLineParser(const CommandLineParser& parser)
{
impl = parser.impl;
CV_XADD(&impl->refcount, 1);
}
CommandLineParser& CommandLineParser::operator = (const CommandLineParser& parser)
{
if( this != &parser )
{ {
about_message = message; if(CV_XADD(&impl->refcount, -1) == 1)
delete impl;
impl = parser.impl;
CV_XADD(&impl->refcount, 1);
} }
return *this;
}
void CommandLineParser::apply_params(std::string key, std::string value) void CommandLineParser::about(const string& message)
{ {
impl->about_message = message;
}
void CommandLineParser::Impl::apply_params(const string& key, const string& value)
{
for (size_t i = 0; i < data.size(); i++) for (size_t i = 0; i < data.size(); i++)
{ {
for (size_t k = 0; k < data[i].keys.size(); k++) for (size_t k = 0; k < data[i].keys.size(); k++)
...@@ -113,10 +264,10 @@ namespace cv ...@@ -113,10 +264,10 @@ namespace cv
} }
} }
} }
} }
void CommandLineParser::apply_params(int i, std::string value) void CommandLineParser::Impl::apply_params(int i, string value)
{ {
for (size_t j = 0; j < data.size(); j++) for (size_t j = 0; j < data.size(); j++)
{ {
if (data[j].number == i) if (data[j].number == i)
...@@ -125,92 +276,87 @@ namespace cv ...@@ -125,92 +276,87 @@ namespace cv
break; break;
} }
} }
} }
void CommandLineParser::sort_params() void CommandLineParser::Impl::sort_params()
{ {
for (size_t i = 0; i < data.size(); i++) for (size_t i = 0; i < data.size(); i++)
{ {
sort(data[i].keys.begin(), data[i].keys.end()); sort(data[i].keys.begin(), data[i].keys.end());
} }
sort (data.begin(), data.end(), cmp_params); sort (data.begin(), data.end(), cmp_params);
} }
std::string CommandLineParser::cat_string(std::string str)
{
while (!str.empty() && str[0] == ' ')
{
str = str.substr(1, str.length() - 1);
}
while (!str.empty() && str[str.length() - 1] == ' ')
{
str = str.substr(0, str.length() - 1);
}
return str; string CommandLineParser::Impl::cat_string(const string& str) const
} {
int left = 0, right = (int)str.length();
while( left <= right && str[left] == ' ' )
left++;
while( right > left && str[right-1] == ' ' )
right--;
return left >= right ? string("") : str.substr(left, right-left);
}
std::string CommandLineParser::getPathToApplication() string CommandLineParser::getPathToApplication() const
{ {
return path_to_app; return impl->path_to_app;
} }
bool CommandLineParser::has(const std::string& name) bool CommandLineParser::has(const string& name) const
{ {
for (size_t i = 0; i < data.size(); i++) for (size_t i = 0; i < impl->data.size(); i++)
{ {
for (size_t j = 0; j < data[i].keys.size(); j++) for (size_t j = 0; j < impl->data[i].keys.size(); j++)
{ {
if (name.compare(data[i].keys[j]) == 0 && std::string("true").compare(data[i].def_value) == 0) if (name.compare(impl->data[i].keys[j]) == 0 && string("true").compare(impl->data[i].def_value) == 0)
{ {
return true; return true;
} }
} }
} }
return false; return false;
} }
bool CommandLineParser::check() bool CommandLineParser::check() const
{ {
return error == false; return impl->error == false;
} }
void CommandLineParser::printErrors() void CommandLineParser::printErrors() const
{ {
if (error) if (impl->error)
{ {
std::cout << std::endl << "ERRORS:" << std::endl << error_message << std::endl; std::cout << std::endl << "ERRORS:" << std::endl << impl->error_message << std::endl;
}
} }
}
void CommandLineParser::printMessage() void CommandLineParser::printMessage() const
{ {
if (about_message != "") if (impl->about_message != "")
std::cout << about_message << std::endl; std::cout << impl->about_message << std::endl;
std::cout << "Usage: " << app_name << " [params] "; std::cout << "Usage: " << impl->app_name << " [params] ";
for (size_t i = 0; i < data.size(); i++) for (size_t i = 0; i < impl->data.size(); i++)
{ {
if (data[i].number > -1) if (impl->data[i].number > -1)
{ {
std::string name = data[i].keys[0].substr(1, data[i].keys[0].length() - 1); string name = impl->data[i].keys[0].substr(1, impl->data[i].keys[0].length() - 1);
std::cout << name << " "; std::cout << name << " ";
} }
} }
std::cout << std::endl << std::endl; std::cout << std::endl << std::endl;
for (size_t i = 0; i < data.size(); i++) for (size_t i = 0; i < impl->data.size(); i++)
{ {
if (data[i].number == -1) if (impl->data[i].number == -1)
{ {
std::cout << "\t"; std::cout << "\t";
for (size_t j = 0; j < data[i].keys.size(); j++) for (size_t j = 0; j < impl->data[i].keys.size(); j++)
{ {
std::string k = data[i].keys[j]; string k = impl->data[i].keys[j];
if (k.length() > 1) if (k.length() > 1)
{ {
std::cout << "--"; std::cout << "--";
...@@ -221,45 +367,46 @@ namespace cv ...@@ -221,45 +367,46 @@ namespace cv
} }
std::cout << k; std::cout << k;
if (j != data[i].keys.size() - 1) if (j != impl->data[i].keys.size() - 1)
{ {
std::cout << ", "; std::cout << ", ";
} }
} }
std::string dv = cat_string(data[i].def_value); string dv = impl->cat_string(impl->data[i].def_value);
if (dv.compare("") != 0) if (dv.compare("") != 0)
{ {
std::cout << " (value:" << dv << ")"; std::cout << " (value:" << dv << ")";
} }
std::cout << std::endl << "\t\t" << data[i].help_message << std::endl; std::cout << std::endl << "\t\t" << impl->data[i].help_message << std::endl;
} }
} }
std::cout << std::endl; std::cout << std::endl;
for (size_t i = 0; i < data.size(); i++) for (size_t i = 0; i < impl->data.size(); i++)
{ {
if (data[i].number != -1) if (impl->data[i].number != -1)
{ {
std::cout << "\t"; std::cout << "\t";
std::string k = data[i].keys[0]; string k = impl->data[i].keys[0];
k = k.substr(1, k.length() - 1); k = k.substr(1, k.length() - 1);
std::cout << k; std::cout << k;
std::string dv = cat_string(data[i].def_value); string dv = impl->cat_string(impl->data[i].def_value);
if (dv.compare("") != 0) if (dv.compare("") != 0)
{ {
std::cout << " (value:" << dv << ")"; std::cout << " (value:" << dv << ")";
} }
std::cout << std::endl << "\t\t" << data[i].help_message << std::endl; std::cout << std::endl << "\t\t" << impl->data[i].help_message << std::endl;
}
} }
} }
}
std::vector<std::string> CommandLineParser::split_range_string(std::string str, char fs, char ss) vector<string> CommandLineParser::Impl::split_range_string(const string& _str, char fs, char ss) const
{ {
std::vector<std::string> vec; string str = _str;
std::string word = ""; vector<string> vec;
string word = "";
bool begin = false; bool begin = false;
while (!str.empty()) while (!str.empty())
...@@ -269,13 +416,13 @@ namespace cv ...@@ -269,13 +416,13 @@ namespace cv
if (begin == true) if (begin == true)
{ {
CV_Error(CV_StsParseError, CV_Error(CV_StsParseError,
std::string("error in split_range_string(") string("error in split_range_string(")
+ str + str
+ std::string(", ") + string(", ")
+ std::string(1, fs) + string(1, fs)
+ std::string(", ") + string(", ")
+ std::string(1, ss) + string(1, ss)
+ std::string(")") + string(")")
); );
} }
begin = true; begin = true;
...@@ -288,13 +435,13 @@ namespace cv ...@@ -288,13 +435,13 @@ namespace cv
if (begin == false) if (begin == false)
{ {
CV_Error(CV_StsParseError, CV_Error(CV_StsParseError,
std::string("error in split_range_string(") string("error in split_range_string(")
+ str + str
+ std::string(", ") + string(", ")
+ std::string(1, fs) + string(1, fs)
+ std::string(", ") + string(", ")
+ std::string(1, ss) + string(1, ss)
+ std::string(")") + string(")")
); );
} }
begin = false; begin = false;
...@@ -311,23 +458,24 @@ namespace cv ...@@ -311,23 +458,24 @@ namespace cv
if (begin == true) if (begin == true)
{ {
CV_Error(CV_StsParseError, CV_Error(CV_StsParseError,
std::string("error in split_range_string(") string("error in split_range_string(")
+ str + str
+ std::string(", ") + string(", ")
+ std::string(1, fs) + string(1, fs)
+ std::string(", ") + string(", ")
+ std::string(1, ss) + string(1, ss)
+ std::string(")") + string(")")
); );
} }
return vec; return vec;
} }
std::vector<std::string> CommandLineParser::split_string(std::string str, char symbol, bool create_empty_item) vector<string> CommandLineParser::Impl::split_string(const string& _str, char symbol, bool create_empty_item) const
{ {
std::vector<std::string> vec; string str = _str;
std::string word = ""; vector<string> vec;
string word = "";
while (!str.empty()) while (!str.empty())
{ {
...@@ -352,55 +500,6 @@ namespace cv ...@@ -352,55 +500,6 @@ namespace cv
} }
return vec; return vec;
} }
#undef clp_get
#define clp_get(T) template<> T CommandLineParser::get<T>(const std::string& name, bool space_delete);
clp_get(int)
clp_get(unsigned int)
clp_get(long)
clp_get(unsigned long)
clp_get(long long)
clp_get(unsigned long long)
clp_get(size_t)
clp_get(float)
clp_get(double)
clp_get(uint64)
clp_get(int64)
clp_get(std::string)
#undef clp_from_str
#define clp_from_str(T) template<> T from_str<T>(const std::string & str);
clp_from_str(int)
clp_from_str(unsigned int)
clp_from_str(long)
clp_from_str(unsigned long)
clp_from_str(long long)
clp_from_str(unsigned long long)
clp_from_str(size_t)
clp_from_str(uint64)
clp_from_str(int64)
clp_from_str(float)
clp_from_str(double)
template<>
std::string from_str(const std::string & str)
{
return str;
}
#undef clp_type_name
#define clp_type_name(type, name) template<> std::string get_type_name<type>() { return std::string(name);}
clp_type_name(int, "int")
clp_type_name(unsigned int, "unsigned int")
clp_type_name(long, "long")
clp_type_name(long long, "long long")
clp_type_name(unsigned long long, "unsigned long long")
clp_type_name(size_t, "size_t")
clp_type_name(float, "float")
clp_type_name(double, "double")
} }
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment