CHierarchicalMapMHPartition.h

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, 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 |
   +------------------------------------------------------------------------+ */
#ifndef CHierarchicalMapMHPartition_H
#define CHierarchicalMapMHPartition_H
 
#include <mrpt/hmtslam/CLocalMetricHypothesis.h>
#include <mrpt/hmtslam/CHMHMapArc.h>
#include <mrpt/hmtslam/CHMHMapNode.h>
 
#include <mrpt/poses/CPose3DPDFSOG.h>
#include <mrpt/poses/CPose3DPDFGaussian.h>
#include <mrpt/system/COutputLogger.h>
#include <mrpt/opengl/opengl_frwds.h>
 
#include <map>
 
namespace mrpt
{
namespace poses
{
class CPose3DPDFParticles;
}
 
namespace hmtslam
{
/** Represents a set of nodes and arcs, posibly only a part of the whole
 * hierarchical, multi-hypothesis map.
 *  A usar will never create an instance of this class, rather it will employ
 * CHierarchicalMHMap.
 * \sa CHierarchicalMHMap, CHMHMapArc, CHMHMapNode
  * \ingroup mrpt_hmtslam_grp
 */
class CHierarchicalMapMHPartition : public mrpt::system::COutputLogger
{
   protected:
    /** The internal list of nodes and arcs in the whole hierarchical model.
      *  The objects must be deleted only in the CHierarchicalMap class, not in
     * partitions only objects.
      */
    TNodeList m_nodes;
    TArcList m_arcs;
 
   public:
    using iterator = TNodeList::iterator;
    using const_iterator = TNodeList::const_iterator;
 
    /** Returns an iterator to the first node in the graph. */
    const_iterator begin() const { return m_nodes.begin(); }
    /** Returns an iterator to the first node in the graph. */
    iterator begin() { return m_nodes.begin(); }
    /** Returns an iterator to the end of the list of nodes in the graph. */
    const_iterator end() const { return m_nodes.end(); }
    /** Returns an iterator to the end of the list of nodes in the graph. */
    iterator end() { return m_nodes.end(); }
    CHierarchicalMapMHPartition() : m_nodes(), m_arcs() {}
    /** A type that reprensents a sequence of node IDs
      */
    using TNodeIDsList = std::vector<CHMHMapNode::TNodeID>;
 
    /** Returns the number of nodes in the partition:
      */
    size_t nodeCount() const;
 
    /** Returns the number of arcs in the partition:
      */
    size_t arcCount() const;
 
    /** Returns the first node in the graph, or nullptr if it does not exist.
      * \return A pointer to the object. DO NOT DELETE this object, if you want
     * to modify it in someway, first obtain a copy by invoking
     * "CSerializable::duplicate"
      */
    CHMHMapNode::Ptr getFirstNode();
 
    /** Returns the node with the given ID, or nullptr if it does not exist.
      * \return A pointer to the object. DO NOT DELETE this object, if you want
     * to modify it in someway, first obtain a copy by invoking
     * "CSerializable::duplicate"
      */
    CHMHMapNode::Ptr getNodeByID(CHMHMapNode::TNodeID id);
 
    /** Returns the node with the given ID, or nullptr if it does not exist.
      * \return A pointer to the object. DO NOT DELETE this object, if you want
     * to modify it in someway, first obtain a copy by invoking
     * "CSerializable::duplicate"
      */
    const CHMHMapNode::Ptr getNodeByID(CHMHMapNode::TNodeID id) const;
 
    /** Returns the node with the given label (case insensitive) for some given
     * hypothesis ID, or nullptr if it does not exist.
      * \return A pointer to the object. DO NOT DELETE this object, if you want
     * to modify it in someway, first obtain a copy by invoking
     * "CSerializable::duplicate"
      */
    CHMHMapNode::Ptr getNodeByLabel(
        const std::string& label, const THypothesisID& hypothesisID);
 
    /** Returns the node with the given label (case insensitive) for some given
     * hypothesis ID, or nullptr if it does not exist.
      * \return A pointer to the object. DO NOT DELETE this object, if you want
     * to modify it in someway, first obtain a copy by invoking
     * "CSerializable::duplicate"
      */
    const CHMHMapNode::Ptr getNodeByLabel(
        const std::string& label, const THypothesisID& hypothesisID) const;
 
