TWaypoint.cpp

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 |
   +------------------------------------------------------------------------+ */
 
#include "nav-precomp.h"  // Precomp header
 
#include <mrpt/nav/reactive/TWaypoint.h>
#include <mrpt/opengl/CSetOfObjects.h>
#include <mrpt/opengl/CDisk.h>
#include <mrpt/opengl/CArrow.h>
#include <limits>
 
using namespace mrpt::nav;
using namespace std;
 
// TWaypoint  ==========
TWaypoint::TWaypoint()
    : target(INVALID_NUM, INVALID_NUM),
      target_heading(INVALID_NUM),
      target_frame_id("map"),
      allowed_distance(INVALID_NUM),
      allow_skip(true)
{
}
 
TWaypoint::TWaypoint(
    double target_x, double target_y, double allowed_distance_,
    bool allow_skip_, double target_heading_)
    : target(target_x, target_y),
      target_heading(target_heading_),
      target_frame_id("map"),
      allowed_distance(allowed_distance_),
      allow_skip(allow_skip_)
{
}
 
bool TWaypoint::isValid() const
{
    return (target.x != INVALID_NUM) && (target.y != INVALID_NUM) &&
           (allowed_distance != INVALID_NUM);
}
 
std::string TWaypoint::getAsText() const
{
    std::string s;
    if (target.x != INVALID_NUM && target.y != INVALID_NUM)
        s += mrpt::format("target=(%8.03f,%8.03f) ", target.x, target.y);
    else
        s += "target=(**Coordinates not set!!**) ";
 
    if (target_heading != INVALID_NUM)
        s += mrpt::format("phi=%8.03f deg ", mrpt::RAD2DEG(target_heading));
    else
        s += " (heading: any) ";
 
    if (allowed_distance != INVALID_NUM)
        s += mrpt::format("allowed_dist=%8.03f ", allowed_distance);
    else
        s += " (**allowed_distance not set!!**) ";
 
    s += (allow_skip ? " allow_skip: YES" : " allow_skip: NO ");
 
    return s;
}
 
// TWaypointSequence ==========
TWaypointSequence::TWaypointSequence() {}
// Gets navigation params as a human-readable format:
std::string TWaypointSequence::getAsText() const
{
    string s;
    s += mrpt::format(
        "List of %u waypoints:\n", static_cast<unsigned int>(waypoints.size()));
    unsigned int i = 0;
    for (const auto& wp : waypoints)
    {
        s += mrpt::format(" #%3u: ", i++);
        s += wp.getAsText();
        s += "\n";
    }
    return s;
}
 
// TWaypointStatus ==========
TWaypointStatus::TWaypointStatus()
    : reached(false),
      skipped(false),
      timestamp_reach(INVALID_TIMESTAMP),
      counter_seen_reachable(0)
{
}
TWaypointStatus& TWaypointStatus::operator=(const TWaypoint& wp)
{
    TWaypoint::operator=(wp);
    return *this;
}
std::string TWaypointStatus::getAsText() const
{
    std::string s = TWaypoint::getAsText();
    s += mrpt::format(" reached=%s", (reached ? "YES" : "NO "));
    ;
    return s;
}
 
// TWaypointStatusSequence ======
TWaypointStatusSequence::TWaypointStatusSequence()
    : waypoints(),
      timestamp_nav_started(INVALID_TIMESTAMP),
      final_goal_reached(false),
      waypoint_index_current_goal(-1),
      last_robot_pose(
          TWaypoint::INVALID_NUM, TWaypoint::INVALID_NUM,
          TWaypoint::INVALID_NUM)
{
}
 
std::string TWaypointStatusSequence::getAsText() const
{
    string s;
    s += mrpt::format(
        "Status for %u waypoints:\n",
        static_cast<unsigned int>(waypoints.size()));
    unsigned int i = 0;
    for (const auto& wp : waypoints)
    {
        s += mrpt::format(" #%3u: ", i++);
        s += wp.getAsText();
        s += "\n";
    }
    s += mrpt::format(
        " final_goal_reached:%s  waypoint_index_current_goal=%d\n",
        (final_goal_reached ? "YES" : "NO "), waypoint_index_current_goal);
    return s;
}
 
TWaypointsRenderingParams::TWaypointsRenderingParams()
    : outter_radius(.3),
      inner_radius(.2),
      outter_radius_non_skippable(.3),
      inner_radius_non_skippable(.0),
      outter_radius_reached(.2),
      inner_radius_reached(.1),
      heading_arrow_len(1.0),
      color_regular(mrpt::img::TColor(0x00, 0x00, 0xff)),
      color_current_goal(mrpt::img::TColor(0xff, 0x00, 0x20)),
      color_reached(mrpt::img::TColor(0x00, 0x00, 0xc0, 0xd0)),
      show_labels(true)
{
}
 
void TWaypointSequence::getAsOpenglVisualization(
    mrpt::opengl::CSetOfObjects& obj,
    const mrpt::nav::TWaypointsRenderingParams& params) const
{
    obj.clear();
    unsigned int idx = 0;
    for (const auto& p : waypoints)
    {
        auto gl_pt = mrpt::make_aligned_shared<mrpt::opengl::CDisk>(
            p.allow_skip ? params.outter_radius
                         : params.outter_radius_non_skippable,
            p.allow_skip ? params.inner_radius
                         : params.inner_radius_non_skippable,
            15);
        gl_pt->setLocation(p.target.x, p.target.y, 0.01);
        gl_pt->setColor_u8(params.color_regular);
        if (params.show_labels)
        {
            gl_pt->setName(mrpt::format("WayPt #%2u", idx));
            gl_pt->enableShowName(true);
        }
        obj.insert(gl_pt);
 
        if (p.target_heading != TWaypoint::INVALID_NUM)
        {
            auto o = mrpt::make_aligned_shared<mrpt::opengl::CArrow>(
                0, 0, 0, params.heading_arrow_len, 0.0f, 0.0f);
            o->setPose(
                mrpt::poses::CPose3D(
                    p.target.x, p.target.y, 0.02, p.target_heading, 0, 0));
            obj.insert(o);
        }
        ++idx;
    }
}
 
void TWaypointStatusSequence::getAsOpenglVisualization(
    mrpt::opengl::CSetOfObjects& obj,
    const mrpt::nav::TWaypointsRenderingParams& params) const
{
    obj.clear();
    {
        unsigned int idx = 0;
        for (const auto& p : waypoints)
        {
            const bool is_cur_goal = (int(idx) == waypoint_index_current_goal);
 
            mrpt::opengl::CDisk::Ptr gl_pt =
                mrpt::make_aligned_shared<mrpt::opengl::CDisk>(
                    p.reached
                        ? params.outter_radius_reached
                        : (p.allow_skip ? params.outter_radius
                                        : params.outter_radius_non_skippable),
                    p.reached
                        ? params.inner_radius_reached
                        : (p.allow_skip ? params.inner_radius
                                        : params.inner_radius_non_skippable),
                    15);
            gl_pt->setLocation(p.target.x, p.target.y, 0.01);
            if (params.show_labels)
            {
                gl_pt->setName(
                    mrpt::format(
                        "WayPt #%2u Reach:%s", idx, p.reached ? "YES" : "NO"));
                gl_pt->enableShowName(true);
            }
            gl_pt->setColor_u8(
                is_cur_goal ? params.color_current_goal
                            : (p.reached ? params.color_reached
                                         : params.color_regular));
            obj.insert(gl_pt);
 
            if (p.target_heading != TWaypoint::INVALID_NUM)
            {
                auto o = mrpt::make_aligned_shared<mrpt::opengl::CArrow>(
                    0, 0, 0, params.heading_arrow_len, 0.0f, 0.0f);
                o->setPose(
                    mrpt::poses::CPose3D(
                        p.target.x, p.target.y, 0.02, p.target_heading, 0, 0));
                obj.insert(o);
            }
            ++idx;
        }
    }
}
 
void TWaypointSequence::save(
    mrpt::config::CConfigFileBase& c, const std::string& s) const
{
    const unsigned int N = waypoints.size();
    c.write(s, "waypoint_count", N);
 
    const int NP = 27;  // name padding
 
    for (unsigned int i = 0; i < N; i++)
    {
        const auto& wp = waypoints[i];
 
        c.write(
            s, mrpt::format("wp%03u_allowed_distance", i), wp.allowed_distance,
            NP);
        c.write(s, mrpt::format("wp%03u_allow_skip", i), wp.allow_skip, NP);
        c.write(s, mrpt::format("wp%03u_target_x", i), wp.target.x, NP);
        c.write(s, mrpt::format("wp%03u_target_y", i), wp.target.y, NP);
        c.write(
            s, mrpt::format("wp%03u_target_frame_id", i), wp.target_frame_id,
            NP);
        c.write(
            s, mrpt::format("wp%03u_target_heading", i), wp.target_heading, NP);
    }
}
 
void TWaypointSequence::load(
    const mrpt::config::CConfigFileBase& c, const std::string& s)
{
    this->clear();
 
    const unsigned int N = c.read_int(s, "waypoint_count", 0, true);
    waypoints.resize(N);
 
    for (unsigned int i = 0; i < N; i++)
    {
        auto& wp = waypoints[i];
 
        wp.allowed_distance = c.read_double(
            s, mrpt::format("wp%03u_allowed_distance", i), 0, true);
        wp.allow_skip =
            c.read_bool(s, mrpt::format("wp%03u_allow_skip", i), true, true);
        wp.target.x =
            c.read_double(s, mrpt::format("wp%03u_target_x", i), 0, true);
        wp.target.y =
            c.read_double(s, mrpt::format("wp%03u_target_y", i), 0, true);
        wp.target_frame_id = c.read_string(
            s, mrpt::format("wp%03u_target_frame_id", i), "map", false);
        double hd = c.read_double(
            s, mrpt::format("wp%03u_target_heading", i),
            mrpt::nav::TWaypoint::INVALID_NUM);
        wp.target_heading = (hd > 100) ? mrpt::nav::TWaypoint::INVALID_NUM : hd;
    }
}