task_planner.H

Go to the documentation of this file.

// Copyright (C) 2006 University of Louisiana at Lafayette
// Authors: Suresh Golconda, Pablo Mejia

// 'task_planner_t' is the abstract class for defining all task planners

#ifndef CAJUN_TASK_PLANNER_H
#define CAJUN_TASK_PLANNER_H

#include "data_type.H"
#include "rndf.H"
#include "world_state.H"

#include "planner_defs.H"

#include <deque>


namespace cajun
{
class mdf_t;

class task_planner_t
{
public:
        virtual ~task_planner_t () {}
        virtual void set_active () = 0;

        virtual path_status_t generate_path (
                world_state_t *ws_, path_t &path_, double &p_len_left_,
                const path_t &base_path_) = 0;

        const path_t* get_path () {return &m_path;}

        path_direction_t path_direction () { return m_path_dir;}

        path_status_t path_status () { return m_status;}
//      bool forward_path () { return m_forward_path;}

        virtual void set_path_blocked (unsigned p_id_);

        void limit_path_speed (unsigned p_id_, double speed_);
        void limit_following_path_speed (unsigned p_id_, double speed_);

        bool is_active () { return m_active; }

        virtual bool get_path_lane_lids (unsigned &sid_,
                                        std::vector<unsigned> &lids_)
                {return false;}

        struct path_lane_map_t
        {
                double start_x;
                double start_y;

                double end_x;
                double end_y;

                unsigned seg_id;
                unsigned lane_id;
        };

        std::vector<path_lane_map_t> m_path_lane_map;

        virtual bool get_path_map_to_lane_lids (
                std::vector<path_lane_map_t> &pl_ids_)
                {return false;}

        virtual bool get_start_lid (unsigned &sid_, unsigned &lid_)
                { return false; }

        path_turn_info_t get_path_turn_info ()
                { return m_turn; }

        virtual bool is_task_complete (world_state_t *ws_, double x_,
                                       double y_, double heading_) = 0;

        virtual void print_plan () = 0;

        void init (mdf_t const *mdf_, rndf_t const *rndf_);

        bool reset_base_path () { return m_reset_base_path; }

        TP_type_t type () { return m_type; }
        // Return true if path generated is classified as tight path.
        // Here is default implementation.
        // TP will override this function if required
        virtual bool is_path_tight () { return false; }
        virtual bool is_quick_acceleration_path () { return false; }

        void print_path_map ();


protected:
        mdf_t const *m_mdf; // Mission structure of speed limits of each lane
        rndf_t const *m_rndf; // city lane information
        path_t m_path; // Path planned, also contains one base point
        bool m_planned_path; // true if planned a path and m_path
        path_status_t m_status;// Stutus of the path planned


        TP_type_t m_type; // Type of task planner
        bool m_active; // true if task planer is 1st task planner
        bool m_complete; // true if task planner completed its task
        bool m_reset_base_path; // reset the base path's points
//      bool m_forward_path; // true if path is forward direction

        path_direction_t m_path_dir; // direction of the path

        //Stores if a turn in its path
        path_turn_info_t m_turn;

        void update_local_path (const path_t &path_, const path_t &b_path_);

};


typedef std::deque<task_planner_t *> tp_plan_t;

};


#endif

---