uturn_task_planner.H

Go to the documentation of this file.

// Copyright (C) 2006 University of Louisiana at Lafayette
// Authors: Suresh Golconda, Pablo Mejia
// uturn_task_planner.H: Generates path to make U-turn. If lane width is narro
// than it might perform 3 point turn.

#ifndef CAJUN_UTURN_TASK_PLANNER_H
#define CAJUN_UTURN_TASK_PLANNER_H


#include "task_planner.H"
#include "uc_planner_param.H"
#include "planner_defs.H"

#define MAX_ACCESS_PHASE        3

namespace cajun
{


class uturn_task_planner_t : public task_planner_t
{
public:
        uturn_task_planner_t ();

        void set_plan (unsigned sid_, unsigned start_lid_,
                       unsigned end_lid_);
        void get_plan (unsigned &sid_, unsigned &start_lid_,
                       unsigned &end_lid_);
        void set_active ();
        path_status_t generate_path (
                world_state_t *ws_, path_t &path_, double &p_len_left_,
                const path_t &base_path_);
        bool get_path_lane_lids (unsigned &sid_,
                                 std::vector<unsigned> &lids_);
        bool is_task_complete (world_state_t *ws_, double x_, double y_,
                               double heading_);
        bool is_path_tight () { return true; }
        void print_plan ();

protected:
        const uc_planner_param_t *m_uc_param;

        unsigned m_sid;
        unsigned m_start_lid;
        unsigned m_end_lid;
        bool m_active_generate;


        // Points where the turn starts
        double m_before_turn_x;
        double m_before_turn_y;

        // Point where the turn should terminate
        double m_after_turn_x;
        double m_after_turn_y;

        // Orientation of bot/path when the turn starts
        double m_start_orient;

        // 0- first leg, 1- second leg, 2- third leg, 3- done
        unsigned m_turn_phase;
        unsigned m_last_turn_phase; // Include this

        unsigned m_pre_path_copy;
        unsigned m_pre_path_index; // num points before which to consider end
                                   // of path

        double m_turn_radius [MAX_ACCESS_PHASE]; // turn radiuse in meters
        double m_extend_path_length [MAX_ACCESS_PHASE]; // dist by which path should be extended
                                     // for reverse turn
        double m_turn_angle [MAX_ACCESS_PHASE]; //Amount of turn

        double m_speed_limit_reverse; // speed limit for forward path
        double m_speed_limit_forward; // speed limit for reverse path

        double m_interp_dis; // distance between uturn path's points

        path_t m_pre_path; // Path before turn

        void print_task_completion ();
        path_status_t add_3_point_turn (
                path_t &path_, double &p_len_left_, unsigned sid_,
                unsigned start_lid_, unsigned end_lid_, double min_speed_,
                double max_speed_);
        void limit_turn_speed_limits (path_t &path_, double min_speed_,
                                    double max_speed_);
        void set_speed_limits (path_t &path_, double min_speed_,
                               double max_speed_);
        void turn_path (path_t &path_, double sx_, double sy_,
                        double p_orient_, double del_angle,
                        double t_rad, relative_side_t turn,
                        double min_speed_, double max_speed_);
        bool record_conditions (world_state_t *ws_, path_t &path_);
        bool copy_path_after_point (double ref_x, double ref_y,
                                    path_t &des_path_,
                                    const path_t &src_path_);
};


};


#endif

---