Tactics2D

https://github.com/woodoxen/tactics2d
Admin
Tactics2D is a reinforcement learning environment library for autonomous driving decision-making...
Tokens:87,020
Snippets:515
Trust Score:7
Update:6 months ago
Show doc for...
Tokens:
Raw
### Install tactics2d and tqdm

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/tutorial/dataset_visualization.ipynb

Installs the tactics2d library and tqdm for progress bars. This is a prerequisite for running the visualization examples.

```python
%%capture
!pip install tactics2d
!pip install tqdm
```

--------------------------------

### Initialize DLP Parsers

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/dataset_support/dlp.ipynb

Setup paths and initialize the dataset and map parsers.

```python
dataset_path = "../../data/DLP"  # Replace with your dataset path
map_path = "../../data/DLP_map"  # Replace with your map path
dataset_parser = DLPParser()
map_parser = OSMParser(lanelet2=True)
```

--------------------------------

### Install Tactics2D from PyPI or Source

Source: https://context7.com/woodoxen/tactics2d/llms.txt

Install the library using pip or build from source after cloning the repository.

```bash
pip install tactics2d
```

```bash
git clone --recurse-submodules git@github.com:WoodOxen/tactics2d.git
cd tactics2d
pip install -v .
```

--------------------------------

### Initialize Log Replay for Singapore

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/dataset_support/nuplan.ipynb

Partial setup for loading a log file from the Singapore dataset.

```python
data_file = "2021.08.18.06.04.33_veh-51_00016_00170.db"
data_path = os.path.join(dataset_path, "train_singapore")
```

--------------------------------

### Install tactics2d Library

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/tutorial/interpolator_visualization.ipynb

Installs the tactics2d library. This command should be run before importing the library.

```python
%%capture
!pip install tactics2d
```

--------------------------------

### Install tactics2d via PyPI

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/installation.md

Standard installation command for the tactics2d package.

```bash
pip install tactics2d
```

--------------------------------

### Install dependencies

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/tutorial/racing_pure_pursuit_demo.ipynb

Install the required tactics2d package using pip.

```python
%%capture
# %pip install tactics2d
```

--------------------------------

### Training Start Output

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/tutorial/train_parking_demo.ipynb

Indicates the beginning of the agent training process.

```text
start train!

```

--------------------------------

### Install tactics2d from Source

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/installation.md

Clones the repository and installs the package locally. Requires GCC and manual placement of NuPlan map data.

```bash
# clone the repository with submodules but ignore the large files (mainly the NuPlan's map data)
# please download NuPlan's map data from its official website and put it in the `tactics2d/data/map/NuPlan` directory
git clone --recurse-submodules git@github.com:WoodOxen/tactics2d.git
cd tactics2d
pip install -v .
```

--------------------------------

### Install Dependencies

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/tutorial/train_parking_demo.ipynb

Installs necessary dependencies for the project, including PyTorch. This is a temporary solution until version 0.1.7 is released on PyPI.

```shell
git submodule update --init --recursive
```

```python
%%capture
# TODO: this is a temporary solution to install the package from the repo
# TODO: remove this cell and install the package from pypi when 0.1.7 is released
# %pip install tactics2d
%pip install torch
```

--------------------------------

### Configure and Train PPO Agent

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/tutorial/train_parking_demo.ipynb

Defines the agent configuration using PPOConfig, initializes the agent with environment specifics, and starts the training process. Adjust hyperparameters and training steps for optimal performance. Ensure the environment and necessary classes (e.g., ParkingActor, RSAgent, ParkingAgent) are imported.

```python
agent_config = PPOConfig(
    {
        "debug": True,
        "state_space": env.observation_space,
        "action_space": env.action_space,
        "gamma": 0.995,
        "lr": 2e-6,
        "actor_net": ParkingActor,
        "actor_kwargs": {
            "state_dim": env.observation_space.shape[0],
            "action_dim": env.action_space.shape[0],
            "hidden_size": 256,
            "continuous": True,
        },
        "critic_kwargs": {"state_dim": env.observation_space.shape[0], "hidden_size": 256},
        "horizon": 20000,
        "batch_size": 32,
        "adam_epsilon": 1e-8,
    }
)
min_radius = vehicle.wheel_base / np.tan(vehicle.steer_range[1] * STEER_RATIO)
vehicle_rear_to_center = 0.5 * vehicle.length - vehicle.rear_overhang
device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
rs_agent = RSAgent(path_planner, min_radius, vehicle_rear_to_center)
agent = ParkingAgent(agent_config, rs_agent, device)
log_path = "./logs"
num_episode = 20  # 1e5

train_rl_agent(env, agent, episode_num=num_episode, log_path=log_path, verbose=True)
```

--------------------------------

### Import and Print tactics2d Version

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/tutorial/interpolator_visualization.ipynb

Imports the tactics2d library and prints its installed version. Ensure the library is installed before running this.

```python
import tactics2d

print(tactics2d.__version__)
```

--------------------------------

### Grid Map Output Example

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/tutorial/sampling_search_demo.ipynb

Sample output generated from the grid map generation process.

```text
Output:
Grid map shape: (10, 10)
Start: (3, 5), Goal: (0, 1)
Number of obstacles: 10
```

--------------------------------

### Run Code Style Checks - Shell

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/community.md

