RobotPursuer.hpp

Go to the documentation of this file.

#ifndef LGL_ROBOT_PURSUER_HPP
#define LGL_ROBOT_PURSUER_HPP

#include <lgl/VisibilityMap.hpp>
#include <lgl/PursuitNavigator.hpp>
#include <lgl/PursuitGraph.hpp>
#include <lgl/PursuitTaskManager.hpp>
#include <lgl/CellID.hpp>

#include <string>

namespace jafar {
  namespace lgl {


    typedef enum {  
            IDLE,   // The robot has nothing to do
            BUSY,   // The robot is busy (with another mission than the pursuit one)
            SUPPORT,  // The robot is providing support for the pursuit mission
            TRACKER   // The robot is currently in charge of the target (tracking task)
      } ROBOT_STATE;

    class RobotPursuer {
    
      private :

        // ID of the robot
        int id ;

        // Parameters for the robot
        unsigned int horizon;           // temporal horizon
        unsigned int viewLength;        // viewLength
        unsigned int temporalTolerance; 
        unsigned int riskTermMaxValue; 
        double sensorsHeight;

        // State of the robot
        ROBOT_STATE state ;

        // Position of the robot
        Cell_ID position ;

        // Models for the robot
        std::string robotAccessibilityMap;
        std::string targetAccessibilityMap;
        std::string robotVisibilityMap;

        // Provide GeoData information and navigation services
        PursuitNavigator* navigator ;

        // VisibilityMap : use for visibility information
        GeoData*  geodata ;
        VisibilityMap* visibilityMap; 

        // PursuitGraph : use for the tracking task
        PursuitGraph* pursuitGraph; 

        // PursuitTaskManager : use for the support task management
        PursuitTaskManager pursuitTaskManager ;

        // PursuitSupport : use for the support task realisation
        //PursuitSupport pursuitSupport; 


      public : 

        RobotPursuer(   int _id,
                std::string _robotAccessibilityMap,
                std::string _targetAccessibilityMap,
                std::string _robotVisibilityMap,
                unsigned int _horizon = 20, // temporal horizon
                unsigned int _viewLength= 20, // viewLength
                unsigned int _temporalTolerance = 7, 
                unsigned int _riskTermMaxValue = 7, 
                double _sensorsHeight = 1,
                ROBOT_STATE _state=IDLE,
                Cell_ID _position=0 
        );
      
        RobotPursuer(   int _id,
                std::string _robotAccessibilityMap,
                std::string _targetAccessibilityMap,
                std::string _robotVisibilityMap,
                unsigned int _horizon = 20, // temporal horizon
                unsigned int _viewLength= 20, // viewLength
                unsigned int _temporalTolerance = 7, 
                unsigned int _riskTermMaxValue = 7, 
                double _sensorsHeight = 1,
                ROBOT_STATE _state=IDLE,
                int x = 0, int y = 0
        );
      
        ~RobotPursuer() ;

        /*  Actions */
        void start( int xTarget, int yTarget);

        void run( int xTarget, int yTarget);

        PursuitGraph* getPG() const;

        std::string getRobotAccessibilityMap()  const ;
        std::string getTargetAccessibilityMap() const ;
        std::string getRobotVisibilityMap()   const ;

        Cell_ID getPosition()   const ;
        void getPosition(int &x, int &y) const;
      private :
        void startTracking( int xTarget, int yTarget);

    };

  }
}

#endif /* LGL_ROBOT_PURSUER_HPP */