    /** Returns a partition of this graph only with nodes at a given level in
      *the hierarchy (0=ground level,1=parent level,etc)
       *    - The partition may be empty if no node fulfills the condition.
       *    - All arcs STARTING at each node from the partition will be added to
      *the partition as well.
       *    - Levels in the hierarchy here stands for arcs of type
      *"arcType_Belongs" only.
       * \sa CHMHMapArc
       */
    // CHierarchicalMapMHPartition   getPartitionByHiearchyLevel( unsigned int
    // level );
 
    /** Saves a MATLAB script that represents graphically the nodes with
      *<i>type</i>="Area" in this hierarchical-map(partition), using the stated
      *node as global coordinates reference.
      *  ADDITIONAL NOTES:
      * - Coordinates are computed simply as the mean value of the first arc
      *with an annotation "RelativePose", added to the pose of the original
      *node.
      * - If the coordinates of any node can not be computed (no arcs,...), an
      *exception will be raised.
      */
    void saveAreasDiagramForMATLAB(
        const std::string& filName, const CHMHMapNode::TNodeID& idReferenceNode,
        const THypothesisID& hypothesisID) const;
 
    /** Saves a MATLAB script that represents graphically the nodes with
      *<i>type</i>="Area" in this hierarchical-map(partition), using the stated
      *node as global coordinates reference, and drawing the ellipses of the
      *localization uncertainty for each node.
      *  ADDITIONAL NOTES:
      * - Coordinates are computed simply as the mean value of the first arc
      *with an annotation "RelativePose", added to the pose of the original
      *node.
      * - If the coordinates of any node can not be computed (no arcs,...), an
      *exception will be raised.
      */
    void saveAreasDiagramWithEllipsedForMATLAB(
        const std::string& filName, const CHMHMapNode::TNodeID& idReferenceNode,
        const THypothesisID& hypothesisID,
        float uncertaintyExagerationFactor = 1.0f, bool drawArcs = false,
        unsigned int numberOfIterationsForOptimalGlobalPoses = 4) const;
 
    /** Saves a MATLAB script that represents graphically the reconstructed
      *"global map"
      *  ADDITIONAL NOTES:
      * - Coordinates are computed simply as the mean value of the first arc
      *with an annotation "RelativePose", added to the pose of the original
      *node.
      * - If the coordinates of any node can not be computed (no arcs,...), an
      *exception will be raised.
      */
    void saveGlobalMapForMATLAB(
        const std::string& filName, const THypothesisID& hypothesisID,
        const CHMHMapNode::TNodeID& idReferenceNode) const;
 
    /** The Dijkstra algorithm for finding the shortest path between a pair of
     * nodes.
      * \return The sequence of arcs connecting the nodes.It will be empty if no
     * path is found or when the starting and ending node coincide.
      */
    void findPathBetweenNodes(
        const CHMHMapNode::TNodeID& nodeFrom,
        const CHMHMapNode::TNodeID& nodeTo, const THypothesisID& hypothesisID,
        TArcList& out_path, bool direction = false) const;
 
    /** Draw a number of samples according to the PDF of the coordinates
     * transformation between a pair of "Area"'s nodes.
      * \exception std::exception If there is not enought information in arcs to
     * compute the PDF
      * \sa computeGloballyConsistentNodeCoordinates
      */
    void computeCoordinatesTransformationBetweenNodes(
        const CHMHMapNode::TNodeID& nodeFrom,
        const CHMHMapNode::TNodeID& nodeTo,
        mrpt::poses::CPose3DPDFParticles& posePDF,
        const THypothesisID& hypothesisID, unsigned int particlesCount = 100,
        float additionalNoiseXYratio = 0.02,
        float additionalNoisePhiRad = mrpt::DEG2RAD(0.1)) const;
 