Install pre-commit and run all checks to ensure code and documentation style compliance.

```shell
pip install pre-commit
pre-commit run --all-files
```

--------------------------------

### Execute Log Replay for Boston

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/dataset_support/nuplan.ipynb

Example workflow to load a specific log file from the Boston dataset and display the animation.

```python
data_file = "2021.08.18.18.32.06_veh-28_00049_00111.db"
data_path = os.path.join(dataset_path, "train_boston")

location = dataset_parser.get_location(data_file, data_path)
map_config = NUPLAN_MAP_CONFIG[location]
map_file = map_config["folder"] + "/" + map_config["gpkg_file"]
print(f"Displaying log replay at {location}")

participants, actual_time_range = dataset_parser.parse_trajectory(data_file, data_path)
map_ = map_parser.parse(os.path.join(map_path, map_file))
print(len(map_.lanes), len(map_.areas), len(map_.roadlines))

ani = render_nuplan(map_, participants, actual_time_range)
HTML(ani.to_html5_video())
```

--------------------------------

### Execute CitySim Replay Examples

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/dataset_support/citysim.ipynb

Parses specific intersection or roundabout trajectory files and triggers the animation rendering.

```python
participants, actual_time_range = dataset_parser.parse_trajectory(
    file="IntersectionA-01.csv",
    folder=os.path.join(dataset_path, "Intersection A (Signalized Intersection)/Trajectories"),
    time_range=(0, 5000),
)

map_ = Map()

boundary = (-10, 160, -20, 100)
print(f"Map range of Intersection A (Signalized Intersection) we display: {boundary}")

ani = render_citysim(map_, participants, boundary, actual_time_range)
HTML(ani.to_html5_video())
```

```python
participants, actual_time_range = dataset_parser.parse_trajectory(
    file="IntersectionD-01.csv",
    folder=os.path.join(dataset_path, "Intersection D (Permissive Left Turn Phasing)/Trajectories"),
    time_range=(3000, 10000),
)

map_ = Map()

boundary = (0, 270, 0, 85)
print(f"Map range of Intersection D (Permissive Left Turn Phasing) we display: {boundary}")

ani = render_citysim(map_, participants, boundary, actual_time_range)
HTML(ani.to_html5_video())
```

```python
participants, actual_time_range = dataset_parser.parse_trajectory(
    file="IntersectionE-01.csv",
    folder=os.path.join(dataset_path, "Intersection E (Permissive Left Turn Phasing)/Trajectories"),
    time_range=(0, 10000),
)

map_ = Map()

boundary = (10, 150, 0, 70)
print(f"Map range of Intersection E (Permissive Left Turn Phasing) we display: {boundary}")

ani = render_citysim(map_, participants, boundary, actual_time_range)
HTML(ani.to_html5_video())
```

```python
participants, actual_time_range = dataset_parser.parse_trajectory(
    file="RoundaboutA-01.csv",
    folder=os.path.join(dataset_path, "Roundabout A (Single Lane)/Trajectories"),
    time_range=(0, 10000),
)

map_ = Map()

boundary = (20, 180, 20, 130)
print(f"Map range of Roundabout A (Single Lane) we display: {boundary}")

ani = render_citysim(map_, participants, boundary, actual_time_range)
HTML(ani.to_html5_video())
```

```python
participants, actual_time_range = dataset_parser.parse_trajectory(
    file="RoundaboutB-01.csv",
    folder=os.path.join(dataset_path, "Roundabout B (Multiple Lanes)/Trajectories"),
    time_range=(0, 10000),
)

map_ = Map()

boundary = (-5, 150, 20, 85)
print(f"Map range of Roundabout B (Multiple Lanes) we display: {boundary}")

ani = render_citysim(map_, participants, boundary, actual_time_range)
HTML(ani.to_html5_video())
```

--------------------------------

### Execute A* Pathfinding

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/tutorial/graph_search_demo.ipynb

Performs path planning using the A* algorithm with a specified graph, start, goal, and callback function.

```python
result = plan_with_astar(
    graph=graph, start=start, goal=goal, size=size, callback=a_star_callback
)
```

--------------------------------

### Visualize RRT-Connect Path Planning

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/tutorial/sampling_search_demo.ipynb

Sets up and displays an animation of the RRT-Connect algorithm's execution. Requires pre-generated grid_map, start, and goal. The animation visualizes algorithm states and collected path.

