TUserOptionsChecker_impl.h

Go to the documentation of this file.

/* +---------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)               |
   |                          http://www.mrpt.org/                             |
   |                                                                           |
   | Copyright (c) 2005-2017, Individual contributors, see AUTHORS file        |
   | See: http://www.mrpt.org/Authors - All rights reserved.                   |
   | Released under BSD License. See details in http://www.mrpt.org/License    |
   +---------------------------------------------------------------------------+ */
 
// implementation of the TUserOptionsChecker class template methods
namespace mrpt { namespace graphslam { namespace apps {
 
template<class GRAPH_t>
TUserOptionsChecker<GRAPH_t>::TUserOptionsChecker():
        sep_header(40, '='),
        sep_subheader(20, '-')
{ }
 
template<class GRAPH_t>
TUserOptionsChecker<GRAPH_t>::~TUserOptionsChecker(){
        using namespace std;
 
        // release the instances holding the descriptions of the available
        // deciders/optimizers
        for (vector<TRegistrationDeciderProps*>::iterator
                        it = regs_descriptions.begin();
                        it != regs_descriptions.end();
                        ++it) {
                delete *it;
        }
        for (vector<TOptimizerProps*>::iterator
                        it = optimizers_descriptions.begin();
                        it != optimizers_descriptions.end();
                        ++it) {
                delete *it;
        }
 
}
 
template<class GRAPH_t>
void TUserOptionsChecker<GRAPH_t>::createDeciderOptimizerMappings() {
        MRPT_START;
 
        using namespace mrpt::graphslam::deciders;
        using namespace mrpt::graphslam::optimizers;
        using namespace mrpt::graphs;
        using namespace mrpt::poses;
 
        // node registration deciders
        node_regs_map["CEmptyNRD"] =
                &createNodeRegistrationDecider<CEmptyNRD<GRAPH_t> >;
        node_regs_map["CFixedIntervalsNRD"] =
                        &createNodeRegistrationDecider<CFixedIntervalsNRD<GRAPH_t> >;
        // edge registration deciders
        edge_regs_map["CEmptyERD"] =
                &createEdgeRegistrationDecider<CEmptyERD<GRAPH_t> >;
        // optimizers
        optimizers_map["CLevMarqGSO"] =
                &createGraphSlamOptimizer<CLevMarqGSO<GRAPH_t> >;
        optimizers_map["CEmptyGSO"] =
                &createGraphSlamOptimizer<CLevMarqGSO<GRAPH_t> >;
 
        // create the decider optimizer, specific to the GRAPH_T template type
        this->_createDeciderOptimizerMappings();
 
 
        MRPT_END;
}
 
template<class GRAPH_t>
void TUserOptionsChecker<GRAPH_t>::_createDeciderOptimizerMappings() {
}
 
// deciders/optpimizers specific to the 2D SLAM cases
template<>
inline void TUserOptionsChecker<mrpt::graphs::CNetworkOfPoses2DInf>::_createDeciderOptimizerMappings() {
        using namespace mrpt::graphs;
 
        node_regs_map["CICPCriteriaNRD"] =
                &createNodeRegistrationDecider<CICPCriteriaNRD<CNetworkOfPoses2DInf> >;
        edge_regs_map["CICPCriteriaERD"] =
                        &createEdgeRegistrationDecider<CICPCriteriaERD<CNetworkOfPoses2DInf> >;
        edge_regs_map["CLoopCloserERD"] =
                        &createEdgeRegistrationDecider<CLoopCloserERD<CNetworkOfPoses2DInf> >;
 
}
template<>
inline void TUserOptionsChecker<mrpt::graphs::CNetworkOfPoses2DInf_NA>::_createDeciderOptimizerMappings() {
        using namespace mrpt::graphs;
 
        node_regs_map["CICPCriteriaNRD"] =
                &createNodeRegistrationDecider<CICPCriteriaNRD<CNetworkOfPoses2DInf_NA> >;
        edge_regs_map["CICPCriteriaERD"] =
                        &createEdgeRegistrationDecider<CICPCriteriaERD<CNetworkOfPoses2DInf_NA> >;
        edge_regs_map["CLoopCloserERD"] =
                        &createEdgeRegistrationDecider<CLoopCloserERD<CNetworkOfPoses2DInf_NA> >;
}
 
// deciders/optpimizers specific to the 3D SLAM cases
template<>
inline void TUserOptionsChecker<mrpt::graphs::CNetworkOfPoses3DInf>::_createDeciderOptimizerMappings() {
 
}
 
template<class GRAPH_t>
void TUserOptionsChecker<GRAPH_t>::dumpRegistrarsToConsole(
                std::string reg_type/*="all"*/) const {
        MRPT_START;
        using namespace std;
        using  namespace mrpt;
 
        ASSERTMSG_((system::strCmpI(reg_type, "node") ||
                                system::strCmpI(reg_type, "edge") ||
                                system::strCmpI(reg_type, "all")),
                        format("Registrar string '%s' does not match a known registrar name.\n"
                                "Specify 'node' 'edge' or 'all'", reg_type.c_str()));
 
 
        if ( system::strCmpI(reg_type, "node") || system::strCmpI(reg_type, "edge") ) {
 
                cout << endl << "Available " << system::upperCase(reg_type) << " Registration Deciders: " << endl;
                cout << sep_header << endl;
 
                for (vector<TRegistrationDeciderProps*>::const_iterator
                                dec_it = regs_descriptions.begin();
                                dec_it != regs_descriptions.end(); ++dec_it) {
                        TRegistrationDeciderProps* dec = *dec_it;
                        if ( system::strCmpI(dec->type, reg_type) ) {
                                cout << dec->name << endl;
                                cout << sep_subheader << endl;
                                cout << "\t- " << "Description: " <<  dec->description << endl;
                                cout << "\t- " << "Rawlog Format: " <<  dec->rawlog_format << endl;
                                cout << "\t- " << "Observations that can be used: " << endl;
                                cout << "\t- " << "Multi-robot SLAM capable decider: " <<
                                        (dec->is_mr_slam_class? "TRUE": "FALSE") << endl;
                                cout << "\t- " << "SLAM Type: " << endl;
                                if (dec->is_slam_2d) {
                                        cout << "\t\t+ " << "2D" << endl;
                                }
                                if (dec->is_slam_3d) {
                                        cout << "\t\t+ " << "3D" << endl;
                                }
                                cout << endl;
                                for (vector<string>::const_iterator obs_it = dec->observations_used.begin();
                                                obs_it != dec->observations_used.end(); ++obs_it) {
                                        cout << "\t\t+ " << *obs_it << endl;
                                }
                        }
                }
        }
        else { // print both
                dumpRegistrarsToConsole("node");
                dumpRegistrarsToConsole("edge");
        }
 
        MRPT_END;
}
 
template<class GRAPH_t>
void TUserOptionsChecker<GRAPH_t>::dumpOptimizersToConsole() const {
        MRPT_START;
 
        using namespace std;
 
        cout << endl << "Available GraphSlam Optimizer classes: " << endl;
        cout << sep_header << endl;
 
        for (vector<TOptimizerProps*>::const_iterator opt_it = optimizers_descriptions.begin();
                        opt_it != optimizers_descriptions.end(); ++opt_it) {
                TOptimizerProps* opt = *opt_it;
                cout << opt->name << endl;
                cout << sep_subheader << endl;
                cout << "\t- " << "Description: " <<  opt->description << endl;
 
                cout << "\t- " << "Multi-robot SLAM capable optimizer: " <<
                        (opt->is_mr_slam_class? "TRUE": "FALSE");
                cout << "\t- " << "SLAM Type: " << endl;
                if (opt->is_slam_2d) {
                        cout << "\t\t+ " << "2D" << endl;
                }
                if (opt->is_slam_3d) {
                        cout << "\t\t+ " << "3D" << endl;
                }
        }
        MRPT_END;
}
 
template<class GRAPH_t>
bool TUserOptionsChecker<GRAPH_t>::checkRegistrationDeciderExists(
                std::string given_reg,
                std::string reg_type) const {
        MRPT_START;
 
        using namespace std;
        using  namespace mrpt;
        using namespace mrpt::poses;
 
        ASSERTMSG_((system::strCmpI(reg_type, "node") ||
                        system::strCmpI(reg_type, "edge")),
                        format("Registrar string \"%s\" does not match a known registrar name.\n"
                                "Specify 'node' or 'edge' ", reg_type.c_str()));
        bool found = false;
 
        for (vector<TRegistrationDeciderProps*>::const_iterator
                        dec_it = regs_descriptions.begin();
                        dec_it != regs_descriptions.end(); ++dec_it) {
                TRegistrationDeciderProps* dec = *dec_it;
 
                // TODO - check this
                // if decider is not suitable for the selected SLAM type, ignore.
                pose_t p;
                if ((!dec->is_slam_2d && IS_CLASS(&p, CPose2D)) ||
                                (!dec->is_slam_3d && IS_CLASS(&p, CPose3D))) {
                        continue;
                }
 
                if (system::strCmpI(dec->type, reg_type)) {
                        if (system::strCmpI(dec->name, given_reg)) {
                                found = true;
                                return found;
                        }
                }
        }
 
        return found;
        MRPT_END;
}
 
template<class GRAPH_t>
bool TUserOptionsChecker<GRAPH_t>::checkOptimizerExists(std::string given_opt) const {
        MRPT_START;
        using namespace std;
        using  namespace mrpt;
        using namespace mrpt::poses;
 
        bool found = false;
 
        for (vector<TOptimizerProps*>::const_iterator
                        opt_it = optimizers_descriptions.begin();
                        opt_it != optimizers_descriptions.end(); ++opt_it) {
                TOptimizerProps* opt = *opt_it;
 
                // if optimizer is not suitable for the selected SLAM type, ignore.
                pose_t p;
                if ((!opt->is_slam_2d && IS_CLASS(&p, CPose2D)) &&
                                (!opt->is_slam_3d && IS_CLASS(&p, CPose3D))) {
                        continue;
                }
 
                if ( system::strCmpI(opt->name, given_opt) ) {
                        found = true;
                        return found;
                }
        }
 
        return found;
        MRPT_END;
}
 
template<class GRAPH_t>
void TUserOptionsChecker<GRAPH_t>::populateDeciderOptimizerProperties() {
        MRPT_START;
 
        // reset the vectors - in case they contain any elements
        regs_descriptions.clear();
        optimizers_descriptions.clear();
 
        // registering the available deciders
        { // CFixedIntervalsNRD
                TRegistrationDeciderProps* dec = new TRegistrationDeciderProps;
                dec->name = "CFixedIntervalsNRD";
                dec->description = "Register a new node if the distance from the previous node surpasses a predefined distance threshold. Uses odometry information for estimating the robot movement";
                dec->type = "Node";
                dec->rawlog_format = "Both";
                dec->observations_used.push_back("CActionRobotMovement2D - Format #1");
                dec->observations_used.push_back("CObservationOdometry - Format #2");
                dec->is_slam_2d = true;
                dec->is_slam_3d = true;
 
                regs_descriptions.push_back(dec);
        }
        { // CICPCriteriaNRD
                TRegistrationDeciderProps* dec = new TRegistrationDeciderProps;
                dec->name = "CICPCriteriaNRD";
                dec->description = "Register a new node if the distance from the previous node surpasses a predefined distance threshold. Uses 2D/3D RangeScans alignment for estimating the robot movement";
                dec->type = "Node";
                dec->rawlog_format = "#2 - Observation-only";
                dec->observations_used.push_back("CObservation2DRangeScan - Format #2");
                dec->observations_used.push_back("CObservation3DRangeScan - Format #2");
                dec->is_slam_2d = true;
 
                regs_descriptions.push_back(dec);
        }
        { // CEmptyNRD
                TRegistrationDeciderProps* dec = new TRegistrationDeciderProps;
                dec->name = "CEmptyNRD";
                dec->description = "Empty Decider - does nothing when its class methods are called";
                dec->type = "Node";
                dec->rawlog_format = "Both";
                dec->is_mr_slam_class = true;
                dec->is_slam_2d = true;
                dec->is_slam_3d = true;
 
                regs_descriptions.push_back(dec);
        }
        { // CICPCriteriaERD
                TRegistrationDeciderProps* dec = new TRegistrationDeciderProps;
                dec->name = "CICPCriteriaERD";
                dec->description = "Register a new edge by aligning the provided 2D/3D RangeScans of 2 nodes. Uses the goodness of the ICP Alignment as the criterium for adding a new edge";
                dec->type = "Edge";
                dec->rawlog_format = "Both";
                dec->observations_used.push_back("CObservation2DRangeScan - Format #1, #2");
                dec->observations_used.push_back("CObservation3DRangeScan - Format #2");
                dec->is_slam_2d = true;
 
                regs_descriptions.push_back(dec);
        }
        { // CEmptyERD
                TRegistrationDeciderProps* dec = new TRegistrationDeciderProps;
                dec->name = "CEmptyERD";
                dec->description = "Empty Decider - does nothing when its class methods are called";
                dec->type = "Edge";
                dec->rawlog_format = "Both";
                dec->is_mr_slam_class = true;
                dec->is_slam_2d = true;
                dec->is_slam_3d = true;
 
                regs_descriptions.push_back(dec);
        }
        { // CLoopCloserERD
                TRegistrationDeciderProps* dec = new TRegistrationDeciderProps;
                dec->name = "CLoopCloserERD";
                dec->description = "Partition the map and register *sets* of edges based on the Pairwise consistency matrix of each set.";
                dec->type = "Edge";
                dec->rawlog_format = "Both";
                dec->observations_used.push_back("CObservation2DRangeScan - Format #1, #2");
                dec->is_slam_2d = true;
 
                regs_descriptions.push_back(dec);
        }
 
        // registering the available optimizers
        { // CEmptyGSO
                TOptimizerProps* opt = new TOptimizerProps;
                opt->name = "CEmptyGSO";
                opt->description = "Empty Optimizer - does nothing when its class methods are called";
                opt->is_mr_slam_class = true;
                opt->is_slam_2d = true;
                opt->is_slam_3d = true;
 
                optimizers_descriptions.push_back(opt);
        }
 
        { // CLevMarqGSO
                TOptimizerProps* opt = new TOptimizerProps;
                opt->name = "CLevMarqGSO";
                opt->description = "Levenberg-Marqurdt non-linear graphSLAM solver";
                opt->is_mr_slam_class = true;
                opt->is_slam_2d = true;
                opt->is_slam_3d = true;
 
                optimizers_descriptions.push_back(opt);
        }
 
        MRPT_END
}
 
 
 
} } } // END OF NAMESPACES