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

add new version of CommandLineParser. add empty docs

Browse Source
This commit is contained in:
AoD314
2012-09-07 13:24:48 +04:00
parent 6a112aa87a
commit 54a202b3d5
26 changed files with 855 additions and 665 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -4505,113 +4505,143 @@ template<> struct ParamType<Algorithm>
enum { type = Param::ALGORITHM };
};
// The CommandLineParser class is designed for command line arguments parsing
class CV_EXPORTS CommandLineParserParams
{
public:
std::string help_message;
std::string def_value;
std::vector<std::string> keys;
int number;
};
template <typename T>
std::string get_type_name() { return "UNKNOW"; }
bool cmp_params(const CommandLineParserParams & p1, const CommandLineParserParams & p2);
template<typename T>
T from_str(const std::string & str)
{
T value;
std::stringstream ss(str);
ss >> value;
if (ss.fail())
{
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>
std::string to_str(T value)
{
std::ostringstream os;
os << value;
return os.str();
}
/*!
"\nThe CommandLineParser class is designed for command line arguments parsing\n"
"Keys map: \n"
"Before you start to work with CommandLineParser you have to create a map for keys.\n"
" It will look like this\n"
" const char* keys =\n"
" {\n"
" { s| string| 123asd |string parameter}\n"
" { d| digit | 100 |digit parameter }\n"
" { c|noCamera|false |without camera }\n"
" { 1| |some text|help }\n"
" { 2| |333 |another help }\n"
" };\n"
"Usage syntax: \n"
" \"{\" - start of parameter string.\n"
" \"}\" - end of parameter string\n"
" \"|\" - separator between short name, full name, default value and help\n"
"Supported syntax: \n"
" --key1=arg1 <If a key with '--' must has an argument\n"
" you have to assign it through '=' sign.> \n"
"<If the key with '--' doesn't have any argument, it means that it is a bool key>\n"
" -key2=arg2 <If a key with '-' must has an argument \n"
" you have to assign it through '=' sign.> \n"
"If the key with '-' doesn't have any argument, it means that it is a bool key\n"
" key3 <This key can't has any parameter> \n"
"Usage: \n"
" Imagine that the input parameters are next:\n"
" -s=string_value --digit=250 --noCamera lena.jpg 10000\n"
" CommandLineParser parser(argc, argv, keys) - create a parser object\n"
" parser.get<string>(\"s\" or \"string\") will return you first parameter value\n"
" parser.get<string>(\"s\", false or \"string\", false) will return you first parameter value\n"
" without spaces in end and begin\n"
" parser.get<int>(\"d\" or \"digit\") will return you second parameter value.\n"
" It also works with 'unsigned int', 'double', and 'float' types>\n"
" parser.get<bool>(\"c\" or \"noCamera\") will return you true .\n"
" If you enter this key in commandline>\n"
" It return you false otherwise.\n"
" parser.get<string>(\"1\") will return you the first argument without parameter (lena.jpg) \n"
" parser.get<int>(\"2\") will return you the second argument without parameter (10000)\n"
" It also works with 'unsigned int', 'double', and 'float' types \n"
*/
class CV_EXPORTS CommandLineParser
{
public:
CommandLineParser(int argc, const char * const argv[], const std::string keys);
//! the default constructor
CommandLineParser(int argc, const char* const argv[], const char* key_map);
std::string getPathToApplication();
//! get parameter, you can choose: delete spaces in end and begin or not
template<typename _Tp>
_Tp get(const std::string& name, bool space_delete=true)
{
if (!has(name))
template <typename T>
T get(const std::string& name, bool space_delete = true)
{
return _Tp();
try
{
for (size_t i = 0; i < data.size(); i++)
{
for (size_t j = 0; j < data[i].keys.size(); j++)
{
if (name.compare(data[i].keys[j]) == 0)
{
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();
}
std::string str = getString(name);
return analyzeValue<_Tp>(str, space_delete);
}
//! print short name, full name, current value and help for all params
void printParams();
template <typename T>
T get(int index, bool space_delete = true)
{
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;
error_message += "Exception: " + std::string(e.what()) + "\n";
}
return T();
}
bool has(const std::string& name);
bool check();
void about(std::string message);
void printMessage();
void printErrors();
protected:
std::map<std::string, std::vector<std::string> > data;
std::string getString(const std::string& name);
bool error;
std::string error_message;
std::string about_message;
bool has(const std::string& keys);
std::string path_to_app;
std::string app_name;
template<typename _Tp>
_Tp analyzeValue(const std::string& str, bool space_delete=false);
std::vector<CommandLineParserParams> data;
template<typename _Tp>
static _Tp getData(const std::string& str)
{
_Tp res;
std::stringstream s1(str);
s1 >> res;
return res;
}
std::vector<std::string> split_range_string(std::string str, char fs, char ss);
std::vector<std::string> split_string(std::string str, char symbol = ' ', bool create_empty_item = false);
std::string cat_string(std::string str);
template<typename _Tp>
_Tp fromStringNumber(const std::string& str);//the default conversion function for numbers
void apply_params(std::string key, std::string value);
void apply_params(int i, std::string value);
};
void sort_params();
template<> CV_EXPORTS
bool CommandLineParser::get<bool>(const std::string& name, bool space_delete);
template<> CV_EXPORTS
std::string CommandLineParser::analyzeValue<std::string>(const std::string& str, bool space_delete);
template<> CV_EXPORTS
int CommandLineParser::analyzeValue<int>(const std::string& str, bool space_delete);
template<> CV_EXPORTS
unsigned int CommandLineParser::analyzeValue<unsigned int>(const std::string& str, bool space_delete);
template<> CV_EXPORTS
uint64 CommandLineParser::analyzeValue<uint64>(const std::string& str, bool space_delete);
template<> CV_EXPORTS
float CommandLineParser::analyzeValue<float>(const std::string& str, bool space_delete);
template<> CV_EXPORTS
double CommandLineParser::analyzeValue<double>(const std::string& str, bool space_delete);
};
/////////////////////////////// Parallel Primitives //////////////////////////////////