```python
result = plan_with_rrt_connect(
    grid_map=grid_map,
    start=start,
    goal=goal,
    size=size,
    callback=rrt_connect_callback,
    reset_seed=False,  # You can observe different runs by changing this to True
)

if result is not None:
    grid_map, start, goal, path, trees = result
    tree_a, tree_b = trees
    height, width = grid_map.shape

    print(f"Collected {len(rrt_connect_states_history)} algorithm states")

    # Initialize visualization objects for RRT-Connect animation
    global ax, vis_objects
    vis_objects = {
        "cell_patches": [],  # List of Rectangle patches for each cell
        "cell_texts": [],  # List of text objects for cost labels
        "start_patch": None,  # Start cell patch (special)
        "goal_patch": None,  # Goal cell patch (special)
        "current_patch": None,  # Current node highlight patch
        "visited_patches": [],  # Visited nodes highlight patches
        "path_line": None,  # Final path line
        "tree_lines": [],  # Lines representing tree edges (single tree) - not used for RRT-Connect
        "tree_nodes": [],  # Circles representing tree nodes (single tree) - not used for RRT-Connect
        "tree_lines_a": [],  # Lines representing tree A edges (dual tree)
        "tree_nodes_a": [],  # Circles representing tree A nodes (dual tree)
        "tree_lines_b": [],  # Lines representing tree B edges (dual tree)
        "tree_nodes_b": [],  # Circles representing tree B nodes (dual tree)
        "random_point_marker": None,  # Marker for random sampling point
    }

    fig, ax = init_figure(size)

    # Create animation for RRT-Connect using unified update function
    rrt_connect_animation = FuncAnimation(
        fig,
        create_sampling_update_frame("RRT-Connect", rrt_connect_states_history),
        frames=len(rrt_connect_states_history),
        init_func=lambda: init_grid(ax, vis_objects, grid_map, start, goal, width, height),
        interval=1000 // fps,  # ms per frame
        blit=False,
        repeat=True,
    )

    # rrt_connect_animation.save(
    #     "rrt_connect_animation.mp4", writer="ffmpeg", fps=fps, dpi=300
    # )

    # Display animation in Jupyter
    display(HTML(rrt_connect_animation.to_jshtml()))
else:
    print("RRT-Connect planning failed")
```

--------------------------------

### Run RRT* and Visualize Path

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/tutorial/sampling_search_demo.ipynb

Executes the RRT* planning algorithm and sets up visualization objects for animation. Requires pre-generated grid_map, start, and goal. The `reset_seed` parameter can be toggled for observing different planning outcomes.

```python
result = plan_with_rrt_star(
    grid_map=grid_map,
    start=start,
    goal=goal,
    size=size,
    callback=rrt_star_callback,
    reset_seed=False,  # You can observe different runs by changing this to True
    radius=3.0,
)

if result is not None:
    grid_map, start, goal, path, tree = result
    height, width = grid_map.shape

    print(f"Collected {len(rrt_star_states_history)} algorithm states")

    # Initialize visualization objects for RRT* animation
    global ax, vis_objects
    vis_objects = {
        "cell_patches": [],  # List of Rectangle patches for each cell
        "cell_texts": [],  # List of text objects for cost labels
        "start_patch": None,  # Start cell patch (special)
        "goal_patch": None,  # Goal cell patch (special)
        "current_patch": None,  # Current node highlight patch
        "visited_patches": [],  # Visited nodes highlight patches
        "path_line": None,  # Final path line
        "tree_lines": [],  # Lines representing tree edges (single tree)
        "tree_nodes": [],  # Circles representing tree nodes (single tree)
        "tree_lines_a": [],  # Lines representing tree A edges (dual tree) - not used for RRT*
        "tree_nodes_a": [],  # Circles representing tree A nodes (dual tree) - not used for RRT*
        "tree_lines_b": [],  # Lines representing tree B edges (dual tree) - not used for RRT*
        "tree_nodes_b": [],  # Circles representing tree B nodes (dual tree) - not used for RRT*
        "random_point_marker": None,  # Marker for random sampling point
    }

    fig, ax = init_figure(size)

    # Create animation for RRT* using unified update function
    rrt_star_animation = FuncAnimation(
        fig,
        create_sampling_update_frame("RRT*", rrt_star_states_history),
        frames=len(rrt_star_states_history),
        init_func=lambda: init_grid(ax, vis_objects, grid_map, start, goal, width, height),
        interval=1000 // fps,  # ms per frame
        blit=False,
        repeat=True,
    )

    # rrt_star_animation.save(
    #     "rrt_star_animation.mp4", writer="ffmpeg", fps=fps, dpi=300
    # )

    # Display animation in Jupyter
    display(HTML(rrt_star_animation.to_jshtml()))
else:
    print("RRT* planning failed")
```

--------------------------------

### Initialize Environment and Imports

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/tutorial/sampling_search_demo.ipynb

Sets up the necessary libraries and configuration for path planning simulations.

```python
%matplotlib notebook

import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
from matplotlib.patches import Rectangle
from IPython.display import HTML
from shapely.geometry import LineString, Polygon

from tactics2d.search import RRT, RRTStar, RRTConnect, PRM
from tactics2d.map.generator import GridMapGenerator

# For reproducibility
random_seed = 2048
np.random.seed(random_seed)

mpl.rcParams["animation.embed_limit"] = 50 * 1024 * 1024  # 50 MB
```

--------------------------------

### RRT-Connect Planning Function

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/tutorial/sampling_search_demo.ipynb

Defines the RRT-Connect planning function, which takes a grid map, start, and goal, and returns a path. It includes setup for boundary, coordinate conversion, obstacle extraction, and collision checking. An optional callback can be provided for state collection.

