INavigation2D.h

Go to the documentation of this file.

/*
 * Copyright (C) 2006-2020 Istituto Italiano di Tecnologia (IIT)
 * All rights reserved.
 *
 * This software may be modified and distributed under the terms of the
 * BSD-3-Clause license. See the accompanying LICENSE file for details.
 */
 
#ifndef YARP_DEV_INAVIGATION2D_H
#define YARP_DEV_INAVIGATION2D_H
 
#include <yarp/os/Vocab.h>
#include <yarp/dev/api.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 {
    namespace dev {
        namespace Nav2D
        {
            class INavigation2DTargetActions;
            class INavigation2DControlActions;
            class INavigation2D;
 
            enum NavigationStatusEnum
            {
                navigation_status_idle                  = yarp::os::createVocab('i', 'd', 'l', 'e'),
                navigation_status_preparing_before_move = yarp::os::createVocab('p', 'r', 'e', 'p'),
                navigation_status_moving                = yarp::os::createVocab('m', 'o', 'v', 'g'),
                navigation_status_waiting_obstacle      = yarp::os::createVocab('w', 'a', 'i', 't'),
                navigation_status_goal_reached          = yarp::os::createVocab('r', 'e', 'c', 'h'),
                navigation_status_aborted               = yarp::os::createVocab('a', 'b', 'r', 't'),
                navigation_status_failing               = yarp::os::createVocab('f', 'a', 'i', 'l'),
                navigation_status_paused                = yarp::os::createVocab('p', 'a', 'u', 's'),
                navigation_status_thinking              = yarp::os::createVocab('t', 'h', 'n', 'k'),
                navigation_status_error                 = yarp::os::createVocab('e', 'r', 'r')
            };
 
            enum NavigationMapTypeEnum
            {
                global_map                              = yarp::os::createVocab('g', 'l', 'o', 'b'),
                local_map                               = yarp::os::createVocab('l', 'o', 'c', 'a')
            };
 
            enum TrajectoryTypeEnum
            {
                global_trajectory = yarp::os::createVocab('g', 'l', 'o', 'b'),
                local_trajectory = yarp::os::createVocab('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);
            }
        }
    }
}
 
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;
 
    virtual bool applyVelocityCommand(double x_vel, double y_vel, double theta_vel, double timeout = 0.1) = 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::INavigation2D :  public yarp::dev::Nav2D::INavigation2DTargetActions,
                                                      public yarp::dev::Nav2D::INavigation2DControlActions,
                                                      public yarp::dev::Nav2D::ILocalization2D
{
public:
    virtual ~INavigation2D() {}
 
    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 bool storeLocation(std::string location_name, Nav2D::Map2DLocation loc) = 0;
 
    virtual bool getLocation(std::string location_name, Nav2D::Map2DLocation& loc) = 0;
 
 
    virtual bool getArea(std::string area_name, Nav2D::Map2DArea& area) = 0;
 
    virtual bool getLocationsList(std::vector<std::string>& locations) = 0;
 
    virtual bool deleteLocation(std::string location_name) = 0;
 
    virtual bool clearAllLocations() = 0;
};
 
constexpr yarp::conf::vocab32_t VOCAB_NAV_STOP                     = yarp::os::createVocab('s', 't', 'o', 'p');
constexpr yarp::conf::vocab32_t VOCAB_NAV_SUSPEND                  = yarp::os::createVocab('s', 'u', 's', 'p');
constexpr yarp::conf::vocab32_t VOCAB_NAV_RESUME                   = yarp::os::createVocab('r', 'e', 's', 'm');
constexpr yarp::conf::vocab32_t VOCAB_NAV_GET_NAVIGATION_WAYPOINTS = yarp::os::createVocab('w', 'a', 'y', 's');
constexpr yarp::conf::vocab32_t VOCAB_NAV_GET_CURRENT_WAYPOINT     = yarp::os::createVocab('w', 'a', 'y');
constexpr yarp::conf::vocab32_t VOCAB_NAV_GET_NAV_MAP              = yarp::os::createVocab('n', 'm', 'a', 'p');
 
#endif // YARP_DEV_INAVIGATION2D_H