uc_planner_param.H

Go to the documentation of this file.

#ifndef CAJUN_UC_PLANNER_PARAM_H
#define  CAJUN_UC_PLANNER_PARAM_H

//#include "stdlib.h"
#include "planner_defs.H"
#include <vector>


namespace cajun
{

class uc_planner_param_t
{
public:
        static const uc_planner_param_t* get_uc_planner_param ();

        // ##############      Graph search related      #################
        // Penalty for changing lane (in seconds)
        double m_change_lane_penalty;
        double m_uturn_penalty;
        double m_intersection_turning_penalty; // in seconds
        double m_stop_sign_penalty; // in seconds
        double m_zone_penalty;
        double m_parking_penalty;
        double m_unparking_penalty;

        // Min distance between nodes on different lanes to be connected in
        // graph
        double m_min_distance_between_CL_graph_node;

        // ##############      state machine related      #################
        double m_confirm_blk_min_time;

        // ##############      IT related      #################

        // If true then always wait at intersection (config parameter)
        bool m_always_wait;

        // Minimum wait time (seconds) at intersection
        double m_min_intersection_wait;

        // Min waiting after getting intersection precedence (seconds)
        double m_wait_after_inter_precedence;

        // Min wait time after intersection path is unblocked
        double m_wait_after_unblocked_inter_path;

        // Min speed through intersectoin (m/s)
        double m_min_intersection_speed;

        // Max speed through intersectoin (m/s)
        double m_max_intersection_speed;

        // Distance to maintain while queuing at intersection
        double m_intersection_queuing_distance;

        double m_small_dis_from_blk_at_intersection;


        // ##############      CL related      #################
        // Max xtrack between lanes for them to be in same direction
        double m_same_lane_max_xtrack; //meters

        // Extra distance to drive on original lane after neighboring shorter
        // lane starts.
        double m_lane_clippage_extra_drive_dis;


        // Speed limit while changing lane
        double m_change_lane_min_speed;
        double m_change_lane_max_speed;

        // Ratio between look ahead and xtrack dis while picking a point on
        // new lane at certain distance
        double m_look_ahead_ratio;

        // Distance before lance change
        double dis_before_LC;
        double m_safe_cl_dis_on_org_lane;
        double m_safe_cl_ahead_dis_on_new_lane;
        double m_safe_cl_behind_dis_on_new_lane;

        // ##############      UT related      #################

        // Minimum turn between lanes of same segment which are in opposite
        // direction to try using uturn.
        double m_min_orient_diff_for_uturn;

        double m_time_for_uturn;
        double m_uturn_reverse_speed_limit;
        double m_uturn_forward_speed_limit;
        double m_uturn_path_interp_dist;
        double m_uturn_forward_path_copy_dist;
        double m_uturn_reverse_path_copy_dist;
        double m_uturn_reverse_path_pre_dist;
        double m_uturn_forward_path_pre_dist;

        double m_uturn_front_radius;
        double m_uturn_reverse_radius;

        double m_uturn_extended_front_path_length;
        double m_uturn_extended_reverse_path_length;

        double m_uturn_front_turn_angle;
        double m_uturn_reverse_turn_angle;

        double m_uturn_safe_dis_before_start_point;
        double m_uturn_safe_dis_after_start_point;


        // ##############      PL related      #################
        double m_passing_lane_confirm_timeout;
        double m_passing_lane_wait_time;
        // Expected distance to pass a lane
        double m_dis_to_pass_lane;
        // Radius of un-parking curvature
        double m_unparking_rad;

        bool  m_dynamic_passing_lane_mode;


        // #############      Parking/Unparking related  #######
        double m_parking_interp_dist;
        double m_parking_path_width;
        double m_parking_min_speed;
        double m_parking_max_speed;
        double m_parking_wp_radius;
        double m_dis_after_blk;

        double m_unpark_extra_initial_straight_leg;


        // ##############      Traffic       ######################
        // Whether to check moving traffic when crossing traffic
        bool m_check_intersection_crossing_traffic;

         //Seconds of gap for crossing traffic
        double m_crossing_traffic_window;

        // Min distance from intersection within which bot should stop if found
        // a approaching traffic
        double m_inter_dis_for_stopping;

        // whether to check for traffic before changing lane
        bool m_check_CL_traffic;

        // Seconds of gap fro changing lane (onto lane in same direction)
        double m_CL_traffic_window;

        // whether to check for traffic before uturn
        bool m_check_UT_traffic;

        // Seconds of gap for uturn to be free of traffic
        double m_UT_traffic_window;

        // whether to check for traffic for passing lane
        bool m_check_PL_traffic;

        // Seconds of gap for uturn to be free of traffic
        double m_PL_traffic_window;

        // Vehicle length used for computing convoy distance and other places
        double m_vehicle_length;

        // Extra convoy distance can be specified here if speed based convoy
        // distance looks very close
        double m_convoy_extra_dis;

        unsigned m_num_tps_check_for_traffic;

        bool m_treat_dynamic_as_static;