```python
def plan_with_rrt_connect(grid_map, start, goal, size, callback=None, reset_seed=True):
    """Plan a path using RRT-Connect algorithm on a grid map with optional callback."""
    # Define boundary [xmin, xmax, ymin, ymax] with grid_resolution=1.0
    if reset_seed:
        np.random.seed()  # Reset random seed for variability

    width, height = size  # grid_map shape is (height, width)
    boundary = [0, width, 0, height]

    # Convert start and goal from (row, col) to (x, y) = (col, row) for RRT-Connect
    start_xy = np.array(grid_to_continuous_coords(start))
    goal_xy = np.array(grid_to_continuous_coords(goal))

    # Extract obstacles from grid map using shared function
    obstacles = extract_obstacles_from_grid(grid_map)

    # Create collision checking function using shared function
    collide_fn = create_grid_collision_checker(obstacles)

    # Run RRT-Connect planning with callback
    path, trees = RRTConnect.plan(
        start=start_xy,
        target=goal_xy,
        boundary=np.array(boundary),
        obstacles=obstacles,
        collide_fn=collide_fn,
        extension_step=1.0,
        max_iter=10000,
        callback=callback,
    )

    if len(path) == 0:
        print("RRT-Connect failed to find a path")
        return None
    else:
        print(f"RRT-Connect found a path with {len(path)} waypoints")
        return grid_map, start, goal, path, trees
```

--------------------------------

### Initialize and Run ParkingEnv

Source: https://context7.com/woodoxen/tactics2d/llms.txt

Set up a ParkingEnv for training vehicles to park. Supports continuous action spaces and provides detailed state information during simulation.

```python
import numpy as np
from tactics2d.envs import ParkingEnv

# Create parking environment with bay parking scenarios
env = ParkingEnv(
    type_proportion=0.5,  # 50% bay parking, 50% parallel parking
    render_mode="human",
    render_fps=60,
    max_step=20000,
    continuous=True  # Use continuous action space
)

# Reset environment and get initial observation
observation, info = env.reset(seed=42)

# Run simulation loop
for step in range(1000):
    # Action: [steering_angle, acceleration]
    # Steering: [-0.524, 0.524] radians
    # Acceleration: [-2.0, 2.0] m/s^2
    action = np.array([0.1, 0.5], dtype=np.float32)

    observation, reward, terminated, truncated, info = env.step(action)
    env.render()

    # Access state information
    print(f"Step {step}: reward={reward:.3f}")
    print(f"  Traffic status: {info['traffic_status']}")
    print(f"  Scenario status: {info['scenario_status']}")
    print(f"  Distance to target: {info['diff_position']:.2f}m")

    if terminated or truncated:
        print("Episode finished!")
        break

env.close()
```

--------------------------------

### Initialize Planning Environment

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/tutorial/graph_search_demo.ipynb

Imports necessary libraries for visualization and path planning, including A* and Dijkstra implementations from the tactics2d package.

```python
%matplotlib notebook

import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
from matplotlib.patches import Rectangle
from IPython.display import HTML


from tactics2d.search import AStar, Dijkstra, grid_to_csr
from tactics2d.map.generator import GridMapGenerator
```

--------------------------------

### Initialize Dataset and Map Parsers

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/dataset_support/nuplan.ipynb

Set up the paths and parser instances required to process NuPlan data files.

```python
dataset_path = "../../data/nuplan/data/cache"  # Replace with your dataset path
map_path = "../../data/nuplan/maps"
dataset_parser = NuPlanParser()
map_parser = GPKGParser("nuplan")
```

--------------------------------

### Initialize Dataset and Map Parsers

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/dataset_support/exid.ipynb

Configure the paths and parser instances for the exiD dataset and map files.

```python
path_dataset = "../../data/exiD/data"  # Replace with your dataset path
path_maps = "../../data/exiD_map"  # Replace with your map path
dataset_parser = LevelXParser("exiD")
map_parser = OSMParser(lanelet2=True)
```

--------------------------------

### Load map configuration and initialize parsers

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/tutorial/dataset_visualization.ipynb

Downloads a map configuration file and loads it using JSON. It then initializes the ScenarioDisplay and OSMParser for map-related functionalities.

```python
config_file = "map.config"
config_path = os.path.join("data", config_file)

download_file(
    "https://raw.githubusercontent.com/WoodOxen/tactics2d/master/tactics2d/dataset_parser/map.config",
    config_file,
)

with open(config_path, "r") as f:
    configs = json.load(f)

scenario_display = ScenarioDisplay()
lanelet2_parser = OSMParser(lanelet2=True)
```

--------------------------------

### Retrieve ego state

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/tutorial/racing_pure_pursuit_demo.ipynb

Get and print the current state of the ego vehicle.

```python
center_line = map_.roadlines["center_line"]
ego_state = env.get_ego_state()
print(ego_state)
```

--------------------------------

### Initialize Git Submodules for Tutorial

Source: https://github.com/woodoxen/tactics2d/blob/master/README.md

Update and initialize Git submodules, which is necessary for running specific tutorial notebooks like train_parking_demo.ipynb.

```bash
git submodule update --init --recursive
```

--------------------------------

### Initialize dataset and map parsers

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/dataset_support/ind.ipynb

Sets up the `LevelXParser` for the 'inD' dataset and `OSMParser` for map data. Specify the correct paths to your dataset and map files.

```python
dataset_path = "../../data/inD/data"  # Replace with your dataset path
map_path = "../../data/inD_map"  # Replace with your map path
dataset_parser = LevelXParser("inD")
map_parser = OSMParser(lanelet2=True)
```

--------------------------------

### Generate Grid Map

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/tutorial/sampling_search_demo.ipynb

Example usage of the GridMapGenerator to create a map and extract obstacle data.

