TUncertaintyPath_impl.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 TUNCERTAINTYPATH_IMPL_H
#define TUNCERTAINTYPATH_IMPL_H
 
#include <mrpt/containers/stl_containers_utils.h>
 
// Implementattion file for TUncertaintyPath struct
 
namespace mrpt
{
namespace graphslam
{
template <class GRAPH_T>
TUncertaintyPath<GRAPH_T>::TUncertaintyPath()
{
        this->clear();
}
template <class GRAPH_T>
TUncertaintyPath<GRAPH_T>::TUncertaintyPath(
        const mrpt::graphs::TNodeID& starting_node)
{
        this->clear();
        nodes_traversed.push_back(starting_node);
}
template <class GRAPH_T>
TUncertaintyPath<GRAPH_T>::TUncertaintyPath(
        const mrpt::graphs::TNodeID& starting_node,
        const mrpt::graphs::TNodeID& ending_node, const constraint_t& edge)
{
        this->clear();
        nodes_traversed.push_back(starting_node);
        this->addToPath(ending_node, edge);
}
 
template <class GRAPH_T>
TUncertaintyPath<GRAPH_T>::~TUncertaintyPath()
{
}
 
template <class GRAPH_T>
void TUncertaintyPath<GRAPH_T>::clear()
{
        using namespace mrpt;
        using namespace mrpt::math;
        using namespace mrpt::poses;
        using namespace std;
 
        // clear the vector of traversed nodes
        nodes_traversed.clear();
 
        // clear the relative edge
        curr_pose_pdf.mean = pose_t();
        // by default the information matrix is set to the unit matrix
        CMatrixDouble33 init_path_mat;
        init_path_mat.unit();
        // put a really large number - we are certain of this position
        init_path_mat *= 10000;  // TODO - justify this..
        curr_pose_pdf.cov_inv = init_path_mat;
 
        determinant_is_updated = false;
        determinant_cached = 0;
 
}  // end of clear
 
template <class GRAPH_T>
bool TUncertaintyPath<GRAPH_T>::isEmpty() const
{
        return *this == self_t();
}
 
template <class GRAPH_T>
void TUncertaintyPath<GRAPH_T>::assertIsBetweenNodeIDs(
        const mrpt::graphs::TNodeID& from, const mrpt::graphs::TNodeID& to) const
{
        ASSERTDEBMSG_(
                this->getSource() == from,
                format(
                        "\nnodeID %lu is not the source of the path\n%s\n\n",
                        static_cast<unsigned long>(from), this->getAsString().c_str()));
        ASSERTDEBMSG_(
                this->getDestination() == to,
                format(
                        "\nnodeID %lu is not the destination of the path\n%s\n\n",
                        static_cast<unsigned long>(to), this->getAsString().c_str()));
}
 
template <class GRAPH_T>
TUncertaintyPath<GRAPH_T>& TUncertaintyPath<GRAPH_T>::operator+=(
        const self_t& other)
{
        using namespace mrpt;
        using namespace mrpt::math;
        using namespace mrpt::poses;
        using namespace std;
 
        // other path should start where this ends
        ASSERTDEBMSG_(
                other.nodes_traversed.begin()[0] == this->nodes_traversed.rbegin()[0],
                "\"other\" instance must start from the nodeID that this "
                "TUncertaintyPath has ended.");
        ASSERTDEBMSG_(
                other.nodes_traversed.size(),
                "\"other\" instance doesn't have an initialized list of traversed "
                "nodes");
        ASSERTDEBMSG_(
                this->nodes_traversed.size(),
                "\"this\" instance doesn't have an initialized list of traversed "
                "nodes");
 
        //////// TODO Remove these - >>>>>>>>>>>>>>>>>>>>>
        // cout << string(20, '-') << "Aggregating 2 paths.."
        //<< string(20, '-') << endl;
        // this->dumpToConsole(); other.dumpToConsole();
        ////// TODO Remove these - <<<<<<<<<<<<<<<<<<<<<
 
        // aggregate the two gaussian - mean & information matrix
        this->curr_pose_pdf += other.curr_pose_pdf;
 
        // add the traversed nodes
        this->nodes_traversed.insert(
                this->nodes_traversed.end(), other.nodes_traversed.begin() + 1,
                other.nodes_traversed.end());
 
        ////// TODO Remove these - >>>>>>>>>>>>>>>>>>>>>
        // cout << std::string(10, '%') << endl << "AFTER Aggregation..." << endl;
        // this->dumpToConsole();
        // cout << string(50, '-') << endl;
        // mrpt::system::pause();
        ////// TODO Remove these - <<<<<<<<<<<<<<<<<<<<<
 
        determinant_is_updated = false;
        return *this;
}
template <class GRAPH_T>
bool TUncertaintyPath<GRAPH_T>::operator==(const self_t& other) const
{
        using namespace mrpt;
        using namespace mrpt::math;
        using namespace mrpt::poses;
        using namespace std;
 
        // check if the traversed nodes are the same as well as the
        // CPoseGaussianInfs are the same..
        return (
                this->nodes_traversed == other.nodes_traversed &&
                this->curr_pose_pdf == other.curr_pose_pdf);
}
template <class GRAPH_T>
bool TUncertaintyPath<GRAPH_T>::operator!=(const self_t& other) const
{
        return !(*this == other);
}
 
template <class GRAPH_T>
void TUncertaintyPath<GRAPH_T>::addToPath(
        const mrpt::graphs::TNodeID& node, const constraint_t& edge)
{
        // update the path
        curr_pose_pdf += edge;
 
        // update the traversed nodes
        nodes_traversed.push_back(node);
 
        determinant_is_updated = false;
}
 
template <class GRAPH_T>
void TUncertaintyPath<GRAPH_T>::loadFromConfigFile(
        const mrpt::config::CConfigFileBase& source, const std::string& section)
{
}
 
template <class GRAPH_T>
void TUncertaintyPath<GRAPH_T>::dumpToTextStream(std::ostream& out) const
{
        out << mrpt::format("%s\n", this->getAsString().c_str());
}
 
template <class GRAPH_T>
void TUncertaintyPath<GRAPH_T>::getAsString(std::string* str) const
{
        using namespace mrpt;
        using namespace mrpt::poses;
        using namespace std;
        using namespace mrpt::math;
        using namespace mrpt::containers;
 
        stringstream ss;
        string header_sep(30, '=');
 
        ss << "Path properties: " << endl;
        ss << header_sep << endl << endl;
 
        ss << "- CPosePDFGaussianInf: "
           << (curr_pose_pdf.isInfType() ? "TRUE" : "FALSE") << endl;
        ss << "- Nodes list: \n\t< " << getSTLContainerAsString(nodes_traversed)
           << "\b\b>" << endl;
 
        ss << endl;
        ss << curr_pose_pdf << endl;
        ss << endl;
 
        CMatrixDouble33 mat;
        if (curr_pose_pdf.isInfType())
        {
                curr_pose_pdf.getInformationMatrix(mat);
        }
        else
        {
                curr_pose_pdf.getCovariance(mat);
        }
        ss << "Determinant: " << mat.det();
 
        *str = ss.str();
}
template <class GRAPH_T>
std::string TUncertaintyPath<GRAPH_T>::getAsString() const
{
        std::string s;
        this->getAsString(&s);
        return s;
}
 
template <class GRAPH_T>
const mrpt::graphs::TNodeID& TUncertaintyPath<GRAPH_T>::getSource() const
{
        return nodes_traversed.at(0);
}
template <class GRAPH_T>
const mrpt::graphs::TNodeID& TUncertaintyPath<GRAPH_T>::getDestination() const
{
        return nodes_traversed.back();
}
 
template <class GRAPH_T>
double TUncertaintyPath<GRAPH_T>::getDeterminant()
{
        using namespace mrpt;
        using namespace mrpt::math;
        using namespace mrpt::poses;
        using namespace std;
 
        // if determinant is up-to-date then return the cached version...
        if (determinant_is_updated) return determinant_cached;
 
        // update the cached version and return it.
        CMatrixDouble33 mat;
        if (curr_pose_pdf.isInfType())
        {
                curr_pose_pdf.getInformationMatrix(mat);
        }
        else
        {
                curr_pose_pdf.getCovariance(mat);
        }
        double determinant = mat.det();
 
        determinant_cached = determinant;
        determinant_is_updated = true;
 
        return determinant;
}
 
template <class GRAPH_T>
bool TUncertaintyPath<GRAPH_T>::hasLowerUncertaintyThan(
        const self_t& other) const
{
        using namespace mrpt;
        using namespace mrpt::math;
        using namespace mrpt::poses;
        using namespace std;
 
        ASSERTDEBMSG_(
                (curr_pose_pdf.isInfType() && other.curr_pose_pdf.isInfType()) ||
                        (!curr_pose_pdf.isInfType() && !other.curr_pose_pdf.isInfType()),
                mrpt::format(
                        "Constraints of given paths don't have the same "
                        "representation of uncertainty"));
 
        // If we are talking about information form matrices, the *higher* the
        // determinant the more confident we are.
        // if we are talking about covariances then the *lower*.
        bool has_lower = false;
        if (curr_pose_pdf.isInfType())
        {
                has_lower = this->getDeterminant() > other.getDeterminant();
        }
        else
        {
                has_lower = this->getDeterminant() < other.getDeterminant();
        }
 
        return has_lower;
}
}
}  // end of namespaces
 
#endif /* end of include guard: TUNCERTAINTYPATH_IMPL_H */