        // ##############      ZONE      #################
        double m_grid_cell_size;

        // 0- basic, 1- 3 * 3 update, 2- 5 * 5 update
        unsigned m_grid_neighbor_mode;

        unsigned m_grid_path_extraction_type;

        // Speed limits for zone path
        double m_zone_min_speed;
        double m_zone_max_speed;

        // Goal marking: radius for circular marking, should be atleast twice
        // of cell size
        double m_basic_PE_goal_radius;
        double m_curved_PE_goal_radius;

        // Goal marking: length
        double m_grid_goal_length;

        // Goal marking: width
        double m_grid_goal_width;

        // Distance by which to jump to find a starting point which does not
        // fall on grid boundary cell
        double m_grid_non_blocking_start_find_step;

        double m_obstacle_hard_expansion_radius;

        double m_obstacle_soft_expansion_radius;

        double m_obstacle_soft_expansion_min_value;

        double m_obstacle_soft_expansion_max_value;

        // grid markings
        // parking spot marking
        double m_parking_spot_grid_cost;

        double m_bot_box_within;

        double m_grid_entry_unblock_box_len;

        // Use placing box around the path to make sure the path is free Fixme:
        // if disabled this feature need to increase the obstacle's hard and
        // soft expansion higher
        bool m_check_safety_region_around_box;

        bool m_mark_grid_around_all_parking_spot;

        // Length of the path to cut off before entering parking spot so that
        // parking task planner can take control from that
        double m_dis_from_parking_spot_for_PK_TP;

        //----------- curved path extraction related ---------
        double m_vehicle_turn_radius;

        // Distance (meters) between step points
        double m_curved_path_step_size;

        // Number of steps to explore for curved path extraction in each
        // direction (left/right)
        unsigned m_curved_path_num_one_side_steps;

        // Max depth to which to search for curved path
        unsigned m_curved_path_max_search_depth;

        double m_min_cost_to_consider_reached_goal;

        // ##############      Rest      #################
        double m_min_dis_from_blk;

        double m_min_dis_from_uturn_blk;

        double m_LF_safety_blk_distance;

        // Lane width multiplier to compute allowed xtrack distance to reach a
        // wp and to be next to a lane
        double m_width_multiplier;

        // max xtrack distance from a path (previous) to be on it
        double m_off_path_distance;

        // atrack distance before path (previous) to consider to be on it
//      double m_dis_before_path;

        // atrack distance after path (previous) to consider to be on it
//      double m_dis_after_path;

        // Max orientation diff between lanes for being to be in same direction
        double m_same_lane_max_orient_diff; // radians

        // Max distance till which to generate path
        double m_max_path_length;

        // Signal a turn signal if any turn within this distance
        double m_signal_lookahead_dis;

        //Min angle (radians) in radians to consider and turn as a formal
        //turning
        double m_min_angle_for_turn;

        // Path width to use when in situation where no rndf lane width is
        // relavent, like when switching lanes, free zones,etc.
        double m_path_width;

        bool m_print_plan;
        bool m_verbose_printing;

        double m_suggested_acceleration; // for convoy speed suggestion


        bool m_change_lane_allowed;
        bool m_passing_lane_allowed;
        bool m_uturn_allowed;

        // Default min and max speeds of base path
        double m_base_path_default_min_speed;
        double m_base_path_default_max_speed;




        // ---------- Safety Regions --------------
        //safety distance from intersection WITH stop sign
        double m_before_stop_intersection_safety_dis;

        //safety distance from intersection WITHOUT stop sign
        double m_before_intersection_safety_dis;
        double m_after_intersection_safety_dis;


        double m_blocked_lane_timeout;
        double m_blocked_zone_timeout;
        double m_max_stop_speed;

        // Radius around the bot looking for info
        double m_bubble_rad;

        // Amount of distance bot can go out of lane for doing uturn (along the
        // lane)
        double m_uturn_dis_outside_lane;

        // ------------   Sensor fusion config file parameters -------
        double m_path_interpolation_distance;

        double m_allowed_pre_lane_dis;
        double m_allowed_post_lane_dis;

        // -------------------------------------------
        bool m_use_parking_task_planner;


        // distance before chute point that bot can be
        double m_start_dis_before_start_chute;

        double m_extra_dis_between_lanes_for_passing;

        // Min atrack distance before which a waypoint is considered to be reached
        double m_min_atrack_for_wp_reach;

        // Use radar data for intersection
        bool m_use_radar_data_for_intersection;

        // Min speed of objects through radar that needs to can be trusted
        double m_radar_min_vehicle_speed;

        // How many after radar stop seeing should system still use it
        double m_radar_object_time_out;

        std::vector<radar_info_t> m_left_radars;
        std::vector<radar_info_t> m_right_radars;

        bool m_nudge_path;
        unsigned m_nudge_path_scan_qid;
private:
        uc_planner_param_t ()
        { };

        bool load_param ();
//      static uc_planner_param_t *m_parameters;

};
};



#endif

---