    /** Computes the probability [0,1] of two areas' gridmaps to "match" (loop
     * closure), according to the grid maps and pose uncertainty from
     * information in arcs (uses a Monte Carlo aproximation)
       *  If there is not enough information or a robust estimation cannot be
     * found, there will not be particles in "estimatedRelativePose".
       */
    float computeMatchProbabilityBetweenNodes(
        const CHMHMapNode::TNodeID& nodeFrom,
        const CHMHMapNode::TNodeID& nodeTo, float& maxMatchProb,
        mrpt::poses::CPose3DPDFSOG& estimatedRelativePose,
        const THypothesisID& hypothesisID,
        unsigned int monteCarloSamplesPose = 300);
 
    /** Returns all the arcs between a pair of nodes:
      */
    void findArcsBetweenNodes(
        const CHMHMapNode::TNodeID& node1, const CHMHMapNode::TNodeID& node2,
        const THypothesisID& hypothesisID, TArcList& out_listArcs) const;
 
    /** Returns the arcs between a pair of nodes of a given type.
      */
    void findArcsOfTypeBetweenNodes(
        const CHMHMapNode::TNodeID& node1id,
        const CHMHMapNode::TNodeID& node2id, const THypothesisID& hypothesisID,
        const std::string& arcType, TArcList& ret) const;
 
    /** Returns the first arc between a pair of nodes of a given type, and if it
     * is in the opposite direction.
      * \return The arc, or nullptr if not found.
      */
    CHMHMapArc::Ptr findArcOfTypeBetweenNodes(
        const CHMHMapNode::TNodeID& node1id,
        const CHMHMapNode::TNodeID& node2id, const THypothesisID& hypothesisID,
        const std::string& arcType, bool& isInverted) const;
 
    /** Returns whether two nodes are "neightbour", i.e. have a direct arc
     * between them  */
    bool areNodesNeightbour(
        const CHMHMapNode::TNodeID& node1, const CHMHMapNode::TNodeID& node2,
        const THypothesisID& hypothesisID,
        const char* requiredAnnotation = nullptr) const;
 
    /** This methods implements a Lu&Milios-like globally optimal estimation for
     * the global coordinates of all the nodes in the graph according to all
     * available arcs with relative pose information.
      * Global coordinates will be computed relative to the node
     * "idReferenceNode".
      * \exception std::exception If there is any node without a pose arc,
     * invalid (non invertible) matrixes, etc...
      * \sa computeCoordinatesTransformationBetweenNodes
      */
    void computeGloballyConsistentNodeCoordinates(
        std::map<CHMHMapNode::TNodeID, mrpt::poses::CPose3DPDFGaussian,
                 std::less<CHMHMapNode::TNodeID>,
                 Eigen::aligned_allocator<
                     std::pair<const CHMHMapNode::TNodeID,
                               mrpt::poses::CPose3DPDFGaussian>>>& nodePoses,
        const CHMHMapNode::TNodeID& idReferenceNode,
        const THypothesisID& hypothesisID,
        const unsigned int& numberOfIterations = 2) const;
 
    /** Returns a 3D scene reconstruction of the hierarchical map.
      *  See "computeGloballyConsistentNodeCoordinates" for the meaning of
     * "numberOfIterationsForOptimalGlobalPoses"
      */
    void getAs3DScene(
        mrpt::opengl::COpenGLScene& outScene,
        const CHMHMapNode::TNodeID& idReferenceNode,
        const THypothesisID& hypothesisID,
        const unsigned int& numberOfIterationsForOptimalGlobalPoses = 5,
        const bool& showRobotPoseIDs = true) const;
 
    /** Return a textual description of the whole graph */
    void dumpAsText(std::vector<std::string>& s) const;
 
    /** Computes the probability [0,1] of two areas' gridmaps to overlap, via a
     * Monte Carlo aproximation.
      * \exception std::exception If there is not enought information in arcs,
     * etc...
      * \param margin_to_substract In meters, the area of each gridmap is
     * "eroded" this amount to compensate the area in excess usually found in
     * gridmaps.
      */
    double computeOverlapProbabilityBetweenNodes(
        const CHMHMapNode::TNodeID& nodeFrom,
        const CHMHMapNode::TNodeID& nodeTo, const THypothesisID& hypothesisID,
        const size_t& monteCarloSamples = 100,
        const float margin_to_substract = 6) const;
 
   protected:
};  // End of class def.
}
}
 
#endif