Updated folder structure; version update to 0.2

Author: sventarika

alks_scenarios/cutin_scenario_generator.py

@@ -35,8 +35,8 @@ def __init__(self, result_dir: str | Path) -> None:
         dx0_min = 0
         dx0_max = 60
         # Varying values
-        vy_step = 2.0
-        dx0_step = 10
+        vy_step = 3.0
+        dx0_step = 20
         self._vy_values = np.arange(vy_min + vy_step, vy_max + vy_step, vy_step)
         self._dx0_values = np.arange(dx0_min, dx0_max + dx0_step, dx0_step)
 
@@ -81,19 +81,7 @@ def _create_scenarios_of_plot_no(
         plot_no_result_dir = self._result_dir / f"plot_{plot_no:02d}"
         plot_no_result_dir.mkdir(exist_ok=True)
 
-        # Scenarios
-        scenario_result_dir = plot_no_result_dir / "scenarios"
-        scenario_result_dir.mkdir(exist_ok=True)
-
-        # Images
-        scenario_image_dir = plot_no_result_dir / "images"
-        if create_image:
-            scenario_image_dir.mkdir(exist_ok=True)
-
-        # Gifs
-        scenario_gif_dir = plot_no_result_dir / "gifs"
-        if create_gif:
-            scenario_gif_dir.mkdir(exist_ok=True)
+        # Each scenario will get its own subfolder under the plot directory
 
         vo0_kmh = ve0_kmh - dv0_kmh
         ve0 = ve0_kmh / 3.6
@@ -110,9 +98,7 @@ def _create_scenarios_of_plot_no(
                         vy,
                         ve0,
                         vo0,
-                        scenario_result_dir,
-                        scenario_gif_dir,
-                        scenario_image_dir,
+                        plot_no_result_dir,
                         create_gif=create_gif,
                         create_image=create_image,
                         create_openx=create_openx,
@@ -126,9 +112,7 @@ def _create_single_scenario(
         vy: float,
         ve0: float,
         vo0: float,
-        scenario_result_dir: Path,
-        scenario_gif_dir: Path,
-        scenario_image_dir: Path,
+        plot_no_result_dir: Path,
         create_gif: bool = False,
         create_image: bool = False,
         create_openx: bool = False,
@@ -197,36 +181,46 @@ def _create_single_scenario(
             check_feasibility=False,
         )
 
-        scenario_config_dir = scenario_result_dir / "configs"
+        scenario_dir = plot_no_result_dir / scenario_name
+        scenario_dir.mkdir(exist_ok=True)
+
+        scenario_config_dir = scenario_dir / "configs"
         scenario_config_dir.mkdir(exist_ok=True)
         scenario.save(scenario_config_dir)
 
         if create_openx:
-            scenario_result_dir_openx = scenario_result_dir / "openx"
-            scenario_result_dir_openx.mkdir(exist_ok=True)
-            scenario.save(scenario_result_dir_openx, mode="openx")
+            scenario_openx_dir = scenario_dir / "openx"
+            scenario_openx_dir.mkdir(exist_ok=True)
+            scenario.save(scenario_openx_dir, mode="openx")
+        if create_image or create_gif:
+            scenario_image_dir = scenario_dir / "images"
+            scenario_image_dir.mkdir(exist_ok=True)
         if create_image:
             scenario.render(scenario_image_dir, dpi=600)
         if create_gif:
-            scenario.render_gif(scenario_gif_dir, dpi=600)
+            scenario.render_gif(scenario_image_dir, dpi=600)
 
 
 def unpack_and_run(args_list: list) -> None:
     scenario_generator = CutInScenarioGenerator(args_list[0])
     scenario_generator.create_all_scenarios(
-        only_plot_no=args_list[1], create_image=True, create_openx=True
+        only_plot_no=args_list[1], create_image=args_list[2], create_openx=args_list[3], create_gif=args_list[4]
     )
 
 
 def generate_all_scenarios() -> None:
     result_dir = Path(__file__).parent / ".." / "results" / "annex3" / "cutin"
     result_dir.mkdir(exist_ok=True, parents=True)
+    
+    create_image = True
+    create_openx = True
+    create_gif = False
 
-    n_plots_in_regulation = 1
+    n_plots_in_regulation = 14  # Number of plots defined in the regulation
 
     n_workers = n_plots_in_regulation
 
-    all_args_lists = [[result_dir, i + 1] for i in range(n_plots_in_regulation)]
+    all_args_lists = [[result_dir, i + 1, create_image, create_openx, create_gif] for i in range(n_plots_in_regulation)]
 
     if n_workers == 1:
         for arg_list in all_args_lists:

alks_scenarios/cutout_scenario_generator.py

@@ -8,7 +8,7 @@
 from tqdm import tqdm
 
 from simple_scenario import Scenario, EgoConfiguration, Vehicle
-from simple_scenario.road import Road, StraightSegment
+from simple_scenario.road import SyntheticRoad, StraightSegment
 
 
 class CutOutScenarioGenerator:
@@ -134,19 +134,7 @@ def _create_scenarios_of_plot_no(
         plot_no_result_dir = self._result_dir / f"plot_{plot_no:02d}"
         plot_no_result_dir.mkdir(exist_ok=True)
 
-        # Scenarios
-        scenario_result_dir = plot_no_result_dir / "scenarios"
-        scenario_result_dir.mkdir(exist_ok=True)
-
-        # Images
-        scenario_image_dir = plot_no_result_dir / "images"
-        if create_image:
-            scenario_image_dir.mkdir(exist_ok=True)
-
-        # Gifs
-        scenario_gif_dir = plot_no_result_dir / "gifs"
-        if create_gif:
-            scenario_gif_dir.mkdir(exist_ok=True)
+        # Each scenario will get its own subfolder under the plot directory
 
         ve0 = ve0_kmh / 3.6
 
@@ -160,9 +148,7 @@ def _create_scenarios_of_plot_no(
                         vy=vy,
                         ve0=ve0,
                         plot_no=plot_no,
-                        scenario_result_dir=scenario_result_dir,
-                        scenario_gif_dir=scenario_gif_dir,
-                        scenario_image_dir=scenario_image_dir,
+                        plot_no_result_dir=plot_no_result_dir,
                         create_gif=create_gif,
                         create_image=create_image,
                         create_openx=create_openx,
@@ -180,9 +166,7 @@ def _create_single_scenario(  # noqa: PLR0912
         scenario_name: str | None = None,
         check_collision_feasibility: bool = True,
         plot_no: str | None = None,
-        scenario_result_dir: str | Path | None = None,
-        scenario_gif_dir: str | Path | None = None,
-        scenario_image_dir: str | Path | None = None,
+        plot_no_result_dir: str | Path | None = None,
         create_gif: bool = False,
         create_image: bool = False,
         create_openx: bool = False,
@@ -218,7 +202,7 @@ def _create_single_scenario(  # noqa: PLR0912
             vy = self._lane_width / object_vehicle_lc_duration
         scenario_duration = np.ceil(object_vehicle_lc_duration) + 10
 
-        dummy_vehicle = Vehicle(0, 0, 0, 0, 0)
+        dummy_vehicle = Vehicle(0)
         # Object vehicle
         dx0 = ve0 * self._thw0
         if dx0_ego_lead is not None:
@@ -230,10 +214,10 @@ def _create_single_scenario(  # noqa: PLR0912
         vo0 = ve0
         object_vehicle = Vehicle(
             0,
-            self._object_lanelet_id,
-            object_vehicle_s0,
-            object_vehicle_t0,
-            vo0,
+            start_lanelet_id=self._object_lanelet_id,
+            start_s=object_vehicle_s0,
+            start_t=object_vehicle_t0,
+            v0=vo0,
             lc_direction=-1,
             lc_type="vy",
             lc_vy=vy,
@@ -242,20 +226,22 @@ def _create_single_scenario(  # noqa: PLR0912
         # f vehicle (slow vehicle)
         f_vehicle_s0 = object_vehicle_s0 + dummy_vehicle.length + dx0_f
         f_vehicle_t0 = object_vehicle_t0
-        f_vehicle = Vehicle(1, self._f_lanelet_id, f_vehicle_s0, f_vehicle_t0, vf0)
+        f_vehicle = Vehicle(1, start_lanelet_id=self._f_lanelet_id, start_s=f_vehicle_s0, start_t=f_vehicle_t0, v0=vf0)
 
         # Calculate road length
         ego_dist = ve0 * scenario_duration
-        road_length = max(ego_dist, self._min_road_length) + self._ego_s0 + 100
+        road_length = max(ego_dist, self._min_road_length) + self._ego_s0 + 110 # TODO: check length of object trajectory as well
         goal_position = max(
             self._ego_s0 + 0.75 * ego_dist,
             f_vehicle_s0 + vf0 * scenario_duration + dummy_vehicle.length,
         )
-        road = Road(
+        ego_configuration = EgoConfiguration(
+            self._ego_lanelet_id, self._ego_s0, self._ego_t0, ve0, target_s=goal_position, target_t=0, target_lanelet_id=self._ego_lanelet_id
+        )
+        road = SyntheticRoad(
             self._n_lanes,
             self._lane_width,
             segments=[StraightSegment(road_length)],
-            goal_position=goal_position,
             speed_limit=60,
         )
 
@@ -278,38 +264,49 @@ def _create_single_scenario(  # noqa: PLR0912
         if not scenario_is_feasible:
             return None
 
-        if scenario_result_dir is not None:
-            scenario_config_dir = scenario_result_dir / "configs"
+        if plot_no_result_dir is not None:
+            scenario_dir = Path(plot_no_result_dir) / scenario_name
+            scenario_dir.mkdir(exist_ok=True)
+
+            scenario_config_dir = scenario_dir / "configs"
             scenario_config_dir.mkdir(exist_ok=True)
             scenario.save(scenario_config_dir)
+
             if create_openx:
-                scenario_result_dir_openx = scenario_result_dir / "openx"
-                scenario_result_dir_openx.mkdir(exist_ok=True)
-                scenario.save(scenario_result_dir_openx, mode="openx")
-        if scenario_image_dir is not None and create_image:
-            scenario.render(scenario_image_dir, dpi=600)
-        if scenario_gif_dir is not None and create_gif:
-            scenario.render_gif(scenario_gif_dir, dpi=600)
+                scenario_openx_dir = scenario_dir / "openx"
+                scenario_openx_dir.mkdir(exist_ok=True)
+                scenario.save(scenario_openx_dir, mode="openx")
+            if create_image or create_gif:
+                scenario_image_dir = scenario_dir / "images"
+                scenario_image_dir.mkdir(exist_ok=True)
+            if create_image:
+                scenario.render(scenario_image_dir, dpi=600)
+            if create_gif:
+                scenario.render_gif(scenario_image_dir, dpi=600)
 
         return scenario
 
 
 def unpack_and_run(args_list: list) -> None:
     scenario_generator = CutOutScenarioGenerator(args_list[0])
     scenario_generator.create_all_scenarios(
-        only_plot_no=args_list[1], create_image=True, create_openx=True
+        only_plot_no=args_list[1], create_image=args_list[2], create_openx=args_list[3], create_gif=args_list[4]
     )
 
 
 def generate_all_scenarios() -> None:
     result_dir = Path(__file__).parent / ".." / "results" / "annex3" / "cutout"
     result_dir.mkdir(exist_ok=True, parents=True)
 
+    create_image = True
+    create_openx = True
+    create_gif = False
+
     n_plots_in_regulation = 6
 
     n_workers = n_plots_in_regulation
 
-    all_args_lists = [[result_dir, i + 1] for i in range(n_plots_in_regulation)]
+    all_args_lists = [[result_dir, i + 1, create_image, create_openx, create_gif] for i in range(n_plots_in_regulation)]
 
     if n_workers == 1:
         for arg_list in all_args_lists:

alks_scenarios/deceleration_scenario_generator.py

@@ -10,7 +10,7 @@
 from tqdm import tqdm
 
 from simple_scenario import Scenario, EgoConfiguration, Vehicle
-from simple_scenario.road import Road, StraightSegment
+from simple_scenario.road import SyntheticRoad, StraightSegment
 
 
 class DecelerationScenarioGenerator:
@@ -49,20 +49,7 @@ def create_all_scenarios(
         create_image: bool = False,
         create_gif: bool = False,
     ) -> None:
-        # Create folders
-        # Scenarios
-        scenario_result_dir = self._result_dir / "scenarios"
-        scenario_result_dir.mkdir(exist_ok=True)
-
-        # Images
-        scenario_image_dir = self._result_dir / "images"
-        if create_image:
-            scenario_image_dir.mkdir(exist_ok=True)
-
-        # Gifs
-        scenario_gif_dir = self._result_dir / "gifs"
-        if create_gif:
-            scenario_gif_dir.mkdir(exist_ok=True)
+        # Each scenario will get its own subfolder under the result directory
 
         n_scenarios = len(self._gx_values) * len(self._ve0_kmh_values)
 
@@ -72,21 +59,16 @@ def create_all_scenarios(
                     self._create_single_scenario(
                         gx,
                         ve0_kmh,
-                        scenario_result_dir,
-                        scenario_gif_dir,
-                        scenario_image_dir,
                         create_openx=create_openx,
                         create_image=create_image,
+                        create_gif=create_gif,
                     )
                     progress_bar.update(1)
 
     def _create_single_scenario(
         self,
         gx: float,
         ve0_kmh: float,
-        scenario_result_dir: Path,
-        scenario_gif_dir: Path,
-        scenario_image_dir: Path,
         create_openx: bool = False,
         create_gif: bool = False,
         create_image: bool = False,
@@ -104,15 +86,15 @@ def _create_single_scenario(
         )
 
         # Object vehicle
-        object_vehicle_length = Vehicle(0, 0, 0, 0, 0).length
+        object_vehicle_length = Vehicle(0).length
         dx = ve0 * self._thw0
         object_s0 = (
             self._ego_s0 + dx + ego_configuration.length / 2 + object_vehicle_length / 2
         )
         object_a0 = -gx * self._g
 
         object_vehicle = Vehicle(
-            0, self._object_lanelet_id, object_s0, self._ego_t0, vo0, object_a0
+            0, start_lanelet_id=self._object_lanelet_id, start_s=object_s0, start_t=self._ego_t0, v0=vo0, a0=object_a0
         )
 
         # Calculate road length
@@ -127,11 +109,13 @@ def _create_single_scenario(
 
         road_length = max(ego_dist, self._min_road_length) + self._ego_s0 + 100
         goal_position = self._ego_s0 + 0.75 * ego_dist
-        road = Road(
+        ego_configuration = EgoConfiguration(
+            self._ego_lanelet_id, self._ego_s0, self._ego_t0, ve0, target_s=goal_position, target_t=0, target_lanelet_id=self._ego_lanelet_id
+        )
+        road = SyntheticRoad(
             self._n_lanes,
             self._lane_width,
             segments=[StraightSegment(road_length)],
-            goal_position=goal_position,
             speed_limit=60,
         )
 
@@ -144,26 +128,32 @@ def _create_single_scenario(
             check_feasibility=False,
         )
 
-        scenario_config_dir = scenario_result_dir / "configs"
+        scenario_dir = self._result_dir / scenario_name
+        scenario_dir.mkdir(exist_ok=True)
+
+        scenario_config_dir = scenario_dir / "configs"
         scenario_config_dir.mkdir(exist_ok=True)
         scenario.save(scenario_config_dir)
 
         if create_openx:
-            scenario_result_dir_openx = scenario_result_dir / "openx"
-            scenario_result_dir_openx.mkdir(exist_ok=True)
-            scenario.save(scenario_result_dir_openx, mode="openx")
+            scenario_openx_dir = scenario_dir / "openx"
+            scenario_openx_dir.mkdir(exist_ok=True)
+            scenario.save(scenario_openx_dir, mode="openx")
+        if create_image or create_gif:
+            scenario_image_dir = scenario_dir / "images"
+            scenario_image_dir.mkdir(exist_ok=True)
         if create_image:
             scenario.render(scenario_image_dir, dpi=600)
         if create_gif:
-            scenario.render_gif(scenario_gif_dir, dpi=600)
+            scenario.render_gif(scenario_image_dir, dpi=600)
 
 
 def generate_all_scenarios() -> None:
     result_dir = Path(__file__).parent / ".." / "results" / "annex3" / "deceleration"
     result_dir.mkdir(exist_ok=True, parents=True)
 
     scenario_generator = DecelerationScenarioGenerator(result_dir)
-    scenario_generator.create_all_scenarios(create_openx=True, create_image=True)
+    scenario_generator.create_all_scenarios(create_openx=True, create_image=True, create_gif=False)
 
 
 if __name__ == "__main__":