THypothesis.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 THYPOTHESIS_H
#define THYPOTHESIS_H
 
#include <mrpt/poses/CPose2D.h>
#include <mrpt/poses/CPose3D.h>
#include <cstdint>
 
#include <iostream>
#include <string>
#include <sstream>
 
namespace mrpt
{
namespace graphs
{
namespace detail
{
/**\brief An edge hypothesis between two nodeIDs.
 *
 * Struct practically provides a wrapper around the GRAPH_T::constraint_t
 * instance. Represents a hypothesis for a potential, perhaps loop closing,
 * edge (i.e. a graph constraint/edge), between two nodeIDs of the graph.
 *
 * \sa mrpt::deciders::CLoopCloserERD
 * \ingroup mrpt_graphs_grp
 */
template <class GRAPH_T>
struct THypothesis
{
        /**\brief Handy typedefs */
        /**\{*/
        /**\brief type of graph constraints */
        using constraint_t = typename GRAPH_T::constraint_t;
        /**\brief type of underlying poses (2D/3D). */
        using pose_t = typename constraint_t::type_value;
        using self_t = THypothesis<GRAPH_T>;
        /**\}*/
        /**\brief Constructor */
        THypothesis();
        /**\brief Destructor */
        ~THypothesis();
        /**\brief Return a string representation of the object at hand
         *
         */
        /**\{*/
        std::string getAsString(bool oneline = true) const;
        void getAsString(std::string* str, bool oneline = true) const;
        /**\}*/
 
        /**\brief Getter methods for the underlying edge
         *
         * \sa setEdge
         */
        /**\{*/
        void getEdge(constraint_t* edge) const;
        constraint_t getEdge() const;
        /**\}*/
 
        /**\brief Setter method for the underlying edge
         *
         * \sa getEdge
         */
        void setEdge(const constraint_t& edge);
 
        /**\brief Getter methods for the inverse of the underlying edge */
        /**\{*/
        void getInverseEdge(constraint_t* edge) const;
        constraint_t getInverseEdge() const;
        /**\}*/
 
        /**\brief Reverse the hypothesis.
         *
         * Reversing implies, at least, changing order of from/to nodes and
         * reversing
         * the underlying edge
         */
        void inverseHypothesis();
 
        /**\brief ID of the current hypothesis */
        size_t id;
        /**\brief Starting node of the hypothesis */
        mrpt::graphs::TNodeID from;
        /**\brief Ending node of the hypothesis */
        mrpt::graphs::TNodeID to;
        /**\brief Field that specifies if the hypothesis is to be considered */
        bool is_valid;
        /**\brief Goodness value corresponding to the hypothesis edge
         *
         * \note For ICP edges this resolves to the CICP goodness measure for the
         * alignment operation.
         *
         * \sa edge, mrpt::slam::CICP::goodness
         */
        double goodness;
        /**\brief Compare the start and end nodes of two hypothesis
         *
         * \return True if ends match.
         */
        bool sameEndsWith(const self_t& other) const;
        /**\brief Check if the start, end nodes are the ones given
         *
         * \return True if ends are the given ones
         */
        bool hasEnds(
                const mrpt::graphs::TNodeID from, const mrpt::graphs::TNodeID to) const;
 
        /**\brief Handy operator for using THypothesis in std::set
         */
        bool operator<(const self_t& other) const;
 
        inline friend std::ostream& operator<<(
                std::ostream& o, const THypothesis<GRAPH_T>& h)
        {
                o << h.getAsString(/*oneline=*/true) << std::endl;
                return o;
        }
 
   private:
        /**\brief Edge connecting the two nodes */
        constraint_t edge;
};
}
}
}  // end of namespaces
 
#include "THypothesis_impl.h"
 
#endif /* end of include guard: THYPOTHESIS_H */