Typing and modernisation of Agent code

CHANGELOG.md

@@ -20,6 +20,7 @@
  * Added V2X sensors for cooperative awareness message and custom user-defined messages to support vehicle-to-vehicle communication
  * Added named tuples for BasicAgent.py's detection result to allow for type-hints and better semantics.
  * Added type-hint support for the PythonAPI
+ * Added type-hints to GlobalRoutePlanner and use carla.Vector3D code instead of pre 0.9.13 numpy code.
 
 
 ## CARLA 0.9.15

PythonAPI/carla/agents/navigation/basic_agent.py

@@ -6,7 +6,7 @@
 """
 This module implements an agent that roams around a track following random
 waypoints and avoiding other vehicles. The agent also responds to traffic lights.
-It can also make use of the global route planner to follow a specifed route
+It can also make use of the global route planner to follow a specified route
 """
 
 import carla
@@ -15,13 +15,12 @@
 from agents.navigation.local_planner import LocalPlanner, RoadOption
 from agents.navigation.global_route_planner import GlobalRoutePlanner
 from agents.tools.misc import (get_speed, is_within_distance,
-                               get_trafficlight_trigger_location,
-                               compute_distance)
+                               get_trafficlight_trigger_location)
 
 from agents.tools.hints import ObstacleDetectionResult, TrafficLightDetectionResult
 
 
-class BasicAgent(object):
+class BasicAgent:
     """
     BasicAgent implements an agent that navigates the scene.
     This agent respects traffic lights and other vehicles, but ignores stop signs.
@@ -31,7 +30,7 @@ class BasicAgent(object):
 
     def __init__(self, vehicle, target_speed=20, opt_dict={}, map_inst=None, grp_inst=None):
         """
-        Initialization the agent paramters, the local and the global planner.
+        Initialization the agent parameters, the local and the global planner.
 
             :param vehicle: actor to apply to agent logic onto
             :param target_speed: speed (in Km/h) at which the vehicle will move
@@ -102,7 +101,7 @@ def __init__(self, vehicle, target_speed=20, opt_dict={}, map_inst=None, grp_ins
 
         # Get the static elements of the scene
         self._lights_list = self._world.get_actors().filter("*traffic_light*")
-        self._lights_map = {}  # Dictionary mapping a traffic light to a wp corrspoing to its trigger volume location
+        self._lights_map = {}  # Dictionary mapping a traffic light to a wp corresponding to its trigger volume location
 
     def add_emergency_stop(self, control):
         """
@@ -139,14 +138,14 @@ def get_local_planner(self):
     def get_global_planner(self):
         """Get method for protected member local planner"""
         return self._global_planner
-        
+
     def set_destination(self, end_location, start_location=None, clean_queue=True):
         # type: (carla.Location, carla.Location | None, bool) -> None
         """
         This method creates a list of waypoints between a starting and ending location,
         based on the route returned by the global router, and adds it to the local planner.
-        If no starting location is passed and `clean_queue` is True, the vehicle local planner's 
-        target location is chosen, which corresponds (by default), to a location about 5 meters 
+        If no starting location is passed and `clean_queue` is True, the vehicle local planner's
+        target location is chosen, which corresponds (by default), to a location about 5 meters
         in front of the vehicle.
         If `clean_queue` is False the newly planned route will be appended to the current route.
 
@@ -157,19 +156,19 @@ def set_destination(self, end_location, start_location=None, clean_queue=True):
         if not start_location:
             if clean_queue and self._local_planner.target_waypoint:
                 # Plan from the waypoint in front of the vehicle onwards
-                start_location = self._local_planner.target_waypoint.transform.location 
+                start_location = self._local_planner.target_waypoint.transform.location
             elif not clean_queue and self._local_planner._waypoints_queue:
                 # Append to the current plan
                 start_location = self._local_planner._waypoints_queue[-1][0].transform.location
             else:
                 # no target_waypoint or _waypoints_queue empty, use vehicle location
-                start_location = self._vehicle.get_location() 
+                start_location = self._vehicle.get_location()
         start_waypoint = self._map.get_waypoint(start_location)
         end_waypoint = self._map.get_waypoint(end_location)
-        
+
         route_trace = self.trace_route(start_waypoint, end_waypoint)
         self._local_planner.set_global_plan(route_trace, clean_queue=clean_queue)
-        
+
     def set_global_plan(self, plan, stop_waypoint_creation=True, clean_queue=True):
         """
         Adds a specific plan to the agent.
@@ -325,7 +324,7 @@ def _vehicle_obstacle_detected(self, vehicle_list=None, max_distance=None, up_an
         """
         Method to check if there is a vehicle in front of the agent blocking its path.
 
-            :param vehicle_list (list of carla.Vehicle): list contatining vehicle objects.
+            :param vehicle_list (list of carla.Vehicle): list containing vehicle objects.
                 If None, all vehicle in the scene are used
             :param max_distance: max freespace to check for obstacles.
                 If None, the base threshold value is used
@@ -354,7 +353,7 @@ def get_route_polygon():
                 return None
 
             return Polygon(route_bb)
-      
+
         if self._ignore_vehicles:
             return ObstacleDetectionResult(False, None, -1)
 
@@ -404,7 +403,7 @@ def get_route_polygon():
                 target_polygon = Polygon(target_list)
 
                 if route_polygon.intersects(target_polygon):
-                    return ObstacleDetectionResult(True, target_vehicle, compute_distance(target_vehicle.get_location(), ego_location))
+                    return ObstacleDetectionResult(True, target_vehicle, target_vehicle.get_location().distance(ego_location))
 
             # Simplified approach, using only the plan waypoints (similar to TM)
             else:
@@ -425,13 +424,15 @@ def get_route_polygon():
                 )
 
                 if is_within_distance(target_rear_transform, ego_front_transform, max_distance, [low_angle_th, up_angle_th]):