```python
connectivity = 8
fps = 10
size = (10, 10)

map_generator = GridMapGenerator(
    size=size, min_cost=0, max_cost=5, obstacle_proportion=0.1, random_seed=random_seed
)

grid_map, start, goal = map_generator.generate()
print(f"Grid map shape: {grid_map.shape}")
print(f"Start: {start}, Goal: {goal}")

# For sampling-based algorithms, we need obstacle information from grid map
# Use shared function to extract obstacles
obstacles = extract_obstacles_from_grid(grid_map)
print(f"Number of obstacles: {len(obstacles)}")
```

--------------------------------

### Initialize dataset and map parsers

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/dataset_support/round.ipynb

Set the paths for the dataset and map, then initialize the LevelXParser for the rounD dataset and OSMParser for map data. Ensure the paths are correct for your environment.

```python
dataset_path = "../../data/rounD/data"  # Replace with your dataset path
map_path = "../../data/rounD_map"  # Replace with your map path
dataset_parser = LevelXParser("rounD")
map_parser = OSMParser(lanelet2=True)
```

--------------------------------

### Visualize HighD Dataset Locations

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/dataset_support/highd.ipynb

Examples of parsing and rendering specific highD dataset locations.

```python
participants, actual_time_range = dataset_parser.parse_trajectory(
    file=11, folder=dataset_path, time_range=(0, 10000)
)
map_ = map_parser.parse(
    file_path=os.path.join(map_path, "highD_1.osm"), configs=HIGHD_MAP_CONFIG["highD_1"]
)

print(f"Map boundary of HighD location 1: {map_.boundary}.")

boundary = (
    map_.boundary[0] + 100,
    map_.boundary[1] - 100,
    map_.boundary[2] - 20,
    map_.boundary[3] + 20,
)

ani = render_levelx(map_, participants, boundary, actual_time_range)
HTML(ani.to_html5_video())
```

```python
participants, actual_time_range = dataset_parser.parse_trajectory(
    file=1, folder=dataset_path, time_range=(10000, 20000)
)
map_ = map_parser.parse(
    file_path=os.path.join(map_path, "highD_2.osm"), configs=HIGHD_MAP_CONFIG["highD_2"]
)

print(f"Map boundary of HighD location 2: {map_.boundary}.")

boundary = (
    map_.boundary[0] + 100,
    map_.boundary[1] - 100,
    map_.boundary[2] - 20,
    map_.boundary[3] + 20,
)

ani = render_levelx(map_, participants, boundary, actual_time_range)
HTML(ani.to_html5_video())
```

```python
participants, actual_time_range = dataset_parser.parse_trajectory(
    file=4, folder=dataset_path, time_range=(20000, 30000)
)
map_ = map_parser.parse(
    file_path=os.path.join(map_path, "highD_3.osm"), configs=HIGHD_MAP_CONFIG["highD_3"]
)

print(f"Map boundary of HighD location 3: {map_.boundary}.")

boundary = (
    map_.boundary[0] + 100,
    map_.boundary[1] - 100,
    map_.boundary[2] - 20,
    map_.boundary[3] + 20,
)

ani = render_levelx(map_, participants, boundary, actual_time_range)
HTML(ani.to_html5_video())
```

```python
participants, actual_time_range = dataset_parser.parse_trajectory(
    file=7, folder=dataset_path, time_range=(30000, 40000)
)
map_ = map_parser.parse(
    file_path=os.path.join(map_path, "highD_4.osm"), configs=HIGHD_MAP_CONFIG["highD_4"]
)

print(f"Map boundary of HighD location 4: {map_.boundary}.")

boundary = (
    map_.boundary[0] + 100,
    map_.boundary[1] - 100,
    map_.boundary[2] - 20,
    map_.boundary[3] + 20,
)

ani = render_levelx(map_, participants, boundary, actual_time_range)
HTML(ani.to_html5_video())
```

--------------------------------

### Initialize and Run RacingEnv

Source: https://context7.com/woodoxen/tactics2d/llms.txt

Set up a RacingEnv for training racing cars on procedurally generated tracks. Supports continuous action spaces and provides vehicle state information.

```python
import numpy as np
from tactics2d.envs import RacingEnv

# Create racing environment
env = RacingEnv(
    render_mode="human",
    render_fps=60,
    max_step=100000,
    continuous=True
)

# Reset and get initial state
observation, info = env.reset(seed=42)

# Racing loop
total_reward = 0
for step in range(5000):
    # Action: [steering_angle, acceleration]
    # Steering: [-0.5, 0.5] radians
    # Acceleration: [-4.0, 2.0] m/s^2
    action = np.array([0.0, 1.5], dtype=np.float32)

    observation, reward, terminated, truncated, info = env.step(action)
    total_reward += reward
    env.render()

    # Get current vehicle state
    ego_state = env.get_ego_state()
    print(f"Speed: {ego_state.speed:.2f} m/s, Heading: {ego_state.heading:.2f} rad")

    if terminated:
        print(f"Race completed! Total reward: {total_reward:.2f}")
        break
    if truncated:
        print(f"Race failed! Reason: {info['scenario_status']}")
        break

env.close()
```

--------------------------------

### Initialize Analysis Environment

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/dataset_support/citysim.ipynb

Imports necessary libraries and configures logging for the data analysis pipeline.

