TUserOptionsChecker_impl.h

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          https://www.mrpt.org/                         |
   |                                                                        |
   | Copyright (c) 2005-2019, Individual contributors, see AUTHORS file     |
   | See: https://www.mrpt.org/Authors - All rights reserved.               |
   | Released under BSD License. See: https://www.mrpt.org/License          |
   +------------------------------------------------------------------------+ */

// implementation of the TUserOptionsChecker class template methods
namespace mrpt::graphslam::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 (auto it = regs_descriptions.begin(); it != regs_descriptions.end();
         ++it)
    {
        delete *it;
    }
    for (auto 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;

    ASSERTDEBMSG_(
        (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 (auto 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 (auto 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 (auto 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;

    ASSERTDEBMSG_(
        (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 (auto 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 (auto 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
        auto* 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.emplace_back(
            "CActionRobotMovement2D - Format #1");
        dec->observations_used.emplace_back("CObservationOdometry - Format #2");
        dec->is_slam_2d = true;
        dec->is_slam_3d = true;

        regs_descriptions.push_back(dec);
    }
    {  // CICPCriteriaNRD
        auto* 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.emplace_back(
            "CObservation2DRangeScan - Format #2");
        dec->observations_used.emplace_back(
            "CObservation3DRangeScan - Format #2");
        dec->is_slam_2d = true;

        regs_descriptions.push_back(dec);
    }
    {  // CEmptyNRD
        auto* 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
        auto* 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.emplace_back(
            "CObservation2DRangeScan - Format #1, #2");
        dec->observations_used.emplace_back(
            "CObservation3DRangeScan - Format #2");
        dec->is_slam_2d = true;

        regs_descriptions.push_back(dec);
    }
    {  // CEmptyERD
        auto* 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
        auto* 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.emplace_back(
            "CObservation2DRangeScan - Format #1, #2");
        dec->is_slam_2d = true;

        regs_descriptions.push_back(dec);
    }

    // registering the available optimizers
    {  // CEmptyGSO
        auto* 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
        auto* 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
}
}  // namespace mrpt::graphslam::apps