-                    return ObstacleDetectionResult(True, target_vehicle, compute_distance(target_transform.location, ego_transform.location))
+                    return ObstacleDetectionResult(True, target_vehicle, target_transform.location.distance(ego_transform.location))
 
         return ObstacleDetectionResult(False, None, -1)
 
-    def _generate_lane_change_path(self, waypoint, direction='left', distance_same_lane=10,
+    @staticmethod
+    def _generate_lane_change_path(waypoint, direction='left', distance_same_lane=10,
                                 distance_other_lane=25, lane_change_distance=25,
                                 check=True, lane_changes=1, step_distance=2):
+        # type: (carla.Waypoint, str, float, float, float, bool, int, float) -> list[tuple[carla.Waypoint, RoadOption]]
         """
         This methods generates a path that results in a lane change.
         Use the different distances to fine-tune the maneuver.

PythonAPI/carla/agents/navigation/behavior_agent.py

@@ -8,14 +8,13 @@
 waypoints and avoiding other vehicles. The agent also responds to traffic lights,
 traffic signs, and has different possible configurations. """
 
-import random
 import numpy as np
 import carla
 from agents.navigation.basic_agent import BasicAgent
 from agents.navigation.local_planner import RoadOption
 from agents.navigation.behavior_types import Cautious, Aggressive, Normal
 
-from agents.tools.misc import get_speed, positive, is_within_distance, compute_distance
+from agents.tools.misc import get_speed, positive
 
 class BehaviorAgent(BasicAgent):
     """

PythonAPI/carla/agents/navigation/behavior_types.py

@@ -4,7 +4,7 @@
 """ This module contains the different parameters sets for each behavior. """
 
 
-class Cautious(object):
+class Cautious:
     """Class for Cautious agent."""
     max_speed = 40
     speed_lim_dist = 6
@@ -15,7 +15,7 @@ class Cautious(object):
     tailgate_counter = 0
 
 
-class Normal(object):
+class Normal:
     """Class for Normal agent."""
     max_speed = 50
     speed_lim_dist = 3
@@ -26,7 +26,7 @@ class Normal(object):
     tailgate_counter = 0
 
 
-class Aggressive(object):
+class Aggressive:
     """Class for Aggressive agent."""
     max_speed = 70
     speed_lim_dist = 1

PythonAPI/carla/agents/navigation/constant_velocity_agent.py

@@ -6,7 +6,7 @@
 """
 This module implements an agent that roams around a track following random
 waypoints and avoiding other vehicles. The agent also responds to traffic lights.
-It can also make use of the global route planner to follow a specifed route
+It can also make use of the global route planner to follow a specified route
 """
 
 import carla

PythonAPI/carla/agents/navigation/controller.py

@@ -12,7 +12,7 @@
 from agents.tools.misc import get_speed
 
 
-class VehiclePIDController():
+class VehiclePIDController:
     """
     VehiclePIDController is the combination of two PID controllers
     (lateral and longitudinal) to perform the
@@ -105,7 +105,7 @@ def set_offset(self, offset):
         self._lat_controller.set_offset(offset)
 
 
-class PIDLongitudinalController():
+class PIDLongitudinalController:
     """
     PIDLongitudinalController implements longitudinal control using a PID.
     """
@@ -171,7 +171,7 @@ def change_parameters(self, K_P, K_I, K_D, dt):
         self._dt = dt
 
 
-class PIDLateralController():
+class PIDLateralController:
     """
     PIDLateralController implements lateral control using a PID.
     """
@@ -199,7 +199,7 @@ def __init__(self, vehicle, offset=0, K_P=1.0, K_I=0.0, K_D=0.0, dt=0.03):
     def run_step(self, waypoint):
         """
         Execute one step of lateral control to steer
-        the vehicle towards a certain waypoin.
+        the vehicle towards a certain waypoint.
 
             :param waypoint: target waypoint
             :return: steering control in the range [-1, 1] where: