From 344ae0d8a3171c74cf3b224db7539cf28b398514 Mon Sep 17 00:00:00 2001 From: sowmen Date: Mon, 1 May 2023 08:43:00 +0100 Subject: [PATCH 1/2] updated parking-v0 --- highway_env/envs/common/abstract.py | 5 +- highway_env/envs/common/graphics.py | 4 +- highway_env/envs/parking_env.py | 160 +++++++++++++++++++++++----- highway_env/road/graphics.py | 24 ++++- highway_env/road/lane.py | 9 +- highway_env/vehicle/objects.py | 10 +- test.ipynb | 85 +++++++++++++++ 7 files changed, 256 insertions(+), 41 deletions(-) create mode 100644 test.ipynb diff --git a/highway_env/envs/common/abstract.py b/highway_env/envs/common/abstract.py index f60ffba52..da29bb22e 100644 --- a/highway_env/envs/common/abstract.py +++ b/highway_env/envs/common/abstract.py @@ -106,7 +106,8 @@ def default_config(cls) -> dict: "render_agent": True, "offscreen_rendering": os.environ.get("OFFSCREEN_RENDERING", "0") == "1", "manual_control": False, - "real_time_rendering": False + "real_time_rendering": False, + "center_window": True } def configure(self, config: dict) -> None: @@ -284,7 +285,7 @@ def render(self) -> Optional[np.ndarray]: self.enable_auto_render = True - self.viewer.display() + self.viewer.display(self.config["center_window"]) if not self.viewer.offscreen: self.viewer.handle_events() diff --git a/highway_env/envs/common/graphics.py b/highway_env/envs/common/graphics.py index 7c4e34570..d5e99daab 100644 --- a/highway_env/envs/common/graphics.py +++ b/highway_env/envs/common/graphics.py @@ -94,12 +94,12 @@ def handle_events(self) -> None: if self.env.action_type: EventHandler.handle_event(self.env.action_type, event) - def display(self) -> None: + def display(self, center=True) -> None: """Display the road and vehicles on a pygame window.""" if not self.enabled: return - self.sim_surface.move_display_window_to(self.window_position()) + self.sim_surface.move_display_window_to(self.window_position() if center else [0.5, 0.5]) RoadGraphics.display(self.env.road, self.sim_surface) if self.vehicle_trajectory: diff --git a/highway_env/envs/parking_env.py b/highway_env/envs/parking_env.py index 54ba79032..61c7d506a 100644 --- a/highway_env/envs/parking_env.py +++ b/highway_env/envs/parking_env.py @@ -3,6 +3,7 @@ from gymnasium import Env import numpy as np +import random from highway_env.envs.common.abstract import AbstractEnv from highway_env.envs.common.observation import MultiAgentObservation, observation_factory @@ -11,6 +12,7 @@ from highway_env.vehicle.graphics import VehicleGraphics from highway_env.vehicle.kinematics import Vehicle from highway_env.vehicle.objects import Landmark, Obstacle +from highway_env.utils import are_polygons_intersecting class GoalEnv(Env): @@ -100,7 +102,15 @@ def default_config(cls) -> dict: "scaling": 7, "controlled_vehicles": 1, "vehicles_count": 0, - "add_walls": True + "add_walls": True, + "center_window": False, + "n_rows": 2, # number of parking rows + "y_offset": 10, # y distance between parallel rows + "font_size": 22, # display font size for ids ['None' to stop render] + "spots": 14, # spots in each row + "obstacles": False, + "random_start": False, + "prevent_early_collision": False }) return config @@ -131,60 +141,152 @@ def _create_road(self, spots: int = 14) -> None: :param spots: number of spots in the parking """ + spots = self.config["spots"] net = RoadNetwork() width = 4.0 lt = (LineType.CONTINUOUS, LineType.CONTINUOUS) x_offset = 0 - y_offset = 10 + y_offset = self.config["y_offset"] length = 8 - for k in range(spots): - x = (k + 1 - spots // 2) * (width + x_offset) - width / 2 - net.add_lane("a", "b", StraightLane([x, y_offset], [x, y_offset+length], width=width, line_types=lt)) - net.add_lane("b", "c", StraightLane([x, -y_offset], [x, -y_offset-length], width=width, line_types=lt)) + + row_ys = [] + for i in range(self.config["n_rows"]): + if i == 0: + row_ys.append([y_offset, y_offset+length]) + elif i == 1: + row_ys.append([-y_offset, -y_offset-length]) + else: + if i%2 == 0: + row_ys.append([row_ys[i-2][1]+2*y_offset, row_ys[i-2][1]+2*y_offset+length]) + else: + row_ys.append([row_ys[i-2][1]-2*y_offset, row_ys[i-2][1]-2*y_offset-length]) + + id = 0 + for row in range(0, self.config["n_rows"]): + for k in range(spots): + x = (k + 1 - spots // 2) * (width + x_offset) - width / 2 + net.add_lane( + chr(ord('a')+row), chr(ord('a')+row+1), + StraightLane([x, row_ys[row][0]], [x, row_ys[row][1]], + width=width, line_types=lt, identifier=id, + display_font_size=self.config['font_size'] + ) + ) + id += 1 self.road = Road(network=net, np_random=self.np_random, record_history=self.config["show_trajectories"]) + + # Store the allowed x,y coordinate ranges to spawn the agent + allowed_y_space = [[-y_offset+8, y_offset-8]] + if len(row_ys) > 2: + for i in range(2, len(row_ys)): + if i%2 == 0: + allowed_y_space.append([row_ys[i-2][1]+8, row_ys[i][0]-8]) + else: + allowed_y_space.append([row_ys[i][0]+8, row_ys[i-2][1]-8]) + + self.allowed_vehicle_space = { + 'x' : (-30, 30), + 'y' : allowed_y_space + } + + # Walls + x_end = abs((1 - spots // 2) * (width + x_offset) - width / 2) + + if len(row_ys) > 1: + wall_y_top = row_ys[-1][1] + 4 if row_ys[-1][1] > 0 else row_ys[-1][1] - 4 + wall_y_bottom = row_ys[-2][1] + 4 if row_ys[-2][1] > 0 else row_ys[-2][1] - 4 + else: + wall_y_bottom = row_ys[-1][1] + 4 + wall_y_top = -y_offset - 4 + + wall_x = x_end + 14 + + for y in [wall_y_top, wall_y_bottom]: + obstacle = Obstacle(self.road, [0, y]) + obstacle.LENGTH, obstacle.WIDTH = (2*wall_x, 1) + obstacle.diagonal = np.sqrt(obstacle.LENGTH**2 + obstacle.WIDTH**2) + self.road.objects.append(obstacle) + + wall_y = 0 + if self.config["n_rows"] > 1 and self.config["n_rows"]%2==1: wall_y = y_offset+4 + elif self.config["n_rows"] == 1: wall_y = y_offset-6 + + for x in [-wall_x, wall_x]: + obstacle = Obstacle( + self.road, + [x, wall_y], + heading=np.pi / 2 + ) + obstacle.LENGTH, obstacle.WIDTH = (abs(wall_y_top) + abs(wall_y_bottom), 1) + obstacle.diagonal = np.sqrt(obstacle.LENGTH**2 + obstacle.WIDTH**2) + self.road.objects.append(obstacle) + + if self.config['obstacles'] and self.config["n_rows"] > 3: + self._create_obstacles() + + def _create_obstacles(self): + """Create some random obstacles""" + obstacle = Obstacle(self.road, (18, -18 - self.config['y_offset']), 90) + obstacle.LENGTH, obstacle.WIDTH = 5, 5 + obstacle.diagonal = np.sqrt(obstacle.LENGTH**2 + obstacle.WIDTH**2) + obstacle.line_color = (187, 84, 49) + self.road.objects.append(obstacle) + + obstacle = Obstacle(self.road, (-18, 18 + self.config['y_offset']), 90) + obstacle.LENGTH, obstacle.WIDTH = 5, 5 + obstacle.diagonal = np.sqrt(obstacle.LENGTH**2 + obstacle.WIDTH**2) + obstacle.line_color = (187, 84, 49) + self.road.objects.append(obstacle) def _create_vehicles(self) -> None: """Create some new random vehicles of a given type, and add them on the road.""" # Controlled vehicles self.controlled_vehicles = [] for i in range(self.config["controlled_vehicles"]): - vehicle = self.action_type.vehicle_class(self.road, [i*20, 0], 2*np.pi*self.np_random.uniform(), 0) + if self.config["random_start"]: + while(True): + x = np.random.randint(self.allowed_vehicle_space['x'][0], self.allowed_vehicle_space['x'][1]) + y_sector = np.random.choice(range(len(self.allowed_vehicle_space['y']))) + y = np.random.randint(self.allowed_vehicle_space['y'][y_sector][0], self.allowed_vehicle_space['y'][y_sector][1]) + vehicle = self.action_type.vehicle_class(self.road, [x, y], 2*np.pi*self.np_random.uniform(), 0) + + intersect = False + for o in self.road.objects: + res, _, _ = are_polygons_intersecting(vehicle.polygon(), o.polygon(), vehicle.velocity, o.velocity) + intersect |= res + if not intersect: + break + else: + vehicle = self.action_type.vehicle_class(self.road, [0, 0], 2*np.pi*self.np_random.uniform(), 0) + vehicle.color = VehicleGraphics.EGO_COLOR self.road.vehicles.append(vehicle) self.controlled_vehicles.append(vehicle) # Goal - lane = self.np_random.choice(self.road.network.lanes_list()) - self.goal = Landmark(self.road, lane.position(lane.length/2, 0), heading=lane.heading) + goal_lane = self.np_random.choice(self.road.network.lanes_list()) + self.goal = Landmark(self.road, goal_lane.position(goal_lane.length/2, 0), heading=goal_lane.heading) self.road.objects.append(self.goal) # Other vehicles - for i in range(self.config["vehicles_count"]): - lane = ("a", "b", i) if self.np_random.uniform() >= 0.5 else ("b", "c", i) + free_lanes = self.road.network.lanes_list().copy() + free_lanes.remove(goal_lane) + random.Random(4).shuffle(free_lanes) + for _ in range(self.config["vehicles_count"] - 1): + lane = free_lanes.pop() v = Vehicle.make_on_lane(self.road, lane, 4, speed=0) self.road.vehicles.append(v) - for v in self.road.vehicles: # Prevent early collisions - if v is not self.vehicle and ( - np.linalg.norm(v.position - self.goal.position) < 20 or - np.linalg.norm(v.position - self.vehicle.position) < 20): - self.road.vehicles.remove(v) - # Walls - if self.config['add_walls']: - width, height = 70, 42 - for y in [-height / 2, height / 2]: - obstacle = Obstacle(self.road, [0, y]) - obstacle.LENGTH, obstacle.WIDTH = (width, 1) - obstacle.diagonal = np.sqrt(obstacle.LENGTH**2 + obstacle.WIDTH**2) - self.road.objects.append(obstacle) - for x in [-width / 2, width / 2]: - obstacle = Obstacle(self.road, [x, 0], heading=np.pi / 2) - obstacle.LENGTH, obstacle.WIDTH = (height, 1) - obstacle.diagonal = np.sqrt(obstacle.LENGTH**2 + obstacle.WIDTH**2) - self.road.objects.append(obstacle) + if self.config["prevent_early_collision"]: + for v in self.road.vehicles: # Prevent early collisions + if v is not self.vehicle and ( + np.linalg.norm(v.position - self.goal.position) < 20 or + np.linalg.norm(v.position - self.vehicle.position) < 20): + self.road.vehicles.remove(v) + def compute_reward(self, achieved_goal: np.ndarray, desired_goal: np.ndarray, info: dict, p: float = 0.5) -> float: """ diff --git a/highway_env/road/graphics.py b/highway_env/road/graphics.py index 23dd3766c..1bd6970c7 100644 --- a/highway_env/road/graphics.py +++ b/highway_env/road/graphics.py @@ -125,14 +125,23 @@ def display(cls, lane: AbstractLane, surface: WorldSurface) -> None: stripes_count = int(2 * (surface.get_height() + surface.get_width()) / (cls.STRIPE_SPACING * surface.scaling)) s_origin, _ = lane.local_coordinates(surface.origin) s0 = (int(s_origin) // cls.STRIPE_SPACING - stripes_count // 2) * cls.STRIPE_SPACING + + last_pixel = [] # Store the pixel coordinates of the last pixel of a lane for side in range(2): if lane.line_types[side] == LineType.STRIPED: cls.striped_line(lane, surface, stripes_count, s0, side) elif lane.line_types[side] == LineType.CONTINUOUS: - cls.continuous_curve(lane, surface, stripes_count, s0, side) + last_pixel.append(cls.continuous_curve(lane, surface, stripes_count, s0, side, return_last_pixel=True)) elif lane.line_types[side] == LineType.CONTINUOUS_LINE: cls.continuous_line(lane, surface, stripes_count, s0, side) + if lane.display_font_size != None: + x = (last_pixel[0][0] + last_pixel[1][0]) // 2 - 8 + y = last_pixel[0][1] + font1 = pygame.font.SysFont('arial', lane.display_font_size) + text_surface = font1.render(str(lane.identifier), True, (0, 0, 0)) + surface.blit(text_surface, (x,y)) + @classmethod def striped_line(cls, lane: AbstractLane, surface: WorldSurface, stripes_count: int, longitudinal: float, side: int) -> None: @@ -152,7 +161,7 @@ def striped_line(cls, lane: AbstractLane, surface: WorldSurface, stripes_count: @classmethod def continuous_curve(cls, lane: AbstractLane, surface: WorldSurface, stripes_count: int, - longitudinal: float, side: int) -> None: + longitudinal: float, side: int, return_last_pixel: bool = False) -> None: """ Draw a striped line on one side of a lane, on a surface. @@ -161,11 +170,12 @@ def continuous_curve(cls, lane: AbstractLane, surface: WorldSurface, stripes_cou :param stripes_count: the number of stripes to draw :param longitudinal: the longitudinal position of the first stripe [m] :param side: which side of the road to draw [0:left, 1:right] + :param return_last_pixel: returns the last pixel coordinate of line """ starts = longitudinal + np.arange(stripes_count) * cls.STRIPE_SPACING ends = longitudinal + np.arange(stripes_count) * cls.STRIPE_SPACING + cls.STRIPE_SPACING lats = [(side - 0.5) * lane.width_at(s) for s in starts] - cls.draw_stripes(lane, surface, starts, ends, lats) + return cls.draw_stripes(lane, surface, starts, ends, lats, return_last_pixel) @classmethod def continuous_line(cls, lane: AbstractLane, surface: WorldSurface, stripes_count: int, longitudinal: float, @@ -186,7 +196,8 @@ def continuous_line(cls, lane: AbstractLane, surface: WorldSurface, stripes_coun @classmethod def draw_stripes(cls, lane: AbstractLane, surface: WorldSurface, - starts: List[float], ends: List[float], lats: List[float]) -> None: + starts: List[float], ends: List[float], lats: List[float], + return_last_pixel: bool = False) -> None: """ Draw a set of stripes along a lane. @@ -195,6 +206,7 @@ def draw_stripes(cls, lane: AbstractLane, surface: WorldSurface, :param starts: a list of starting longitudinal positions for each stripe [m] :param ends: a list of ending longitudinal positions for each stripe [m] :param lats: a list of lateral positions for each stripe [m] + :param return_last_pixel: returns the last pixel coordinate of line """ starts = np.clip(starts, 0, lane.length) ends = np.clip(ends, 0, lane.length) @@ -204,6 +216,10 @@ def draw_stripes(cls, lane: AbstractLane, surface: WorldSurface, (surface.vec2pix(lane.position(starts[k], lats[k]))), (surface.vec2pix(lane.position(ends[k], lats[k]))), max(surface.pix(cls.STRIPE_WIDTH), 1)) + last_coordinate = (surface.vec2pix(lane.position(ends[k], lats[k]))) + + if return_last_pixel: + return last_coordinate @classmethod def draw_ground(cls, lane: AbstractLane, surface: WorldSurface, color: Tuple[float], width: float, diff --git a/highway_env/road/lane.py b/highway_env/road/lane.py index 87d302d33..922278289 100644 --- a/highway_env/road/lane.py +++ b/highway_env/road/lane.py @@ -152,7 +152,9 @@ def __init__(self, line_types: Tuple[LineType, LineType] = None, forbidden: bool = False, speed_limit: float = 20, - priority: int = 0) -> None: + priority: int = 0, + identifier: int = None, + display_font_size: int = 15) -> None: """ New straight lane. @@ -162,6 +164,8 @@ def __init__(self, :param line_types: the type of lines on both sides of the lane :param forbidden: is changing to this lane forbidden :param priority: priority level of the lane, for determining who has right of way + :param identifier: sequential id assigned to each lane + :param display_font_size: priority level of the lane, for determining who has right of way """ self.start = np.array(start) self.end = np.array(end) @@ -175,6 +179,9 @@ def __init__(self, self.priority = priority self.speed_limit = speed_limit + self.identifier = identifier + self.display_font_size = display_font_size # Font size to display the lane counter + def position(self, longitudinal: float, lateral: float) -> np.ndarray: return self.start + longitudinal * self.direction + lateral * self.direction_lateral diff --git a/highway_env/vehicle/objects.py b/highway_env/vehicle/objects.py index 1eba65201..bda417a8d 100644 --- a/highway_env/vehicle/objects.py +++ b/highway_env/vehicle/objects.py @@ -1,5 +1,5 @@ from abc import ABC -from typing import Sequence, Tuple, TYPE_CHECKING, Optional +from typing import Sequence, Tuple, TYPE_CHECKING, Optional, Union import numpy as np from highway_env import utils @@ -51,8 +51,11 @@ def __init__(self, road: 'Road', position: Sequence[float], heading: float = 0, self.hit = False self.impact = np.zeros(self.position.shape) + # Option to set line color of the object manually + self.line_color = None + @classmethod - def make_on_lane(cls, road: 'Road', lane_index: LaneIndex, longitudinal: float, speed: Optional[float] = None) \ + def make_on_lane(cls, road: 'Road', lane: Union['AbstractLane', LaneIndex], longitudinal: float, speed: Optional[float] = None) \ -> 'RoadObject': """ Create a vehicle on a given lane at a longitudinal position. @@ -63,7 +66,8 @@ def make_on_lane(cls, road: 'Road', lane_index: LaneIndex, longitudinal: float, :param speed: initial speed in [m/s] :return: a RoadObject at the specified position """ - lane = road.network.get_lane(lane_index) + if type(lane) is LaneIndex: + lane = road.network.get_lane(lane) if speed is None: speed = lane.speed_limit return cls(road, lane.position(longitudinal, 0), lane.heading_at(longitudinal), speed) diff --git a/test.ipynb b/test.ipynb new file mode 100644 index 000000000..8a1f976de --- /dev/null +++ b/test.ipynb @@ -0,0 +1,85 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import gymnasium\n", + "import highway_env\n", + "highway_env.register_highway_envs()\n", + "\n", + "env = gymnasium.make(\"parking-v0\", render_mode='rgb_array')\n", + "env.configure({\n", + " \"vehicles_count\": 10, \n", + " \"duration\": 300,\n", + " \"screen_width\": 900,\n", + " \"screen_height\": 1200,\n", + " \"collision_reward\": -8,\n", + " \"custom_reward\": False,\n", + " \"n_rows\": 4,\n", + " \"y_offset\": 10, # y distance between parallel rows\n", + " \"obstacles\": True,\n", + " \"random_start\": True\n", + "})\n", + "env.reset()\n", + "\n", + "fig,ax = plt.subplots(1, figsize=(10,10))\n", + "ax.imshow(env.render())\n", + "env.close()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "DLenv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.13" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 5864f5e166d828ebad0892c8bc2ba70acdf4453d Mon Sep 17 00:00:00 2001 From: sowmen Date: Mon, 1 May 2023 09:04:15 +0100 Subject: [PATCH 2/2] updated commits --- test.ipynb | 85 ------------------------------------------------------ 1 file changed, 85 deletions(-) delete mode 100644 test.ipynb diff --git a/test.ipynb b/test.ipynb deleted file mode 100644 index 8a1f976de..000000000 --- a/test.ipynb +++ /dev/null @@ -1,85 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "%load_ext autoreload\n", - "%autoreload 2" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import warnings\n", - "warnings.filterwarnings(\"ignore\")\n", - "\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "import gymnasium\n", - "import highway_env\n", - "highway_env.register_highway_envs()\n", - "\n", - "env = gymnasium.make(\"parking-v0\", render_mode='rgb_array')\n", - "env.configure({\n", - " \"vehicles_count\": 10, \n", - " \"duration\": 300,\n", - " \"screen_width\": 900,\n", - " \"screen_height\": 1200,\n", - " \"collision_reward\": -8,\n", - " \"custom_reward\": False,\n", - " \"n_rows\": 4,\n", - " \"y_offset\": 10, # y distance between parallel rows\n", - " \"obstacles\": True,\n", - " \"random_start\": True\n", - "})\n", - "env.reset()\n", - "\n", - "fig,ax = plt.subplots(1, figsize=(10,10))\n", - "ax.imshow(env.render())\n", - "env.close()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "DLenv", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.13" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 2 -}