INavigation2D.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2006-2021 Istituto Italiano di Tecnologia (IIT)
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef YARP_DEV_INAVIGATION2D_H
#define YARP_DEV_INAVIGATION2D_H
 
#include <yarp/os/Vocab.h>
#include <yarp/dev/api.h>
#include <yarp/dev/IMap2D.h>
#include <yarp/dev/ILocalization2D.h>
#include <yarp/dev/Map2DLocation.h>
#include <yarp/dev/Map2DPath.h>
#include <yarp/dev/Map2DArea.h>
#include <yarp/dev/MapGrid2D.h>
#include <vector>
#include <limits>
#include <string>
 
namespace yarp::dev::Nav2D {
class INavigation2DVelocityActions;
class INavigation2DTargetActions;
class INavigation2DControlActions;
class INavigation2DExtraActions;
class INavigation2D;
 
enum NavigationStatusEnum
{
    navigation_status_idle = yarp::os::createVocab32('i', 'd', 'l', 'e'),
    navigation_status_preparing_before_move = yarp::os::createVocab32('p', 'r', 'e', 'p'),
    navigation_status_moving = yarp::os::createVocab32('m', 'o', 'v', 'g'),
    navigation_status_waiting_obstacle = yarp::os::createVocab32('w', 'a', 'i', 't'),
    navigation_status_goal_reached = yarp::os::createVocab32('r', 'e', 'c', 'h'),
    navigation_status_aborted = yarp::os::createVocab32('a', 'b', 'r', 't'),
    navigation_status_failing = yarp::os::createVocab32('f', 'a', 'i', 'l'),
    navigation_status_paused = yarp::os::createVocab32('p', 'a', 'u', 's'),
    navigation_status_thinking = yarp::os::createVocab32('t', 'h', 'n', 'k'),
    navigation_status_error = yarp::os::createVocab32('e', 'r', 'r')
};
 
enum NavigationMapTypeEnum
{
    global_map = yarp::os::createVocab32('g', 'l', 'o', 'b'),
    local_map = yarp::os::createVocab32('l', 'o', 'c', 'a')
};
 
enum TrajectoryTypeEnum
{
    global_trajectory = yarp::os::createVocab32('g', 'l', 'o', 'b'),
    local_trajectory = yarp::os::createVocab32('l', 'o', 'c', 'a')
};
 
namespace INavigation2DHelpers
{
    //converts a string to a NavigationStatusEnum.
    //navigation_status_error is returned if the string is not recognized.
    YARP_dev_API NavigationStatusEnum stringToStatus(std::string s);
 
    //converts a NavigationStatusEnum to a string.
    YARP_dev_API std::string statusToString(NavigationStatusEnum status);
} // namespace INavigation2DHelpers
} // namespace yarp::dev::Nav2D
 
class YARP_dev_API yarp::dev::Nav2D::INavigation2DVelocityActions
{
public:
    virtual ~INavigation2DVelocityActions() {}
 
    virtual bool applyVelocityCommand(double x_vel, double y_vel, double theta_vel, double timeout = 0.1) = 0;
 
    virtual bool getLastVelocityCommand(double& x_vel, double& y_vel, double& theta_vel) = 0;
};
 
class YARP_dev_API yarp::dev::Nav2D::INavigation2DTargetActions
{
public:
    virtual ~INavigation2DTargetActions() {}
 
    virtual bool gotoTargetByAbsoluteLocation(yarp::dev::Nav2D::Map2DLocation loc) = 0;
 
    virtual bool getAbsoluteLocationOfCurrentTarget(yarp::dev::Nav2D::Map2DLocation& loc) = 0;
 
    virtual bool gotoTargetByRelativeLocation(double x, double y) = 0;
 
    virtual bool gotoTargetByRelativeLocation(double x, double y, double theta) = 0;
 
    virtual bool getRelativeLocationOfCurrentTarget(double& x, double& y, double& theta) = 0;
};
 
class YARP_dev_API yarp::dev::Nav2D::INavigation2DControlActions
{
public:
    virtual ~INavigation2DControlActions() {}
 
    virtual bool getNavigationStatus(NavigationStatusEnum& status) = 0;
 
    virtual bool stopNavigation() = 0;
 
    virtual bool suspendNavigation(const double time_s= std::numeric_limits<double>::infinity()) = 0;
 
    virtual bool resumeNavigation() = 0;
 
    virtual bool recomputeCurrentNavigationPath() = 0;
 
    virtual bool getAllNavigationWaypoints(yarp::dev::Nav2D::TrajectoryTypeEnum trajectory_type, yarp::dev::Nav2D::Map2DPath& waypoints) = 0;
 
    virtual bool getCurrentNavigationWaypoint(yarp::dev::Nav2D::Map2DLocation& curr_waypoint) = 0;
 
    virtual bool getCurrentNavigationMap(yarp::dev::Nav2D::NavigationMapTypeEnum map_type, yarp::dev::Nav2D::MapGrid2D& map) = 0;
};
 
class YARP_dev_API yarp::dev::Nav2D::INavigation2DExtraActions
{
public:
    virtual bool gotoTargetByLocationName(std::string location_or_area_name) = 0;
 
    virtual bool checkInsideArea(std::string area_name) = 0;
 
    virtual bool checkInsideArea(Nav2D::Map2DArea area) = 0;
 
    virtual bool checkNearToLocation(Nav2D::Map2DLocation loc, double linear_tolerance, double angular_tolerance = std::numeric_limits<double>::infinity()) = 0;
 
    virtual bool checkNearToLocation(std::string location_name, double linear_tolerance, double angular_tolerance = std::numeric_limits<double>::infinity()) = 0;
 
    virtual bool getNameOfCurrentTarget(std::string& location_name) = 0;
 
    virtual bool storeCurrentPosition(std::string location_name) = 0;
 
    virtual ~INavigation2DExtraActions() {}
};
 
class YARP_dev_API yarp::dev::Nav2D::INavigation2D :  public yarp::dev::Nav2D::INavigation2DTargetActions,
                                                      public yarp::dev::Nav2D::INavigation2DControlActions,
                                                      public yarp::dev::Nav2D::INavigation2DVelocityActions,
                                                      public yarp::dev::Nav2D::INavigation2DExtraActions,
                                                      public yarp::dev::Nav2D::IMap2D,
                                                      public yarp::dev::Nav2D::ILocalization2D
{
public:
    virtual ~INavigation2D() {}
};
 
constexpr yarp::conf::vocab32_t VOCAB_NAV_STOP                     = yarp::os::createVocab32('s', 't', 'o', 'p');
constexpr yarp::conf::vocab32_t VOCAB_NAV_SUSPEND                  = yarp::os::createVocab32('s', 'u', 's', 'p');
constexpr yarp::conf::vocab32_t VOCAB_NAV_RESUME                   = yarp::os::createVocab32('r', 'e', 's', 'm');
constexpr yarp::conf::vocab32_t VOCAB_NAV_GET_NAVIGATION_WAYPOINTS = yarp::os::createVocab32('w', 'a', 'y', 's');
constexpr yarp::conf::vocab32_t VOCAB_NAV_GET_CURRENT_WAYPOINT     = yarp::os::createVocab32('w', 'a', 'y');
constexpr yarp::conf::vocab32_t VOCAB_NAV_GET_NAV_MAP              = yarp::os::createVocab32('n', 'm', 'a', 'p');
 
#endif // YARP_DEV_INAVIGATION2D_H