3dpcp/.svn/pristine/33/333506af4f1aa220b56eba089abbbc9af8a8e67e.svn-base

250 lines
8.5 KiB
Text
Raw Normal View History

2012-10-02 07:37:52 +00:00
/*
* fbr_global implementation
*
* Copyright (C) HamidReza Houshiar
*
* Released under the GPL version 3.
*
*/
#include "slam6d/fbr/fbr_global.h"
#include <stdexcept>
namespace fbr{
2012-10-15 17:05:06 +00:00
2012-10-02 07:37:52 +00:00
string scanFormatToString(IOType format){
return io_type_to_libname(format);
}
2012-10-15 17:05:06 +00:00
2012-10-02 07:37:52 +00:00
IOType stringToScanFormat(string format){
return formatname_to_io_type(format.c_str());
2012-10-15 17:05:06 +00:00
}
2012-10-02 07:37:52 +00:00
string projectionMethodToString(projection_method method){
string sMethod;
switch(method){
case EQUIRECTANGULAR:
sMethod = "EQUIRECTANGULAR";
break;
case CYLINDRICAL:
sMethod = "CYLINDRICAL";
break;
case MERCATOR:
sMethod = "MERCATOR";
break;
case RECTILINEAR:
sMethod = "RECTILINEAR";
break;
case PANNINI:
sMethod = "PANNINI";
break;
case STEREOGRAPHIC:
sMethod = "STEREOGRAPHIC";
break;
case ZAXIS:
sMethod = "ZAXIS";
break;
case CONIC:
sMethod = "CONIC";
break;
default:
throw std::runtime_error(std::string("projection method ") + to_string(method) + std::string(" could not be matched to a projection method"));
}
return sMethod;
}
projection_method stringToProjectionMethod(string method){
if(strcasecmp(method.c_str(), "EQUIRECTANGULAR") == 0) return EQUIRECTANGULAR;
else if(strcasecmp(method.c_str(), "CYLINDRICAL") == 0) return CYLINDRICAL;
else if(strcasecmp(method.c_str(), "MERCATOR") == 0) return MERCATOR;
else if(strcasecmp(method.c_str(), "RECTILINEAR") == 0) return RECTILINEAR;
else if(strcasecmp(method.c_str(), "PANNINI") == 0) return PANNINI;
else if(strcasecmp(method.c_str(), "STEREOGRAPHIC") == 0) return STEREOGRAPHIC;
else if(strcasecmp(method.c_str(), "ZAXIS") == 0) return ZAXIS;
else if(strcasecmp(method.c_str(), "CONIC") == 0) return CONIC;
else throw std::runtime_error(std::string("projection method ") + method + std::string(" is unknown"));
}
string panoramaMapMethodToString(panorama_map_method method){
string sMethod;
switch(method){
case FARTHEST:
sMethod = "FARTHEST";
break;
case EXTENDED:
sMethod = "EXTENDED";
break;
default:
throw std::runtime_error(std::string("panorama map method ") + to_string(method) + std::string(" could not be matched to a panorama map method"));
}
return sMethod;
}
panorama_map_method stringToPanoramaMapMethod(string method){
if(strcasecmp(method.c_str(), "FARTHEST") == 0) return FARTHEST;
else if(strcasecmp(method.c_str(), "EXTENDED") == 0) return EXTENDED;
else throw std::runtime_error(std::string("panorama map method ") + method + std::string(" is unknown"));
}
string featureDetectorMethodToString(feature_detector_method method){
string sMethod;
switch(method){
case SIFT_DET:
sMethod = "SIFT_DET";
break;
case SURF_DET:
sMethod = "SURF_DET";
break;
case ORB_DET:
sMethod = "ORB_DET";
break;
case FAST_DET:
sMethod = "FAST_DET";
break;
case STAR_DET:
sMethod = "STAR_DET";
break;
default:
throw std::runtime_error(std::string("feature detector method ") + to_string(method) + std::string(" could not be matched to a feature detector method"));
}
return sMethod;
}
feature_detector_method stringToFeatureDetectorMethod(string method){
if(strcasecmp(method.c_str(), "SIFT") == 0) return SIFT_DET;
else if(strcasecmp(method.c_str(), "SURF") == 0) return SURF_DET;
else if(strcasecmp(method.c_str(), "ORB") == 0) return ORB_DET;
else if(strcasecmp(method.c_str(), "FAST") == 0) return FAST_DET;
else if(strcasecmp(method.c_str(), "STAR") == 0) return STAR_DET;
else throw std::runtime_error(std::string("feature detector method ") + method + std::string(" is unknown"));
}
string featureDescriptorMethodToString(feature_descriptor_method method){
string sMethod;
switch(method){
case SIFT_DES:
sMethod = "SIFT_DES";
break;
case SURF_DES:
sMethod = "SURF_DES";
break;
case ORB_DES:
sMethod = "ORB_DES";
break;
default:
throw std::runtime_error(std::string("feature descriptor method ") + to_string(method) + std::string(" could not be matched to a feature descriptor method"));
}
return sMethod;
}
feature_descriptor_method stringToFeatureDescriptorMethod(string method){
if(strcasecmp(method.c_str(), "SIFT") == 0) return SIFT_DES;
else if(strcasecmp(method.c_str(), "SURF") == 0) return SURF_DES;
else if(strcasecmp(method.c_str(), "ORB") == 0) return ORB_DES;
else throw std::runtime_error(std::string("feature descriptor method ") + method + std::string(" is unknown"));
}
string matcherMethodToString(matcher_method method){
string sMethod;
switch(method){
case BRUTEFORCE:
sMethod = "BRUTEFORCE";
break;
case FLANN:
sMethod = "FLANN";
break;
case KNN:
sMethod = "KNN";
break;
case RADIUS:
sMethod = "RADIUS";
break;
case RATIO:
sMethod = "RATIO";
break;
default:
throw std::runtime_error(std::string("matcher method ") + to_string(method) + std::string(" could not be matched to a matcher method"));
}
return sMethod;
}
matcher_method stringToMatcherMethod(string method){
if(strcasecmp(method.c_str(), "BRUTEFORCE") == 0) return BRUTEFORCE;
else if(strcasecmp(method.c_str(), "FLANN") == 0) return FLANN;
else if(strcasecmp(method.c_str(), "KNN") == 0) return KNN;
else if(strcasecmp(method.c_str(), "RADIUS") == 0) return RADIUS;
else if(strcasecmp(method.c_str(), "RATIO") == 0) return RATIO;
else throw std::runtime_error(std::string("matcher method ") + method + std::string(" is unknown"));
}
string registrationMethodToString(registration_method method){
string sMethod;
switch(method){
case ALL:
sMethod = "ALL";
break;
case RANSAC:
sMethod = "RANSAC";
break;
case DISABLE:
sMethod = "DISABLE";
break;
default:
throw std::runtime_error(std::string("registration method ") + to_string(method) + std::string(" could not be matched to a registration method"));
}
return sMethod;
}
registration_method stringToRegistrationMethod(string method){
if(strcasecmp(method.c_str(), "ALL") == 0) return ALL;
else if(strcasecmp(method.c_str(), "RANSAC") == 0) return RANSAC;
else if(strcasecmp(method.c_str(), "DISABLE") == 0) return DISABLE;
else throw std::runtime_error(std::string("registration method ") + method + std::string(" is unknown"));
}
2012-10-15 17:05:06 +00:00
string featureFiltrationMethodToString(feature_filtration_method method){
string fFiltrationMethod;
switch(method){
case OCCLUSION:
fFiltrationMethod = "OCCLUSION";
break;
case STANDARD_DEVIATION:
fFiltrationMethod = "STANDARD_DEVIATION";
break;
case DISABLE_FILTER:
fFiltrationMethod = "DISABLE_FILTER";
break;
default:
throw std::runtime_error(std::string("feature filtration method ") + to_string(method) + std::string(" could not be matched to a feature filtration method"));
}
return fFiltrationMethod;
}
feature_filtration_method stringToFeatureFiltrationMethod(string method){
if(strcasecmp(method.c_str(), "OCCLUSION") == 0) return OCCLUSION;
else if(strcasecmp(method.c_str(), "STANDARD_DEVIATION") == 0) return STANDARD_DEVIATION;
else if(strcasecmp(method.c_str(), "DISABLE_FILTER") == 0) return DISABLE_FILTER;
else throw std::runtime_error(std::string("feature filtration method ") + method + std::string(" is unknown"));
}
string matchingFiltrationMethodToString(matching_filtration_method method){
string mFiltrationMethod;
switch(method){
case FUNDEMENTAL_MATRIX:
mFiltrationMethod = "FUNDEMENTAL_MATRIX";
break;
case DISABLE_MATCHING_FILTER:
mFiltrationMethod = "DISABLE_MATCHING_FILTER";
break;
default:
throw std::runtime_error(std::string("matching filtration method ") + to_string(method) + std::string(" could not be matched to a matching filtration method"));
}
return mFiltrationMethod;
}
matching_filtration_method stringToMatchingFiltrationMethod(string method){
if(strcasecmp(method.c_str(), "FUNDEMENTAL_MATRIX") == 0) return FUNDEMENTAL_MATRIX;
else if(strcasecmp(method.c_str(), "DISABLE_MATCHING_FILTER") == 0) return DISABLE_MATCHING_FILTER;
else throw std::runtime_error(std::string("matching filtration method ") + method + std::string(" is unknown"));
}
2012-10-02 07:37:52 +00:00
}