```python
%matplotlib inline
import warnings

warnings.filterwarnings("ignore")

import logging

logging.basicConfig(level=logging.WARNING)

import os
import glob

import polars as pl
import numpy as np
import matplotlib as mpl
import matplotlib.gridspec as gridspec
import matplotlib.pyplot as plt
import seaborn as sns
```

--------------------------------

### Execute Speed Distribution Analysis

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/dataset_support/nuplan.ipynb

Examples of calling the plotting function with specific map boundaries and trajectory datasets.

```python
map_boundary_boston = [330500, 333500, 4689100, 4691400]
plot_speed_distribution(
    map_boundary_boston, data_path, trajectory_folders[0], trajectory_files[0]
)
```

```python
map_boundary_pittsburgh = [587000, 589500, 4473750, 4476250]
plot_speed_distribution(
    map_boundary_pittsburgh, data_path, trajectory_folders[1], trajectory_files[1]
)
```

```python
map_boundary_pittsburgh = [364750, 366250, 142700, 144400]
plot_speed_distribution(
    map_boundary_pittsburgh, data_path, trajectory_folders[2], trajectory_files[2]
)
```

```python
map_boundary_pittsburgh = [664000, 667000, 3996000, 4000000]
plot_speed_distribution(
    map_boundary_pittsburgh, data_path, trajectory_folders[3], trajectory_files[3], proportion=0.6
)
```

--------------------------------

### Initialize Parking Environment and RS Planner

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/tutorial/train_parking_demo.ipynb

Sets up the parking environment and initializes the Reeds-Shepp planner with agent and sensor parameters. This is a prerequisite for path planning.

```python
print(vars(env))
env = ParkingWrapper(env)
print(vars(env))
path_planner = RSPlanner(env.unwrapped.scenario_manager.agent, num_lidar_rays, lidar_range)
vehicle = env.unwrapped.scenario_manager.agent
```

--------------------------------

### Configure Dataset and Map Paths

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/dataset_support/highd.ipynb

Set the file paths and initialize the parsers for the highD dataset.

```python
dataset_path = "../../data/highD/data"  # Replace with your dataset path
map_path = "../../data/highD_map"  # Replace with your map path
dataset_parser = LevelXParser("highD")
map_parser = OSMParser(lanelet2=True)
```

--------------------------------

### Import necessary libraries for Tactics2D

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/dataset_support/round.ipynb

Import all required modules from Tactics2D and other libraries for log parsing and visualization. Ensure these libraries are installed.

```python
%matplotlib notebook

import os
import numpy as np
from matplotlib.animation import FuncAnimation
from shapely.geometry import Point
from IPython.display import HTML

from tactics2d.dataset_parser import LevelXParser
from tactics2d.map.parser import OSMParser
from tactics2d.map.map_config import ROUND_MAP_CONFIG
from tactics2d.sensor import BEVCamera
from tactics2d.renderer import MatplotlibRenderer
```

--------------------------------

### Execute Log Replay for Pittsburgh

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/dataset_support/nuplan.ipynb

Example workflow to load a specific log file from the Pittsburgh dataset and display a truncated animation.

```python
data_file = "2021.08.17.13.10.50_veh-08_00313_00564.db"
data_path = os.path.join(dataset_path, "train_pittsburgh")

location = dataset_parser.get_location(data_file, data_path)
map_config = NUPLAN_MAP_CONFIG[location]
map_file = map_config["folder"] + "/" + map_config["gpkg_file"]
print(f"Displaying log replay at {location}")

participants, actual_time_range = dataset_parser.parse_trajectory(data_file, data_path)
map_ = map_parser.parse(os.path.join(map_path, map_file))

ani = render_nuplan(map_, participants, actual_time_range[:200])
HTML(ani.to_html5_video())
```

--------------------------------

### Initialize RSPlanner

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/tutorial/train_parking_demo.ipynb

Initializes the RSPlanner with vehicle parameters, lidar configuration, and sets up internal states for path planning.

```python
class RSPlanner:
    # use Reeds-Shepp curve to plan the collision-free path
    def __init__(self, vehicle, lidar_num, lidar_range=lidar_range) -> None:
        self.radius = vehicle.wheel_base / np.tan(vehicle.steer_range[1] * STEER_RATIO)  # TODO
        self.vehicle_box = vehicle.geometry
        self.lidar_num = lidar_num
        self.lidar_range = lidar_range
        # the minimum distance between the vehicle's bounding box and the rear wheel center
        self.vehicle_base = self.init_vehicle_base()
        self.center_shift = 0.5 * vehicle.length - vehicle.rear_overhang
        self.start_pos = [0, 0, 0]
        self.move_vehicle_center()
        self.distance_tolerance = 0.05  # the distance tolerance to the obstacles
        self.threshold_distance = (
            lidar_range - 5.0
        )  # the threshold of distance to the target to execute the rs path
        self.rs_planner = ReedsShepp(self.radius)
```

--------------------------------

### Initialize Tactics2D Environment

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/dataset_support/citysim.ipynb

Imports necessary libraries and initializes the dataset and map parsers.

```python
%matplotlib notebook

import os
import numpy as np
from matplotlib.animation import FuncAnimation
from shapely.geometry import Point
from IPython.display import HTML

from tactics2d.dataset_parser import CitySimParser
from tactics2d.map.parser import OSMParser
from tactics2d.sensor import BEVCamera
from tactics2d.renderer import MatplotlibRenderer
from tactics2d.map.element import Map
```

