template class mrpt::graphslam::deciders::CEdgeRegistrationDecider¶

Interface for implementing edge registration classes.

CEdgeRegistrationDecider provides the basic methods that have to exist in every edge registration decider class. For an example of inheriting from this class see CICPCriteriaERD.

As a naming convention, all the implemented edge registration deciders are suffixed with the ERD acronym.

#include <mrpt/graphslam/interfaces/CEdgeRegistrationDecider.h>

template <class GRAPH_T = typename mrpt::graphs::CNetworkOfPoses2DInf>
class CEdgeRegistrationDecider: public mrpt::graphslam::CRegistrationDeciderOrOptimizer
{
public:
    // typedefs

    typedef mrpt::graphslam::CRegistrationDeciderOrOptimizer<GRAPH_T> parent;
    typedef typename GRAPH_T::constraint_t constraint_t;
    typedef typename GRAPH_T::constraint_t::type_value pose_t;

    //
methods

    virtual void getEdgesStats(std::map<std::string, int>* edge_type_to_num) const;
    virtual bool justInsertedLoopClosure() const;
    virtual void getDescriptiveReport(std::string* report_str) const;
    virtual bool updateState(mrpt::obs::CActionCollection::Ptr action, mrpt::obs::CSensoryFrame::Ptr observations, mrpt::obs::CObservation::Ptr observation) = 0;
    virtual void setWindowManagerPtr(mrpt::graphslam::CWindowManager* win_manager);
    virtual void setCriticalSectionPtr(std::mutex* graph_section);
    virtual void initializeVisuals();
    virtual void updateVisuals();
    virtual void notifyOfWindowEvents(const std::map<std::string, bool>& events_occurred);
    virtual void loadParams(const std::string& source_fname);
    virtual void printParams() const;
    virtual void setGraphPtr(GRAPH_T* graph);
    virtual void initializeLoggers(const std::string& name);
};

// direct descendants

template <class GRAPH_T = typename mrpt::graphs::CNetworkOfPoses2DInf>
class CEmptyERD;

template <class GRAPH_T>
class CRangeScanEdgeRegistrationDecider;

Inherited Members¶

public:
    // structs

    struct TMsg;

    //
methods

    virtual void setClassName(const std::string& name);
    bool isMultiRobotSlamClass();
    std::string getClassName() const;

Typedefs¶

typedef mrpt::graphslam::CRegistrationDeciderOrOptimizer<GRAPH_T> parent

Handy typedefs.

Parent of current class

typedef typename GRAPH_T::constraint_t constraint_t

type of graph constraints

typedef typename GRAPH_T::constraint_t::type_value pose_t

type of underlying poses (2D/3D).

Methods¶

virtual void getEdgesStats(std::map<std::string, int>* edge_type_to_num) const

Fill the given map with the type of registered edges as well as the corresponding number of registration of each edge.

virtual bool justInsertedLoopClosure() const

Used by the caller to query for possible loop closures in the last edge registration procedure.

virtual void getDescriptiveReport(std::string* report_str) const

Fill the provided string with a detailed report of the decider/optimizer state.

Report should include (part of) the following:

Timing of important methods
Properties fo class at the current time
Logging of commands until current time

virtual bool updateState(mrpt::obs::CActionCollection::Ptr action, mrpt::obs::CSensoryFrame::Ptr observations, mrpt::obs::CObservation::Ptr observation) = 0

Generic method for fetching the incremental action-observations (or observation-only) measurements.

Returns:

True if operation was successful. Criteria for Success depend on the decider/optimizer implementing this method

virtual void setWindowManagerPtr(mrpt::graphslam::CWindowManager* win_manager)

Fetch a CWindowManager pointer.

CWindowManager instance should contain a CDisplayWindow3D* and, optionally, a CWindowObserver pointer so that interaction with the window is possible

virtual void setCriticalSectionPtr(std::mutex* graph_section)

Fetch a std::mutex for locking the GRAPH_T resource.

Handy for realising multithreading in the derived classes.

Beware that prior to the decider/optimizer public method call, the CCriticalSection will already be locked from CGraphSlamEngine_t instance, but this isn’t effective in multithreaded implementations where the decider/optimizer itself has to lock the function at which the extra thread runs.

virtual void initializeVisuals()

Initialize visual objects in CDisplayWindow (e.g.

add an object to scene).

Parameters:

std::exception

If the method is called without having first provided a CDisplayWindow3D* to the class instance