```python
dataset_path = "../../data/CitySim"  # Replace with your dataset path
dataset_parser = CitySimParser()
map_parser = OSMParser()
```

--------------------------------

### Call plot_map Function

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/dataset_support/nuplan.ipynb

Example calls to the plot_map function with different map files. The output indicates the figure size generated.

```python
plot_map(map_path, map_files[0])
```

```python
plot_map(map_path, map_files[1])
```

```python
plot_map(map_path, map_files[2])
```

```python
plot_map(map_path, map_files[3])
```

--------------------------------

### Initialize Data Analysis Environment

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/dataset_support/unid.ipynb

Imports necessary libraries for data manipulation and visualization.

```python
%matplotlib inline
import warnings

warnings.filterwarnings("ignore")

import pandas as pd
import polars as pl
import numpy as np
import matplotlib as mpl
import matplotlib.gridspec as gridspec
import matplotlib.pyplot as plt
import seaborn as sns
```

--------------------------------

### Visualize Reeds-Shepp Interpolator Paths

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/tutorial/interpolator_visualization.ipynb

Visualizes the paths generated by the Reeds-Shepp interpolator. It plots start and end points with their orientations and the interpolated paths between them.

```python
def visualize_RS():
    start_headings = np.arange(0.1, 2 * np.pi, 0.66)
    # start_headings = [0.1 + 0.66 * 1]
    start_points = np.vstack((np.cos(start_headings), np.sin(start_headings))).T * 15 + np.array(
        [7.5, 7.5]
    )
    end_point = np.array([7.5, 7.5])
    end_heading = np.pi / 2
    length = 4
    width = 1.8
    radius = 7.5

    my_RS = ReedsShepp(radius)

    fig, ax = plt.subplots(1, 1)

    ax.add_patch(
        mpatches.Polygon(
            get_bbox(end_point, length, width, end_heading), fill=True, color="gray", alpha=0.5
        )
    )

    for start_point, start_heading in zip(start_points, start_headings):
        ax.add_patch(
            mpatches.Polygon(
                get_bbox(start_point, length, width, start_heading),
                fill=True,
                color="pink",
                alpha=0.5,
            )
        )
        path = my_RS.get_curve(start_point, start_heading, end_point, end_heading)
        curve = path.curve
        # paths = my_RS.get_all_path(start_point, start_heading, end_point, end_heading)
        # for path in paths:
        #     if path is not None:
        #         curve = my_RS.get_curve_line(path, start_point, start_heading)
        #         ax.plot(curve[:, 0], curve[:, 1])
        #         print(path.actions, path.segments * radius, path.signs, path.length)
        ax.plot(curve[:, 0], curve[:, 1], "black")

    ax.set_aspect("equal")
    plt.show()
```

```python
visualize_RS()
```

--------------------------------

### Visualize Dubins Interpolator Paths

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/tutorial/interpolator_visualization.ipynb

Visualizes the paths generated by the Dubins interpolator. It plots start and end points with their orientations and the interpolated paths between them.

```python
def visualize_dubins():
    start_headings = np.arange(0.1, 2 * np.pi, 0.66)
    start_points = np.vstack((np.cos(start_headings), np.sin(start_headings))).T * 15 + np.array(
        [7.5, 7.5]
    )
    end_point = np.array([7.5, 7.5])
    end_heading = np.pi / 2
    length = 4
    width = 1.8
    radius = 7.5

    my_dubins = Dubins(radius)

    fig, ax = plt.subplots(1, 1)

    ax.add_patch(
        mpatches.Polygon(
            get_bbox(end_point, length, width, end_heading), fill=True, color="gray", alpha=0.5
        )
    )

    for start_point, start_heading in zip(start_points, start_headings):
        ax.add_patch(
            mpatches.Polygon(
                get_bbox(start_point, length, width, start_heading),
                fill=True,
                color="pink",
                alpha=0.5,
            )
        )
        path = my_dubins.get_curve(start_point, start_heading, end_point, end_heading)
        curve = path.curve
        ax.plot(curve[:, 0], curve[:, 1], "black")

    ax.set_aspect("equal")
    plt.show()
```

```python
visualize_dubins()
```

--------------------------------

### Configure and Initialize Parking Environment

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/tutorial/train_parking_demo.ipynb

Configures and initializes the ParkingEnv with specified parameters for parking lot type proportion, render mode, render FPS, and maximum steps per episode.

```python
# the proportion of the type of parking lot,
# 0 means all scenarios are parallel parking, 1 means all scenarios are vertical parking
type_proportion = 1.0
# the render mode, "rgb_array" means render the scene to a numpy array, "human" means render the scene to a window
render_mode = ["rgb_array", "human"][1]
render_fps = 50
# the max step of one episode
max_step = 1000
env = ParkingEnv(
    type_proportion=type_proportion,
    render_mode=render_mode,
    render_fps=render_fps,
    max_step=max_step,
)
```

--------------------------------

### Import necessary libraries for Tactics2D

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/dataset_support/ind.ipynb

Imports required modules for dataset parsing, map handling, sensor simulation, and visualization with Tactics2D. Ensure these libraries are installed.

```python
%matplotlib notebook

import os

import numpy as np
from matplotlib.animation import FuncAnimation
from shapely.geometry import Point
from IPython.display import HTML

from tactics2d.dataset_parser import LevelXParser
from tactics2d.map.parser import OSMParser
from tactics2d.map.map_config import IND_MAP_CONFIG
from tactics2d.sensor import BEVCamera
from tactics2d.renderer import MatplotlibRenderer
```

--------------------------------

### Run Specific Test Case with Pytest

Source: https://github.com/woodoxen/tactics2d/blob/master/README.md

Install pytest and use it to run a specific test function within a test file. Replace [test_file_name] and [test_function_name] with actual values.

```bash
pip install pytest
pytest tests/[test_file_name]::[test_function_name]
```

--------------------------------

### Download sample Argoverse dataset files

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/tutorial/dataset_visualization.ipynb

Downloads the necessary JSON and PARQUET files for a sample Argoverse scenario. These files are required for the subsequent demonstration.

```python
download_file(
    "https://raw.githubusercontent.com/SCP-CN-001/trajectory_dataset_support/main/trajectory_sample/Argoverse/train/0a0a2bb7-c4f4-44cd-958a-9ee15cb34aca/log_map_archive_0a0a2bb7-c4f4-44cd-958a-9ee15cb34aca.json",
    "log_map_archive_0a0a2bb7-c4f4-44cd-958a-9ee15cb34aca.json",
)

download_file(
    "https://raw.githubusercontent.com/SCP-CN-001/trajectory_dataset_support/main/trajectory_sample/Argoverse/train/0a0a2bb7-c4f4-44cd-958a-9ee15cb34aca/scenario_0a0a2bb7-c4f4-44cd-958a-9ee15cb34aca.parquet",
    "scenario_0a0a2bb7-c4f4-44cd-958a-9ee15cb34aca.parquet",
)
```

--------------------------------

### Import Dependencies for Data Analysis

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/dataset_support/nuplan.ipynb

Initializes the environment by appending the current directory to the path and importing necessary libraries for data manipulation and visualization.

```python
import os
import sys

sys.path.append(".")

import warnings

warnings.filterwarnings("ignore")

import logging

logging.basicConfig(level=logging.WARNING)

import geopandas as gpd
import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import sqlite3
import seaborn as sns
```

--------------------------------

### Get Reeds-Shepp Path

Source: https://github.com/woodoxen/tactics2d/blob/master/docs/tutorial/train_parking_demo.ipynb

Calculates a Reeds-Shepp path from the current vehicle state to a target destination, considering relative positions and headings. It filters paths based on distance to the target and potential collisions.

```python
def get_rs_path(self, info):
        start_x, start_y, start_yaw = self.start_pos
        dest_coords = np.mean(
            np.array(list(info["target_area"].geometry.exterior.coords)[:4]), axis=0
        )
        dest_heading = info["target_heading"]
        ego_pos = [info["state"].x, info["state"].y, info["state"].heading]
        # print("ego_pos", ego_pos)
        # print("dest_pos", dest_coords)
        if self.center_shift != 0:
            dest_coords[0] -= self.center_shift * np.cos(dest_heading)
            dest_coords[1] -= self.center_shift * np.sin(dest_heading)
            ego_pos[0] -= self.center_shift * np.cos(ego_pos[2])
            ego_pos[1] -= self.center_shift * np.sin(ego_pos[2])

        dest_pos = (dest_coords[0], dest_coords[1], dest_heading)
        self.dest_pos = dest_pos
        self.ego_pos = ego_pos
        rel_distance = np.sqrt((dest_pos[0] - ego_pos[0]) ** 2 + (dest_pos[1] - ego_pos[1]) ** 2)
        if rel_distance > self.threshold_distance:
            return None

        rel_angle = np.arctan2(dest_pos[1] - ego_pos[1], dest_pos[0] - ego_pos[0]) - ego_pos[2]
        rel_dest_heading = dest_pos[2] - ego_pos[2]
        goalX, goalY, goalYaw = (
            rel_distance * np.cos(rel_angle),
            rel_distance * np.sin(rel_angle),
            rel_dest_heading,
        )
        #  Find all possible reeds-shepp paths between current and goal node
        reedsSheppPaths = self.rs_planner.get_all_path(
            np.array([start_x, start_y]), start_yaw, np.array([goalX, goalY]), goalYaw
        )

        # Check if reedsSheppPaths is empty
        if not reedsSheppPaths:
            return None

        # Initialize an empty list to act as the priority queue
        costs = []
        # Create a dictionary to map paths to their lengths
        path_lengths = {}

        # Populate the priority queue and the path_lengths dictionary
        for i, path in enumerate(reedsSheppPaths):
            if path is None:
                continue
            heapq.heappush(costs, (path.length, i))  # Push tuple (length, index)
            path_lengths[i] = path.length  # Store path length in dictionary

        # Find the first collision-free path in the priority queue
        min_path_len = -1
        obstacles_params = self.construct_obstacles(info)
        while costs:
            # Pop the tuple with the minimum length
            _, index = heapq.heappop(costs)
            path = reedsSheppPaths[index]
            if min_path_len < 0:
                min_path_len = path.length
            if path.length > 2 * min_path_len:
                break

            path.get_curve_line(np.array([start_x, start_y]), start_yaw, self.radius, 0.1)
            # print(len(path.curve), path.length, len(path.yaw))
```
Tokens:
Raw