From 3f33f596c079b04cf7fddb63aa2c3ba503f42e6f Mon Sep 17 00:00:00 2001 From: Kieran Ratcliffe Date: Tue, 8 Aug 2023 16:13:15 -0700 Subject: [PATCH 01/19] Added suggested wording updates to BLAME documentation. --- invertedai/api/blame.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/invertedai/api/blame.py b/invertedai/api/blame.py index e4ff95d0..24ce4351 100644 --- a/invertedai/api/blame.py +++ b/invertedai/api/blame.py @@ -23,9 +23,9 @@ class BlameResponse(BaseModel): Response returned from an API call to :func:`iai.blame`. """ agents_at_fault: Optional[Tuple[int, ...]] #: A tuple containing all agents predicted to be at fault. If empty, the model has predicated no agents are at fault. - reasons: Optional[Dict[int, List[str]]] #: A dictionary with agent IDs as keys and a list of fault class strings for why the keyed agent is to blame. - confidence_score: Optional[float] #: Float value between [0,1] indicating the models confidence in the response. - birdviews: Optional[List[Image]] #: If `get_birdviews` was set, this contains the resulting image. + reasons: Optional[Dict[int, List[str]]] #: A dictionary with agent IDs as keys corresponding to "agents_at_fault" paired with a list of reasons why the keyed agent is at fault. + confidence_score: Optional[float] #: Float value between [0,1] indicating BLAME's confidence in the response where 0.0 represents the minimum confidence and 1.0 represents maximum confidence. + birdviews: Optional[List[Image]] #: If `get_birdviews` was set, this contains the resulting images. @validate_arguments def blame( @@ -56,7 +56,7 @@ def blame( and no time steps afterwards. The lists of AgentState objects preceding the collision should capture enough of the scenario context before the collision for the Blame model to analyze and assign fault. For best results it is recommended to - input 30-100 time steps of 0.1s each preceding the collision. + input 20-50 time steps of 0.1s each preceding the collision. Each AgentState state must include x: [float], y: [float] coordinates in meters, orientation: [float] in radians with 0 pointing along the positive x axis and pi/2 pointing along the positive y axis, and speed: [float] in m/s. @@ -74,10 +74,10 @@ def blame( Whether to return the reasons regarding why each agent was blamed. get_confidence_score: - Whether to return how confident the Blame model is in its response. + Whether to return how confident the BLAME is in its response. get_birdviews: - Whether to return images visualizing the collision case.This is very slow and + Whether to return images visualizing the collision case. This is very slow and should only be used for debugging. See Also From d15c25a26a879620c0d4557c773704ced2ebfa5d Mon Sep 17 00:00:00 2001 From: Kieran Ratcliffe Date: Fri, 11 Aug 2023 13:40:20 -0700 Subject: [PATCH 02/19] Added the ability to specify face and edge colours for all agents in scene plotter. --- invertedai/utils.py | 47 +++++++++++++++++++++++++++++++++++++++------ 1 file changed, 41 insertions(+), 6 deletions(-) diff --git a/invertedai/utils.py b/invertedai/utils.py index a834ce31..cfd13457 100644 --- a/invertedai/utils.py +++ b/invertedai/utils.py @@ -675,6 +675,9 @@ def __init__(self, map_image=None, fov=None, xy_offset=None, static_actors=None, self.numbers = False + self.agent_face_colors = None + self.agent_edge_colors = None + def initialize_recording(self, agent_states, agent_attributes, traffic_light_states=None, conditional_agents=None): self.agent_states_history = [agent_states] self.traffic_lights_history = [traffic_light_states] @@ -689,6 +692,8 @@ def reset_recording(self): self.traffic_lights_history = [] self.agent_attributes = None self.conditional_agents = [] + self.agent_face_colors = None #: Optional[Optional[Tuple[float,float,float]]] representing R,G,B values for each agent's main color between [0,1] or None if using the default + self.agent_edge_colors = None #: Optional[Optional[Tuple[float,float,float]]] representing R,G,B values for each agent's border color between [0,1] or None if using the default def record_step(self, agent_states, traffic_light_states=None): self.agent_states_history.append(agent_states) @@ -713,7 +718,17 @@ def plot_frame(self, idx, ax=None, numbers=False, direction_vec=False, def animate_scene(self, output_name=None, start_idx=0, end_idx=-1, ax=None, numbers=False, direction_vec=True, velocity_vec=False, - plot_frame_number=False): + plot_frame_number=False, agent_face_colors=None, + agent_edge_colors=None): + + if (agent_face_colors and self.agent_attributes) and (len(agent_face_colors) != len(self.agent_attributes)): + raise Exception("Number of agent colors does not match number of agents.") + if (agent_edge_colors and self.agent_attributes) and (len(agent_edge_colors) != len(self.agent_attributes)): + raise Exception("Number of agent colors does not match number of agents.") + + self.agent_face_colors = agent_face_colors + self.agent_edge_colors = agent_edge_colors + self._initialize_plot(ax=ax, numbers=numbers, direction_vec=direction_vec, velocity_vec=velocity_vec, plot_frame_number=plot_frame_number) end_idx = len(self.agent_states_history) if end_idx == -1 else end_idx @@ -758,6 +773,19 @@ def _initialize_plot(self, ax=None, numbers=False, direction_vec=True, self._update_frame_to(0) + def _get_color(self,agent_idx,color_list): + c = None + if color_list and color_list[agent_idx]: + is_good_color_format = isinstance(color_list[agent_idx],tuple) + for pc in color_list[agent_idx]: + is_good_color_format *= isinstance(pc,float) and (0.0 <= pc <= 1.0) + + if not is_good_color_format: + raise Exception(f"Expected color format is Tuple[float,float,float] with 0 <= float <= 1 but received {color_list[agent_idx]}.") + c = color_list[agent_idx] + + return c + def _update_frame_to(self, frame_idx): for i, (agent, agent_attribute) in enumerate(zip(self.agent_states_history[frame_idx], self.agent_attributes)): self._update_agent(i, agent, agent_attribute) @@ -812,13 +840,20 @@ def _update_agent(self, agent_idx, agent, agent_attribute): self.box_labels[agent_idx].set_x(x) self.box_labels[agent_idx].set_y(y) - if agent_idx in self.conditional_agents: - c = self.cond_c - else: - c = self.agent_c + lw = 1 + fc = self._get_color(agent_idx,self.agent_face_colors) + if not fc: + if agent_idx in self.conditional_agents: + fc = self.cond_c + else: + fc = self.agent_c + ec = self._get_color(agent_idx,self.agent_edge_colors) + if not ec: + lw = 0 + ec = fc rect = Rectangle((x - l / 2, y - w / 2), l, w, angle=psi * - 180 / np.pi, rotation_point='center', fc=c, lw=0) + 180 / np.pi, rotation_point='center', fc=fc, ec=ec, lw=lw) if agent_idx in self.actor_boxes: self.actor_boxes[agent_idx].remove() self.actor_boxes[agent_idx] = rect From acb9f6b44a8dcca5038f3f71967726cdc59f16bc Mon Sep 17 00:00:00 2001 From: Kieran Ratcliffe Date: Fri, 11 Aug 2023 13:52:12 -0700 Subject: [PATCH 03/19] Revert "Added suggested wording updates to BLAME documentation." This reverts commit 3f33f596c079b04cf7fddb63aa2c3ba503f42e6f. --- invertedai/api/blame.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/invertedai/api/blame.py b/invertedai/api/blame.py index 24ce4351..e4ff95d0 100644 --- a/invertedai/api/blame.py +++ b/invertedai/api/blame.py @@ -23,9 +23,9 @@ class BlameResponse(BaseModel): Response returned from an API call to :func:`iai.blame`. """ agents_at_fault: Optional[Tuple[int, ...]] #: A tuple containing all agents predicted to be at fault. If empty, the model has predicated no agents are at fault. - reasons: Optional[Dict[int, List[str]]] #: A dictionary with agent IDs as keys corresponding to "agents_at_fault" paired with a list of reasons why the keyed agent is at fault. - confidence_score: Optional[float] #: Float value between [0,1] indicating BLAME's confidence in the response where 0.0 represents the minimum confidence and 1.0 represents maximum confidence. - birdviews: Optional[List[Image]] #: If `get_birdviews` was set, this contains the resulting images. + reasons: Optional[Dict[int, List[str]]] #: A dictionary with agent IDs as keys and a list of fault class strings for why the keyed agent is to blame. + confidence_score: Optional[float] #: Float value between [0,1] indicating the models confidence in the response. + birdviews: Optional[List[Image]] #: If `get_birdviews` was set, this contains the resulting image. @validate_arguments def blame( @@ -56,7 +56,7 @@ def blame( and no time steps afterwards. The lists of AgentState objects preceding the collision should capture enough of the scenario context before the collision for the Blame model to analyze and assign fault. For best results it is recommended to - input 20-50 time steps of 0.1s each preceding the collision. + input 30-100 time steps of 0.1s each preceding the collision. Each AgentState state must include x: [float], y: [float] coordinates in meters, orientation: [float] in radians with 0 pointing along the positive x axis and pi/2 pointing along the positive y axis, and speed: [float] in m/s. @@ -74,10 +74,10 @@ def blame( Whether to return the reasons regarding why each agent was blamed. get_confidence_score: - Whether to return how confident the BLAME is in its response. + Whether to return how confident the Blame model is in its response. get_birdviews: - Whether to return images visualizing the collision case. This is very slow and + Whether to return images visualizing the collision case.This is very slow and should only be used for debugging. See Also From a90305a268a0b60d4905e7a3f57e3b541d9557cf Mon Sep 17 00:00:00 2001 From: Kieran Ratcliffe Date: Tue, 15 Aug 2023 14:56:00 -0700 Subject: [PATCH 04/19] Add docstrings to public methods of ScenePlotter and parameter validation. --- invertedai/utils.py | 235 +++++++++++++++++++++++++++++++++++++------- 1 file changed, 199 insertions(+), 36 deletions(-) diff --git a/invertedai/utils.py b/invertedai/utils.py index cfd13457..089d3681 100644 --- a/invertedai/utils.py +++ b/invertedai/utils.py @@ -2,7 +2,7 @@ import asyncio import json import re -from typing import Dict, Optional +from typing import Dict, Optional, List, Tuple, Any from requests.auth import AuthBase from requests.adapters import HTTPAdapter, Retry import invertedai as iai @@ -13,16 +13,18 @@ import logging import matplotlib.pyplot as plt from matplotlib.patches import Rectangle -from matplotlib import animation +from matplotlib.animation import FuncAnimation +from matplotlib.axes import Axes import numpy as np import csv import math from tqdm.contrib import tmap from itertools import product -from invertedai.common import AgentState, StaticMapActor +from invertedai.common import AgentState, AgentAttributes, TrafficLightState, StaticMapActor, Image from matplotlib import transforms from copy import deepcopy from invertedai.future import to_thread +from pydantic import validate_arguments, BaseModel, ConfigDict H_SCALE = 10 text_x_offset = 0 @@ -630,9 +632,43 @@ def rot(rot): [np.sin(rot), np.cos(rot)]]) -class ScenePlotter: - def __init__(self, map_image=None, fov=None, xy_offset=None, static_actors=None, - open_drive=None, resolution=(640, 480), dpi=100): + +class ScenePlotter(): + """ + A class providing features and handling the data regarding visualization of a scene involving IAI data. + """ + model_config = ConfigDict(arbitrary_types_allowed=True) + + @validate_arguments + def __init__( + self, + map_image: Optional[Any] = None, + fov: float = 100, + xy_offset: Optional[Tuple[int,int]] = None, + static_actors: Optional[List[StaticMapActor]] = None, + open_drive: bool = False, + resolution: Tuple[int,int] = (640, 480), + dpi: float = 100 + ): + """ + Arguments + ---------- + map_image: Image + Base image onto which the scene is visualized. It is recommended to acquire this information from the relevant LocationReponse object for the scene. + fov: float + The field of view in meters corresponding to the map_image attribute. It is recommended to acquire this information from the relevant LocationReponse object for the scene. + xy_offset: Optional[Tuple[int,int]] = None + The left-hand offset for the center of the map image. It is recommended to acquire this information from the relevant LocationReponse object for the scene. + static_actors: Optional[List[StaticMapActor]] = None + A list of static actor agents (e.g. traffic lights) represented as StaticMapActor objects, in the scene. It is recommended to acquire this information from the relevant LocationReponse object for the scene. + open_drive: bool = False + A flag dictating whether the map is in the ASAM OpenDRIVE format (i.e. xodr maps) + resolution: Tuple[int,int] = (640, 480) + The desired resolution of the map image expressed as a Tuple with two integers for the width and height respectively. + dpi: float = 100 + Dots per inch to define the level of detail in the image. + """ + self.conditional_agents = None self.agent_attributes = None self.traffic_lights_history = None @@ -675,10 +711,32 @@ def __init__(self, map_image=None, fov=None, xy_offset=None, static_actors=None, self.numbers = False - self.agent_face_colors = None - self.agent_edge_colors = None + self.agent_face_colors = None + self.agent_edge_colors = None + + @validate_arguments + def initialize_recording( + self, + agent_states: List[AgentState], + agent_attributes: List[AgentAttributes], + traffic_light_states: Optional[Dict[int, TrafficLightState]] = None, + conditional_agents: Optional[List[int]] = None + ): + """ + Record the initial state of the scene to be visualized. This function also acts as an implicit reset of the recording and removes previous agent state, agent attribute, conditional agent, traffic light, and agent style data. + + Arguments + ---------- + agent_states: List[AgentState] + A list of AgentState objects corresponding to the initial time step to be visualized. + agent_attributes: List[AgentState] + Static attributes of the agent, which don’t change over the course of a simulation. We assume every agent is a rectangle obeying a kinematic bicycle model. + traffic_light_states: Optional[Dict[int, TrafficLightState]] + Optional parameter containing the state of the traffic lights corresponding to the initial time step to be visualized. This parameter should only be used if the corresponding map contains traffic light static actors. + conditional_agents: List[int] + Optional parameter containing a list of agent IDs corresponding to conditional agents to be visualized to distinguish themselves. + """ - def initialize_recording(self, agent_states, agent_attributes, traffic_light_states=None, conditional_agents=None): self.agent_states_history = [agent_states] self.traffic_lights_history = [traffic_light_states] self.agent_attributes = agent_attributes @@ -687,47 +745,134 @@ def initialize_recording(self, agent_states, agent_attributes, traffic_light_sta else: self.conditional_agents = [] + self.agent_face_colors = None + self.agent_edge_colors = None + def reset_recording(self): + """ + Explicitly reset the recording and remove the previous agent state, agent attribute, conditional agent, traffic light, and agent style data. + """ self.agent_states_history = [] self.traffic_lights_history = [] self.agent_attributes = None self.conditional_agents = [] - self.agent_face_colors = None #: Optional[Optional[Tuple[float,float,float]]] representing R,G,B values for each agent's main color between [0,1] or None if using the default - self.agent_edge_colors = None #: Optional[Optional[Tuple[float,float,float]]] representing R,G,B values for each agent's border color between [0,1] or None if using the default + self.agent_face_colors = None + self.agent_edge_colors = None + + @validate_arguments + def record_step( + self, + agent_states: List[AgentState], + traffic_light_states: Optional[Dict[int, TrafficLightState]] = None + ): + """ + Record a single timestep of scene data to be used in a visualization + + Arguments + ---------- + agent_states: List[AgentState] + A list of AgentState objects corresponding to the initial time step to be visualized. + traffic_light_states: Optional[Dict[int, TrafficLightState]] + Optional parameter containing the state of the traffic lights corresponding to the initial time step to be visualized. This parameter should only be used if the corresponding map contains traffic light static actors. + """ - def record_step(self, agent_states, traffic_light_states=None): self.agent_states_history.append(agent_states) self.traffic_lights_history.append(traffic_light_states) - def plot_scene(self, agent_states, agent_attributes, traffic_light_states=None, conditional_agents=None, - ax=None, numbers=False, direction_vec=True, velocity_vec=False): + @validate_arguments + def plot_scene( + self, + agent_states: List[AgentState], + agent_attributes: List[AgentAttributes], + traffic_light_states: Optional[Dict[int, TrafficLightState]] = None, + conditional_agents: Optional[List[int]] = None, + ax: Optional[Any] = None, + numbers: bool = False, + direction_vec: bool = True, + velocity_vec: bool = False, + agent_face_colors: Optional[List[Optional[Tuple[float,float,float]]]] = None, + agent_edge_colors: Optional[List[Optional[Tuple[float,float,float]]]] = None + ): + """ + A standalone scene plotting function that initializes and resets a recording. It is assumed this function will be used not while recording steps for a full animation. + + Parameters + ---------- + agent_states: List[AgentState] + A list of agents to be visualized in the image. + agent_attributes: List[AgentState] + Static attributes of the agent, which don’t change over the course of a simulation. We assume every agent is a rectangle obeying a kinematic bicycle model. + traffic_light_states: Optional[Dict[int, TrafficLightState]] + Optional parameter containing the state of the traffic lights to be visualized in the image. This parameter should only be used if the corresponding map contains traffic light static actors. + conditional_agents: List[int] + Optional parameter containing a list of agent IDs of conditional agents to be visualized in the image to distinguish themselves. + ax: Optional[Axes] = None + A matplotlib Axes object used to plot the image. By default, an Axes object is created if a value of None is passed. + numbers: bool = False + Flag to determine if the ID's of all agents should be plotted in the image. By default this flag is set to False. + direction_vec: bool = True + Flag to determine if a vector showing the vehicles direction should be plotted in the image. By default this flag is set to True. + velocity_vec: bool = False + Flag to determine if the a vector showing the vehicles velocity should be plotted in the animation. By default this flag is set to False. + agent_face_colors: Optional[List[Tuple[float,float,float]]] = None + An optional parameter containing a list of either RGB tuples indicating the desired color of the agent with the corresponding index ID. A value of None in this list will use the default color. This value gets overwritten by the conditional agent color. + agent_edge_colors: Optional[List[Tuple[float,float,float]]] = None + An optional parameter containing a list of either RGB tuples indicating the desired color of a border around the agent with the corresponding index ID. A value of None in this list will use the default color. This value gets overwritten by the conditional agent color. + + """ self.initialize_recording(agent_states, agent_attributes, traffic_light_states=traffic_light_states, conditional_agents=conditional_agents) - self.plot_frame(idx=0, ax=ax, numbers=numbers, direction_vec=direction_vec, + self._validate_agent_style_data(agent_face_colors,agent_edge_colors) + + self._plot_frame(idx=0, ax=ax, numbers=numbers, direction_vec=direction_vec, velocity_vec=velocity_vec, plot_frame_number=False) self.reset_recording() - def plot_frame(self, idx, ax=None, numbers=False, direction_vec=False, - velocity_vec=False, plot_frame_number=False): - self._initialize_plot(ax=ax, numbers=numbers, direction_vec=direction_vec, - velocity_vec=velocity_vec, plot_frame_number=plot_frame_number) - self._update_frame_to(idx) - - def animate_scene(self, output_name=None, start_idx=0, end_idx=-1, ax=None, - numbers=False, direction_vec=True, velocity_vec=False, - plot_frame_number=False, agent_face_colors=None, - agent_edge_colors=None): - - if (agent_face_colors and self.agent_attributes) and (len(agent_face_colors) != len(self.agent_attributes)): - raise Exception("Number of agent colors does not match number of agents.") - if (agent_edge_colors and self.agent_attributes) and (len(agent_edge_colors) != len(self.agent_attributes)): - raise Exception("Number of agent colors does not match number of agents.") + @validate_arguments + def animate_scene( + self, + output_name: Optional[str] = None, + start_idx: int = 0, + end_idx: int = -1, + ax: Optional[Any] = None, + numbers: bool = False, + direction_vec: bool = True, + velocity_vec: bool = False, + plot_frame_number: bool = False, + agent_face_colors: Optional[List[Optional[Tuple[float,float,float]]]] = None, + agent_edge_colors: Optional[List[Optional[Tuple[float,float,float]]]] = None + ) -> FuncAnimation: + """ + Produce an animation of the sequentially recorded steps. A matplotlib animation object can be returned and/or a gif saved of the scene. + + Parameters + ---------- + output_name: Optional[str] = None + File name of the gif to which the animation will be saved. + start_idx: int = 0 + The index of the time step from which the animation will begin. By default it is assumed all recorded steps are desired to be animated. + end_idx: int = 0 + The index of the time step from which the animation will end. By default it is assumed all recorded steps are desired to be animated. + ax: Optional[Axes] = None + A matplotlib Axes object used to plot the animation. By default, an Axes object is created if a value of None is passed. + numbers: bool = False + Flag to determine if the ID's of all agents should be plotted in the animation. By default this flag is set to False. + direction_vec: bool = True + Flag to determine if a vector showing the vehicles direction should be plotted in the animation. By default this flag is set to True. + velocity_vec: bool = False + Flag to determine if the a vector showing the vehicles velocity should be plotted in the animation. By default this flag is set to False. + plot_frame_number: bool = False + Flag to determine if the frame numbers should be plotted in the animation. By default this flag is set to False. + agent_face_colors: Optional[List[Tuple[float,float,float]]] = None + An optional parameter containing a list of either RGB tuples indicating the desired color of the agent with the corresponding index ID. A value of None in this list will use the default color. This value gets overwritten by the conditional agent color. + agent_edge_colors: Optional[List[Tuple[float,float,float]]] = None + An optional parameter containing a list of either RGB tuples indicating the desired color of a border around the agent with the corresponding index ID. A value of None in this list will use the default color. This value gets overwritten by the conditional agent color. + """ - self.agent_face_colors = agent_face_colors - self.agent_edge_colors = agent_edge_colors + self._validate_agent_style_data(agent_face_colors,agent_edge_colors) self._initialize_plot(ax=ax, numbers=numbers, direction_vec=direction_vec, velocity_vec=velocity_vec, plot_frame_number=plot_frame_number) @@ -738,12 +883,30 @@ def animate_scene(self, output_name=None, start_idx=0, end_idx=-1, ax=None, def animate(i): self._update_frame_to(i) - ani = animation.FuncAnimation( + ani = FuncAnimation( fig, animate, np.arange(start_idx, end_idx), interval=100) if output_name is not None: ani.save(f'{output_name}', writer='pillow', dpi=self.dpi) return ani + def _plot_frame(self, idx, ax=None, numbers=False, direction_vec=False, + velocity_vec=False, plot_frame_number=False): + self._initialize_plot(ax=ax, numbers=numbers, direction_vec=direction_vec, + velocity_vec=velocity_vec, plot_frame_number=plot_frame_number) + self._update_frame_to(idx) + + def _validate_agent_style_data(self,agent_face_colors,agent_edge_colors): + if self.agent_attributes is not None: + if agent_face_colors is not None: + if len(agent_face_colors) != len(self.agent_attributes): + raise Exception("Number of agent face colors does not match number of agents.") + if agent_edge_colors is not None: + if len(agent_edge_colors) != len(self.agent_attributes): + raise Exception("Number of agent edge colors does not match number of agents.") + + self.agent_face_colors = agent_face_colors + self.agent_edge_colors = agent_edge_colors + def _initialize_plot(self, ax=None, numbers=False, direction_vec=True, velocity_vec=False, plot_frame_number=False): if ax is None: @@ -752,7 +915,7 @@ def _initialize_plot(self, ax=None, numbers=False, direction_vec=True, if not self.open_drive: ax.imshow(self.map_image, extent=self.extent) else: - self._draw_xord_map(ax) + self._draw_xodr_map(ax) self.extent = (self.map_center[0] - self.fov / 2, self.map_center[0] + self.fov / 2) +\ (self.map_center[1] - self.fov / 2, self.map_center[1] + self.fov / 2) ax.set_xlim((self.extent[0], self.extent[1])) @@ -874,10 +1037,10 @@ def _plot_traffic_light(self, light_id, light_state): self.current_ax.add_patch(rect) self.traffic_light_boxes[light_id] = rect - def _draw_xord_map(self, ax, extras=False): + def _draw_xodr_map(self, ax, extras=False): """ This function plots the parsed xodr map - the `odrplot` of `esmini` is used for plotting and parsing xord + the `odrplot` of `esmini` is used for plotting and parsing xodr https: // esmini.github.io/ # _tools_overview """ with open(self.open_drive) as f: From 4e4bcc0348e22d029e89c7351f8653b4678debef Mon Sep 17 00:00:00 2001 From: Kieran Ratcliffe Date: Tue, 15 Aug 2023 16:47:15 -0700 Subject: [PATCH 05/19] Added OpenDRIVE map variables as kwargs to ScenePlotter. --- invertedai/utils.py | 71 +++++++++++++++++++++++++++++++-------------- 1 file changed, 49 insertions(+), 22 deletions(-) diff --git a/invertedai/utils.py b/invertedai/utils.py index 089d3681..0caf2500 100644 --- a/invertedai/utils.py +++ b/invertedai/utils.py @@ -21,6 +21,7 @@ from tqdm.contrib import tmap from itertools import product from invertedai.common import AgentState, AgentAttributes, TrafficLightState, StaticMapActor, Image +from invertedai.light import LocationResponse from matplotlib import transforms from copy import deepcopy from invertedai.future import to_thread @@ -642,38 +643,59 @@ class ScenePlotter(): @validate_arguments def __init__( self, - map_image: Optional[Any] = None, - fov: float = 100, - xy_offset: Optional[Tuple[int,int]] = None, - static_actors: Optional[List[StaticMapActor]] = None, + location_response: Optional[LocationResponse] = None, open_drive: bool = False, resolution: Tuple[int,int] = (640, 480), - dpi: float = 100 + dpi: float = 100, + **kwargs ): """ Arguments ---------- - map_image: Image - Base image onto which the scene is visualized. It is recommended to acquire this information from the relevant LocationReponse object for the scene. - fov: float - The field of view in meters corresponding to the map_image attribute. It is recommended to acquire this information from the relevant LocationReponse object for the scene. - xy_offset: Optional[Tuple[int,int]] = None - The left-hand offset for the center of the map image. It is recommended to acquire this information from the relevant LocationReponse object for the scene. - static_actors: Optional[List[StaticMapActor]] = None - A list of static actor agents (e.g. traffic lights) represented as StaticMapActor objects, in the scene. It is recommended to acquire this information from the relevant LocationReponse object for the scene. + location_response: Optional[LocationResponse] = None + A LocationResponse object taken from calling iai.light() containing relevant data regarding the location of the scene including the map image. open_drive: bool = False A flag dictating whether the map is in the ASAM OpenDRIVE format (i.e. xodr maps) resolution: Tuple[int,int] = (640, 480) The desired resolution of the map image expressed as a Tuple with two integers for the width and height respectively. dpi: float = 100 Dots per inch to define the level of detail in the image. + + Keyword Arguments + ----------------- + map_image: [np.ndarray] + Base image onto which the scene is visualized. Only use this argument if not using the respective information from the relevant LocationReponse object. + fov: float + The field of view in meters corresponding to the map_image attribute. Only use this argument if not using the respective information from the relevant LocationReponse object. + xy_offset: Optional[Tuple[int,int]] = None + The left-hand offset for the center of the map image. Only use this argument if not using the respective information from the relevant LocationReponse object. + static_actors: Optional[List[StaticMapActor]] = None + A list of static actor agents (e.g. traffic lights) represented as StaticMapActor objects, in the scene. Only use this argument if not using the respective information from the relevant LocationReponse object. + + """ self.conditional_agents = None self.agent_attributes = None self.traffic_lights_history = None self.agent_states_history = None + self.open_drive = open_drive + + if not self.open_drive + self.map_image = location_response.birdview_image.decode() + self.fov = location_response.map_fov + self.xy_offset = (location_response.map_center.x, location_response.map_center.y) + static_actor = location_response.static_actors + else: + self._validate_kwargs("map_image") + self._validate_kwargs("fov") + self._validate_kwargs("xy_offset") + self._validate_kwargs("static_actor") + + self.traffic_lights = {static_actor.actor_id: static_actor for static_actor in static_actors if static_actor.agent_type == 'traffic-light'} + + self.dpi = dpi self.resolution = resolution self.fov = fov @@ -684,9 +706,7 @@ def __init__( else: self.map_center = xy_offset - self.traffic_lights = {static_actor.actor_id: static_actor - for static_actor in static_actors - if static_actor.agent_type == 'traffic-light'} + self.traffic_light_colors = { 'red': (1.0, 0.0, 0.0), @@ -707,13 +727,13 @@ def __init__( self.frame_label = None self.current_ax = None - self.reset_recording() - self.numbers = False self.agent_face_colors = None self.agent_edge_colors = None + self.reset_recording() + @validate_arguments def initialize_recording( self, @@ -779,14 +799,14 @@ def record_step( self.agent_states_history.append(agent_states) self.traffic_lights_history.append(traffic_light_states) - @validate_arguments + @validate_arguments(config=dict(arbitrary_types_allowed=True)) def plot_scene( self, agent_states: List[AgentState], agent_attributes: List[AgentAttributes], traffic_light_states: Optional[Dict[int, TrafficLightState]] = None, conditional_agents: Optional[List[int]] = None, - ax: Optional[Any] = None, + ax: Optional[Axes] = None, numbers: bool = False, direction_vec: bool = True, velocity_vec: bool = False, @@ -831,13 +851,13 @@ def plot_scene( self.reset_recording() - @validate_arguments + @validate_arguments(config=dict(arbitrary_types_allowed=True)) def animate_scene( self, output_name: Optional[str] = None, start_idx: int = 0, end_idx: int = -1, - ax: Optional[Any] = None, + ax: Optional[Axes] = None, numbers: bool = False, direction_vec: bool = True, velocity_vec: bool = False, @@ -889,6 +909,13 @@ def animate(i): ani.save(f'{output_name}', writer='pillow', dpi=self.dpi) return ani + def _validate_kwargs(self,arg_name): + if arg_name in kwargs: + setattr(self,kwargs["map_image"]) + else: + raise Exception("Expected keyword argument 'map_image' but none was given.") + + def _plot_frame(self, idx, ax=None, numbers=False, direction_vec=False, velocity_vec=False, plot_frame_number=False): self._initialize_plot(ax=ax, numbers=numbers, direction_vec=direction_vec, From ec75d3eef45ad1b3a5f29d4208c85157fb2d25bc Mon Sep 17 00:00:00 2001 From: Kieran Ratcliffe Date: Tue, 15 Aug 2023 16:48:16 -0700 Subject: [PATCH 06/19] Fixed name error in kwarg validation. --- invertedai/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/invertedai/utils.py b/invertedai/utils.py index 0caf2500..9a44f671 100644 --- a/invertedai/utils.py +++ b/invertedai/utils.py @@ -911,7 +911,7 @@ def animate(i): def _validate_kwargs(self,arg_name): if arg_name in kwargs: - setattr(self,kwargs["map_image"]) + setattr(self,kwargs[arg_name]) else: raise Exception("Expected keyword argument 'map_image' but none was given.") From 688e9778c755a07a03e4c76dcf9b86b77d54594b Mon Sep 17 00:00:00 2001 From: Kieran Ratcliffe Date: Wed, 23 Aug 2023 11:55:52 -0700 Subject: [PATCH 07/19] Updated documentation and fixed data validation including open_drive maps. --- invertedai/utils.py | 121 ++++++++++++++++++++------------------------ 1 file changed, 56 insertions(+), 65 deletions(-) diff --git a/invertedai/utils.py b/invertedai/utils.py index 9a44f671..d117ed89 100644 --- a/invertedai/utils.py +++ b/invertedai/utils.py @@ -2,30 +2,32 @@ import asyncio import json import re +import logging from typing import Dict, Optional, List, Tuple, Any from requests.auth import AuthBase from requests.adapters import HTTPAdapter, Retry +from pydantic import validate_arguments, BaseModel, ConfigDict + import invertedai as iai import invertedai.api import invertedai.api.config +from invertedai.common import AgentState, AgentAttributes, TrafficLightState, StaticMapActor, Image, Point +from invertedai.api.location import LocationResponse from invertedai import error -from invertedai.common import Point -import logging +from invertedai.future import to_thread + import matplotlib.pyplot as plt from matplotlib.patches import Rectangle from matplotlib.animation import FuncAnimation from matplotlib.axes import Axes +from matplotlib import transforms +from tqdm.contrib import tmap +from itertools import product + import numpy as np import csv import math -from tqdm.contrib import tmap -from itertools import product -from invertedai.common import AgentState, AgentAttributes, TrafficLightState, StaticMapActor, Image -from invertedai.light import LocationResponse -from matplotlib import transforms from copy import deepcopy -from invertedai.future import to_thread -from pydantic import validate_arguments, BaseModel, ConfigDict H_SCALE = 10 text_x_offset = 0 @@ -636,15 +638,13 @@ def rot(rot): class ScenePlotter(): """ - A class providing features and handling the data regarding visualization of a scene involving IAI data. + A class providing features for handling the data regarding visualization of a scene involving IAI data. """ - model_config = ConfigDict(arbitrary_types_allowed=True) - @validate_arguments def __init__( self, location_response: Optional[LocationResponse] = None, - open_drive: bool = False, + open_drive: Optional[str] = None, resolution: Tuple[int,int] = (640, 480), dpi: float = 100, **kwargs @@ -653,9 +653,9 @@ def __init__( Arguments ---------- location_response: Optional[LocationResponse] = None - A LocationResponse object taken from calling iai.light() containing relevant data regarding the location of the scene including the map image. - open_drive: bool = False - A flag dictating whether the map is in the ASAM OpenDRIVE format (i.e. xodr maps) + A LocationResponse object taken from calling iai.location_info() containing relevant data regarding the location of the scene including the map image. + open_drive: Optional[str] = None + If using an ASAM OpenDRIVE format map for visualization, this string parameter is used to indicate the path to the corresponding CSV file. resolution: Tuple[int,int] = (640, 480) The desired resolution of the map image expressed as a Tuple with two integers for the width and height respectively. dpi: float = 100 @@ -664,15 +664,13 @@ def __init__( Keyword Arguments ----------------- map_image: [np.ndarray] - Base image onto which the scene is visualized. Only use this argument if not using the respective information from the relevant LocationReponse object. + Base image onto which the scene is visualized. This parameter must be provided if using an ASAM OpenDRIVE format map. fov: float - The field of view in meters corresponding to the map_image attribute. Only use this argument if not using the respective information from the relevant LocationReponse object. + The field of view in meters corresponding to the map_image attribute. This parameter must be provided if using an ASAM OpenDRIVE format map. xy_offset: Optional[Tuple[int,int]] = None - The left-hand offset for the center of the map image. Only use this argument if not using the respective information from the relevant LocationReponse object. + The left-hand offset for the center of the map image. This parameter must be provided if using an ASAM OpenDRIVE format map. static_actors: Optional[List[StaticMapActor]] = None - A list of static actor agents (e.g. traffic lights) represented as StaticMapActor objects, in the scene. Only use this argument if not using the respective information from the relevant LocationReponse object. - - + A list of static actor agents (e.g. traffic lights) represented as StaticMapActor objects, in the scene. This parameter must be provided if using an ASAM OpenDRIVE format map. """ self.conditional_agents = None @@ -680,33 +678,26 @@ def __init__( self.traffic_lights_history = None self.agent_states_history = None - self.open_drive = open_drive + self._open_drive = open_drive + self._dpi = dpi + self._resolution = resolution - if not self.open_drive + if self._open_drive is None: self.map_image = location_response.birdview_image.decode() self.fov = location_response.map_fov self.xy_offset = (location_response.map_center.x, location_response.map_center.y) - static_actor = location_response.static_actors + self.static_actors = location_response.static_actors else: - self._validate_kwargs("map_image") - self._validate_kwargs("fov") - self._validate_kwargs("xy_offset") - self._validate_kwargs("static_actor") - - self.traffic_lights = {static_actor.actor_id: static_actor for static_actor in static_actors if static_actor.agent_type == 'traffic-light'} - + self._validate_kwargs("map_image",kwargs) + self._validate_kwargs("fov",kwargs) + self._validate_kwargs("xy_offset",kwargs) + self._validate_kwargs("static_actors",kwargs) - self.dpi = dpi - self.resolution = resolution - self.fov = fov - self.map_image = map_image - if not open_drive: - self.extent = (- self.fov / 2 + xy_offset[0], self.fov / 2 + xy_offset[0]) + \ - (- self.fov / 2 + xy_offset[1], self.fov / 2 + xy_offset[1]) - else: - self.map_center = xy_offset + self.traffic_lights = {static_actor.actor_id: static_actor for static_actor in self.static_actors if static_actor.agent_type == 'traffic-light'} - + if self._open_drive is None: + self.extent = (- self.fov / 2 + self.xy_offset[0], self.fov / 2 + self.xy_offset[0]) + \ + (- self.fov / 2 + self.xy_offset[1], self.fov / 2 + self.xy_offset[1]) self.traffic_light_colors = { 'red': (1.0, 0.0, 0.0), @@ -749,11 +740,11 @@ def initialize_recording( ---------- agent_states: List[AgentState] A list of AgentState objects corresponding to the initial time step to be visualized. - agent_attributes: List[AgentState] + agent_attributes: List[AgentAttributes] Static attributes of the agent, which don’t change over the course of a simulation. We assume every agent is a rectangle obeying a kinematic bicycle model. - traffic_light_states: Optional[Dict[int, TrafficLightState]] + traffic_light_states: Optional[Dict[int, TrafficLightState]] = None Optional parameter containing the state of the traffic lights corresponding to the initial time step to be visualized. This parameter should only be used if the corresponding map contains traffic light static actors. - conditional_agents: List[int] + conditional_agents: Optional[List[int]] = None Optional parameter containing a list of agent IDs corresponding to conditional agents to be visualized to distinguish themselves. """ @@ -774,8 +765,8 @@ def reset_recording(self): """ self.agent_states_history = [] self.traffic_lights_history = [] - self.agent_attributes = None self.conditional_agents = [] + self.agent_attributes = None self.agent_face_colors = None self.agent_edge_colors = None @@ -792,7 +783,7 @@ def record_step( ---------- agent_states: List[AgentState] A list of AgentState objects corresponding to the initial time step to be visualized. - traffic_light_states: Optional[Dict[int, TrafficLightState]] + traffic_light_states: Optional[Dict[int, TrafficLightState]] = None Optional parameter containing the state of the traffic lights corresponding to the initial time step to be visualized. This parameter should only be used if the corresponding map contains traffic light static actors. """ @@ -814,17 +805,17 @@ def plot_scene( agent_edge_colors: Optional[List[Optional[Tuple[float,float,float]]]] = None ): """ - A standalone scene plotting function that initializes and resets a recording. It is assumed this function will be used not while recording steps for a full animation. + Plot a single timestep of data then reset the recording. Parameters ---------- agent_states: List[AgentState] A list of agents to be visualized in the image. - agent_attributes: List[AgentState] + agent_attributes: List[AgentAttributes] Static attributes of the agent, which don’t change over the course of a simulation. We assume every agent is a rectangle obeying a kinematic bicycle model. - traffic_light_states: Optional[Dict[int, TrafficLightState]] + traffic_light_states: Optional[Dict[int, TrafficLightState]] = None Optional parameter containing the state of the traffic lights to be visualized in the image. This parameter should only be used if the corresponding map contains traffic light static actors. - conditional_agents: List[int] + conditional_agents: Optional[List[int]] = None Optional parameter containing a list of agent IDs of conditional agents to be visualized in the image to distinguish themselves. ax: Optional[Axes] = None A matplotlib Axes object used to plot the image. By default, an Axes object is created if a value of None is passed. @@ -834,9 +825,9 @@ def plot_scene( Flag to determine if a vector showing the vehicles direction should be plotted in the image. By default this flag is set to True. velocity_vec: bool = False Flag to determine if the a vector showing the vehicles velocity should be plotted in the animation. By default this flag is set to False. - agent_face_colors: Optional[List[Tuple[float,float,float]]] = None + agent_face_colors: Optional[List[Optional[Tuple[float,float,float]]]] = None An optional parameter containing a list of either RGB tuples indicating the desired color of the agent with the corresponding index ID. A value of None in this list will use the default color. This value gets overwritten by the conditional agent color. - agent_edge_colors: Optional[List[Tuple[float,float,float]]] = None + agent_edge_colors: Optional[List[Optional[Tuple[float,float,float]]]] = None An optional parameter containing a list of either RGB tuples indicating the desired color of a border around the agent with the corresponding index ID. A value of None in this list will use the default color. This value gets overwritten by the conditional agent color. """ @@ -866,7 +857,7 @@ def animate_scene( agent_edge_colors: Optional[List[Optional[Tuple[float,float,float]]]] = None ) -> FuncAnimation: """ - Produce an animation of the sequentially recorded steps. A matplotlib animation object can be returned and/or a gif saved of the scene. + Produce an animation of sequentially recorded steps. A matplotlib animation object can be returned and/or a gif saved of the scene. Parameters ---------- @@ -874,7 +865,7 @@ def animate_scene( File name of the gif to which the animation will be saved. start_idx: int = 0 The index of the time step from which the animation will begin. By default it is assumed all recorded steps are desired to be animated. - end_idx: int = 0 + end_idx: int = -1 The index of the time step from which the animation will end. By default it is assumed all recorded steps are desired to be animated. ax: Optional[Axes] = None A matplotlib Axes object used to plot the animation. By default, an Axes object is created if a value of None is passed. @@ -898,7 +889,7 @@ def animate_scene( velocity_vec=velocity_vec, plot_frame_number=plot_frame_number) end_idx = len(self.agent_states_history) if end_idx == -1 else end_idx fig = self.current_ax.figure - fig.set_size_inches(self.resolution[0] / self.dpi, self.resolution[1] / self.dpi, True) + fig.set_size_inches(self._resolution[0] / self._dpi, self._resolution[1] / self._dpi, True) def animate(i): self._update_frame_to(i) @@ -906,14 +897,14 @@ def animate(i): ani = FuncAnimation( fig, animate, np.arange(start_idx, end_idx), interval=100) if output_name is not None: - ani.save(f'{output_name}', writer='pillow', dpi=self.dpi) + ani.save(f'{output_name}', writer='pillow', dpi=self._dpi) return ani - def _validate_kwargs(self,arg_name): + def _validate_kwargs(self,arg_name,kwargs): if arg_name in kwargs: - setattr(self,kwargs[arg_name]) + setattr(self,arg_name,kwargs[arg_name]) else: - raise Exception("Expected keyword argument 'map_image' but none was given.") + raise Exception(f"Expected keyword argument '{arg_name}' but none was given.") def _plot_frame(self, idx, ax=None, numbers=False, direction_vec=False, @@ -939,12 +930,12 @@ def _initialize_plot(self, ax=None, numbers=False, direction_vec=True, if ax is None: plt.clf() ax = plt.gca() - if not self.open_drive: + if self._open_drive is None: ax.imshow(self.map_image, extent=self.extent) else: self._draw_xodr_map(ax) - self.extent = (self.map_center[0] - self.fov / 2, self.map_center[0] + self.fov / 2) +\ - (self.map_center[1] - self.fov / 2, self.map_center[1] + self.fov / 2) + self.extent = (self.xy_offset[0] - self.fov / 2, self.xy_offset[0] + self.fov / 2) +\ + (self.xy_offset[1] - self.fov / 2, self.xy_offset[1] + self.fov / 2) ax.set_xlim((self.extent[0], self.extent[1])) ax.set_ylim((self.extent[2], self.extent[3])) self.current_ax = ax @@ -991,7 +982,7 @@ def _update_frame_to(self, frame_idx): else: self.frame_label.set_text(str(frame_idx)) - if not self.open_drive: + if self._open_drive is None: self.current_ax.set_xlim(*self.extent[0:2]) self.current_ax.set_ylim(*self.extent[2:4]) @@ -1070,7 +1061,7 @@ def _draw_xodr_map(self, ax, extras=False): the `odrplot` of `esmini` is used for plotting and parsing xodr https: // esmini.github.io/ # _tools_overview """ - with open(self.open_drive) as f: + with open(self._open_drive) as f: reader = csv.reader(f, skipinitialspace=True) positions = list(reader) From d916d073f856dedebe8f6d67410b69237868befb Mon Sep 17 00:00:00 2001 From: Kieran Ratcliffe Date: Wed, 23 Aug 2023 14:02:06 -0700 Subject: [PATCH 08/19] Added website documentation for Utils, ONLY for the ScenePlotter class. --- docs/source/pythonapi/index.md | 1 + docs/source/pythonapi/sdk-utils.md | 9 +++++++++ invertedai/utils.py | 4 ++++ 3 files changed, 14 insertions(+) create mode 100644 docs/source/pythonapi/sdk-utils.md diff --git a/docs/source/pythonapi/index.md b/docs/source/pythonapi/index.md index d4f90e61..f74f7b2c 100644 --- a/docs/source/pythonapi/index.md +++ b/docs/source/pythonapi/index.md @@ -15,6 +15,7 @@ sdk-blame sdk-simulation sdk-common sdk-env-var +sdk-utils.md ``` diff --git a/docs/source/pythonapi/sdk-utils.md b/docs/source/pythonapi/sdk-utils.md new file mode 100644 index 00000000..ce984e7e --- /dev/null +++ b/docs/source/pythonapi/sdk-utils.md @@ -0,0 +1,9 @@ +# Utils + + +```{eval-rst} +.. automodule:: invertedai.utils + .. autoclass:: ScenePlotter + .. automethod:: +``` + diff --git a/invertedai/utils.py b/invertedai/utils.py index d117ed89..843053a7 100644 --- a/invertedai/utils.py +++ b/invertedai/utils.py @@ -671,6 +671,10 @@ def __init__( The left-hand offset for the center of the map image. This parameter must be provided if using an ASAM OpenDRIVE format map. static_actors: Optional[List[StaticMapActor]] = None A list of static actor agents (e.g. traffic lights) represented as StaticMapActor objects, in the scene. This parameter must be provided if using an ASAM OpenDRIVE format map. + + See Also + -------- + :func:`location_info` """ self.conditional_agents = None From 2f9ee0cdc60de71afb0bcf90168c355dd2bffe4b Mon Sep 17 00:00:00 2001 From: Kieran Ratcliffe Date: Wed, 23 Aug 2023 14:07:28 -0700 Subject: [PATCH 09/19] Changed a few if statements to explicitly reference None case. --- invertedai/utils.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/invertedai/utils.py b/invertedai/utils.py index 843053a7..2e1c6745 100644 --- a/invertedai/utils.py +++ b/invertedai/utils.py @@ -1027,13 +1027,13 @@ def _update_agent(self, agent_idx, agent, agent_attribute): lw = 1 fc = self._get_color(agent_idx,self.agent_face_colors) - if not fc: + if fc is None: if agent_idx in self.conditional_agents: fc = self.cond_c else: fc = self.agent_c ec = self._get_color(agent_idx,self.agent_edge_colors) - if not ec: + if ec is None: lw = 0 ec = fc From 9ad33bd7cf4c951fcb0a56916aec9770aa0b6073 Mon Sep 17 00:00:00 2001 From: Kieran Ratcliffe Date: Wed, 23 Aug 2023 15:22:52 -0700 Subject: [PATCH 10/19] Updates to ScenePlotter sphinx documentation. --- docs/source/pythonapi/sdk-utils.md | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/docs/source/pythonapi/sdk-utils.md b/docs/source/pythonapi/sdk-utils.md index ce984e7e..31f33f9c 100644 --- a/docs/source/pythonapi/sdk-utils.md +++ b/docs/source/pythonapi/sdk-utils.md @@ -2,8 +2,7 @@ ```{eval-rst} -.. automodule:: invertedai.utils - .. autoclass:: ScenePlotter - .. automethod:: +.. autoclass:: ScenePlotter + .. method:: ``` From 4212e010f79368e3d2efafcc36effdd2263f287c Mon Sep 17 00:00:00 2001 From: Kieran Ratcliffe Date: Wed, 23 Aug 2023 15:28:28 -0700 Subject: [PATCH 11/19] Updated sphinx documentation. --- docs/source/pythonapi/sdk-utils.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/source/pythonapi/sdk-utils.md b/docs/source/pythonapi/sdk-utils.md index 31f33f9c..48e2ccc6 100644 --- a/docs/source/pythonapi/sdk-utils.md +++ b/docs/source/pythonapi/sdk-utils.md @@ -2,7 +2,7 @@ ```{eval-rst} -.. autoclass:: ScenePlotter - .. method:: +.. autoclass:: invertedai.utils.ScenePlotter + :method:: ``` From 8e9d5b2991ecab4bc8d1dc8c24b131f9ce73134d Mon Sep 17 00:00:00 2001 From: Kieran Ratcliffe Date: Wed, 23 Aug 2023 15:58:29 -0700 Subject: [PATCH 12/19] Further updates to sphinx documentation. --- docs/source/pythonapi/sdk-utils.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/source/pythonapi/sdk-utils.md b/docs/source/pythonapi/sdk-utils.md index 48e2ccc6..7483de29 100644 --- a/docs/source/pythonapi/sdk-utils.md +++ b/docs/source/pythonapi/sdk-utils.md @@ -3,6 +3,7 @@ ```{eval-rst} .. autoclass:: invertedai.utils.ScenePlotter - :method:: + :method: + :undoc-members: ``` From 1705e0defcaf7037fc55cfafe0554f66cb2f7059 Mon Sep 17 00:00:00 2001 From: Kieran Ratcliffe Date: Wed, 23 Aug 2023 16:05:12 -0700 Subject: [PATCH 13/19] Changed members field to sphinx documentation. --- docs/source/pythonapi/sdk-utils.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/pythonapi/sdk-utils.md b/docs/source/pythonapi/sdk-utils.md index 7483de29..70205af1 100644 --- a/docs/source/pythonapi/sdk-utils.md +++ b/docs/source/pythonapi/sdk-utils.md @@ -3,7 +3,7 @@ ```{eval-rst} .. autoclass:: invertedai.utils.ScenePlotter - :method: + :members: :undoc-members: ``` From 54da6d600edcec56ea04e57b3e67de064300fd23 Mon Sep 17 00:00:00 2001 From: Kieran Ratcliffe Date: Wed, 23 Aug 2023 16:18:32 -0700 Subject: [PATCH 14/19] Cleaned up the docstrings for ScenePlotter functions. --- invertedai/utils.py | 68 ++++++++++++++++++++++----------------------- 1 file changed, 34 insertions(+), 34 deletions(-) diff --git a/invertedai/utils.py b/invertedai/utils.py index 2e1c6745..3b535486 100644 --- a/invertedai/utils.py +++ b/invertedai/utils.py @@ -638,7 +638,7 @@ def rot(rot): class ScenePlotter(): """ - A class providing features for handling the data regarding visualization of a scene involving IAI data. + A class providing features for handling the data visualization of a scene involving IAI data. """ @validate_arguments def __init__( @@ -652,24 +652,24 @@ def __init__( """ Arguments ---------- - location_response: Optional[LocationResponse] = None + location_response: A LocationResponse object taken from calling iai.location_info() containing relevant data regarding the location of the scene including the map image. - open_drive: Optional[str] = None + open_drive: If using an ASAM OpenDRIVE format map for visualization, this string parameter is used to indicate the path to the corresponding CSV file. - resolution: Tuple[int,int] = (640, 480) + resolution: The desired resolution of the map image expressed as a Tuple with two integers for the width and height respectively. - dpi: float = 100 + dpi: Dots per inch to define the level of detail in the image. Keyword Arguments ----------------- - map_image: [np.ndarray] + map_image: Base image onto which the scene is visualized. This parameter must be provided if using an ASAM OpenDRIVE format map. fov: float The field of view in meters corresponding to the map_image attribute. This parameter must be provided if using an ASAM OpenDRIVE format map. - xy_offset: Optional[Tuple[int,int]] = None + xy_offset: The left-hand offset for the center of the map image. This parameter must be provided if using an ASAM OpenDRIVE format map. - static_actors: Optional[List[StaticMapActor]] = None + static_actors: A list of static actor agents (e.g. traffic lights) represented as StaticMapActor objects, in the scene. This parameter must be provided if using an ASAM OpenDRIVE format map. See Also @@ -742,13 +742,13 @@ def initialize_recording( Arguments ---------- - agent_states: List[AgentState] + agent_states: A list of AgentState objects corresponding to the initial time step to be visualized. - agent_attributes: List[AgentAttributes] + agent_attributes: Static attributes of the agent, which don’t change over the course of a simulation. We assume every agent is a rectangle obeying a kinematic bicycle model. - traffic_light_states: Optional[Dict[int, TrafficLightState]] = None + traffic_light_states: Optional parameter containing the state of the traffic lights corresponding to the initial time step to be visualized. This parameter should only be used if the corresponding map contains traffic light static actors. - conditional_agents: Optional[List[int]] = None + conditional_agents: Optional parameter containing a list of agent IDs corresponding to conditional agents to be visualized to distinguish themselves. """ @@ -785,9 +785,9 @@ def record_step( Arguments ---------- - agent_states: List[AgentState] + agent_states: A list of AgentState objects corresponding to the initial time step to be visualized. - traffic_light_states: Optional[Dict[int, TrafficLightState]] = None + traffic_light_states: Optional parameter containing the state of the traffic lights corresponding to the initial time step to be visualized. This parameter should only be used if the corresponding map contains traffic light static actors. """ @@ -813,25 +813,25 @@ def plot_scene( Parameters ---------- - agent_states: List[AgentState] + agent_states: A list of agents to be visualized in the image. - agent_attributes: List[AgentAttributes] + agent_attributes: Static attributes of the agent, which don’t change over the course of a simulation. We assume every agent is a rectangle obeying a kinematic bicycle model. - traffic_light_states: Optional[Dict[int, TrafficLightState]] = None + traffic_light_states: Optional parameter containing the state of the traffic lights to be visualized in the image. This parameter should only be used if the corresponding map contains traffic light static actors. - conditional_agents: Optional[List[int]] = None + conditional_agents: Optional parameter containing a list of agent IDs of conditional agents to be visualized in the image to distinguish themselves. - ax: Optional[Axes] = None + ax: A matplotlib Axes object used to plot the image. By default, an Axes object is created if a value of None is passed. - numbers: bool = False + numbers: Flag to determine if the ID's of all agents should be plotted in the image. By default this flag is set to False. - direction_vec: bool = True + direction_vec: Flag to determine if a vector showing the vehicles direction should be plotted in the image. By default this flag is set to True. - velocity_vec: bool = False + velocity_vec: Flag to determine if the a vector showing the vehicles velocity should be plotted in the animation. By default this flag is set to False. - agent_face_colors: Optional[List[Optional[Tuple[float,float,float]]]] = None + agent_face_colors: An optional parameter containing a list of either RGB tuples indicating the desired color of the agent with the corresponding index ID. A value of None in this list will use the default color. This value gets overwritten by the conditional agent color. - agent_edge_colors: Optional[List[Optional[Tuple[float,float,float]]]] = None + agent_edge_colors: An optional parameter containing a list of either RGB tuples indicating the desired color of a border around the agent with the corresponding index ID. A value of None in this list will use the default color. This value gets overwritten by the conditional agent color. """ @@ -865,25 +865,25 @@ def animate_scene( Parameters ---------- - output_name: Optional[str] = None + output_name: File name of the gif to which the animation will be saved. - start_idx: int = 0 + start_idx: The index of the time step from which the animation will begin. By default it is assumed all recorded steps are desired to be animated. - end_idx: int = -1 + end_idx: The index of the time step from which the animation will end. By default it is assumed all recorded steps are desired to be animated. - ax: Optional[Axes] = None + ax: A matplotlib Axes object used to plot the animation. By default, an Axes object is created if a value of None is passed. - numbers: bool = False + numbers: Flag to determine if the ID's of all agents should be plotted in the animation. By default this flag is set to False. - direction_vec: bool = True + direction_vec: Flag to determine if a vector showing the vehicles direction should be plotted in the animation. By default this flag is set to True. - velocity_vec: bool = False + velocity_vec: Flag to determine if the a vector showing the vehicles velocity should be plotted in the animation. By default this flag is set to False. - plot_frame_number: bool = False + plot_frame_number: Flag to determine if the frame numbers should be plotted in the animation. By default this flag is set to False. - agent_face_colors: Optional[List[Tuple[float,float,float]]] = None + agent_face_colors: An optional parameter containing a list of either RGB tuples indicating the desired color of the agent with the corresponding index ID. A value of None in this list will use the default color. This value gets overwritten by the conditional agent color. - agent_edge_colors: Optional[List[Tuple[float,float,float]]] = None + agent_edge_colors: An optional parameter containing a list of either RGB tuples indicating the desired color of a border around the agent with the corresponding index ID. A value of None in this list will use the default color. This value gets overwritten by the conditional agent color. """ From 928a6da7dbbed4fc357d95dc18641ccdc730448e Mon Sep 17 00:00:00 2001 From: Kieran Ratcliffe Date: Wed, 23 Aug 2023 16:47:42 -0700 Subject: [PATCH 15/19] Updated demos and README.md to use updated ScenePlotter parameters. --- README.md | 11 +- examples/IAI_full_demo.ipynb | 195 ++++--- examples/blame_example.ipynb | 707 +++++++++++------------ examples/cosimulation_minimal_example.py | 5 +- examples/cosimulation_npc_only.ipynb | 23 +- examples/minimal_example.py | 5 +- examples/npc_only.ipynb | 45 +- 7 files changed, 496 insertions(+), 495 deletions(-) diff --git a/README.md b/README.md index 7f315bbb..91d8bd48 100644 --- a/README.md +++ b/README.md @@ -67,10 +67,7 @@ agent_attributes = response.agent_attributes # get dimension and other attribut location_info_response = iai.location_info(location=location) rendered_static_map = location_info_response.birdview_image.decode() -scene_plotter = iai.utils.ScenePlotter(rendered_static_map, - location_info_response.map_fov, - (location_info_response.map_center.x, location_info_response.map_center.y), - location_info_response.static_actors) +scene_plotter = iai.utils.ScenePlotter(location_info_response) scene_plotter.initialize_recording( agent_states=response.agent_states, agent_attributes=agent_attributes, @@ -165,10 +162,7 @@ iai_simulation = iai.BasicCosimulation( # instantiate a stateful wrapper for In location_info_response = iai.location_info(location=location) rendered_static_map = location_info_response.birdview_image.decode() -scene_plotter = iai.utils.ScenePlotter(rendered_static_map, - location_info_response.map_fov, - (location_info_response.map_center.x, location_info_response.map_center.y), - location_info_response.static_actors) +scene_plotter = iai.utils.ScenePlotter(location_info_response) scene_plotter.initialize_recording( agent_states=iai_simulation.agent_states, agent_attributes=iai_simulation.agent_attributes, @@ -198,7 +192,6 @@ scene_plotter.animate_scene( plot_frame_number=True ) print("Done") - ``` To quickly check out how Inverted AI NPCs behave, try our diff --git a/examples/IAI_full_demo.ipynb b/examples/IAI_full_demo.ipynb index faae7c3a..86aa5ad9 100644 --- a/examples/IAI_full_demo.ipynb +++ b/examples/IAI_full_demo.ipynb @@ -44,7 +44,7 @@ "metadata": { "id": "7ATaWGo8IEXS" }, - "execution_count": 1, + "execution_count": null, "outputs": [] }, { @@ -74,7 +74,7 @@ "metadata": { "id": "b7l_n8sULmAX" }, - "execution_count": 2, + "execution_count": null, "outputs": [] }, { @@ -86,7 +86,7 @@ "metadata": { "id": "SFu9oOcDIQGs" }, - "execution_count": 3, + "execution_count": null, "outputs": [] }, { @@ -116,7 +116,7 @@ "metadata": { "id": "PiySgisPG6mG" }, - "execution_count": 4, + "execution_count": null, "outputs": [] }, { @@ -146,7 +146,7 @@ "id": "BIWeuX3aGcYt", "outputId": "4877e8fa-c7d9-4054-9cee-467d4e8ced3a" }, - "execution_count": 5, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -182,12 +182,12 @@ { "cell_type": "code", "source": [ - "scene_plotter = iai.utils.ScenePlotter(rendered_static_map, RENDERING_FOV, (location_info.map_center.x, location_info.map_center.y), location_info.static_actors)" + "scene_plotter = iai.utils.ScenePlotter(location_info)" ], "metadata": { "id": "P7reG8MW8QD1" }, - "execution_count": 6, + "execution_count": null, "outputs": [] }, { @@ -212,7 +212,7 @@ "id": "l1bfAd2QKPxX", "outputId": "a94e3faa-0080-4d64-9de1-c445c5668c66" }, - "execution_count": 7, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -264,7 +264,7 @@ "metadata": { "id": "iMmemEgMKw91" }, - "execution_count": 8, + "execution_count": null, "outputs": [] }, { @@ -304,7 +304,7 @@ "id": "NGG3WehBLIs6", "outputId": "2f59a56d-54e2-4495-8734-fe37f5d7670a" }, - "execution_count": 9, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -321,9 +321,9 @@ "fig, ax = plt.subplots(constrained_layout=True, figsize=(FIGURE_SIZE, FIGURE_SIZE))\n", "ax.set_axis_off()\n", "scene_plotter.plot_scene(\n", - " initial_conditions.agent_states,\n", - " initial_conditions.agent_attributes,\n", - " traffic_light_states = traffic_light,\n", + " agent_states=initial_conditions.agent_states,\n", + " agent_attributes=initial_conditions.agent_attributes,\n", + " traffic_light_states=traffic_light,\n", " ax=ax,\n", " numbers=True,\n", " velocity_vec=False,\n", @@ -338,7 +338,7 @@ "height": 1000 } }, - "execution_count": 10, + "execution_count": null, "outputs": [ { "output_type": "display_data", @@ -365,7 +365,11 @@ "cell_type": "code", "source": [ "agent_attributes = initial_conditions.agent_attributes\n", - "scene_plotter.initialize_recording(initial_conditions.agent_states, agent_attributes=agent_attributes, traffic_light_states=traffic_light)\n", + "scene_plotter.initialize_recording(\n", + " agent_states=initial_conditions.agent_states,\n", + " agent_attributes=agent_attributes,\n", + " traffic_light_states=traffic_light\n", + ")\n", "updated_state = initial_conditions\n", "times = []\n", "for i in range(SIMULATION_LENGTH):\n", @@ -393,7 +397,7 @@ "id": "BAsVrvyZLVI0", "outputId": "a5572048-cabb-4d66-a2a2-108712eaa29a" }, - "execution_count": 11, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -432,7 +436,7 @@ "metadata": { "id": "aGEE2jxMMLen" }, - "execution_count": 12, + "execution_count": null, "outputs": [] }, { @@ -448,7 +452,7 @@ "id": "LzhwrAXBHE8i", "outputId": "15c0c552-d4df-4aea-ba2a-d25768b57006" }, - "execution_count": 13, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -509,7 +513,7 @@ "metadata": { "id": "ZSH1uX3eMoAW" }, - "execution_count": 14, + "execution_count": null, "outputs": [] }, { @@ -545,7 +549,7 @@ "id": "pjy28ln-M3bN", "outputId": "65689319-4968-4e7a-f784-8da9a1d29e48" }, - "execution_count": 15, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -562,9 +566,9 @@ "fig, ax = plt.subplots(constrained_layout=True, figsize=(FIGURE_SIZE, FIGURE_SIZE))\n", "ax.set_axis_off()\n", "scene_plotter.plot_scene(\n", - " initial_conditions.agent_states,\n", - " initial_conditions.agent_attributes,\n", - " traffic_light_states = traffic_light,\n", + " agent_states=initial_conditions.agent_states,\n", + " agent_attributes=initial_conditions.agent_attributes,\n", + " traffic_light_states=traffic_light,\n", " ax=ax,\n", " numbers=True,\n", " velocity_vec=False,\n", @@ -579,7 +583,7 @@ "id": "hNI7FMavl-pf", "outputId": "af2ab712-1d54-4f19-8dbc-289183fcc277" }, - "execution_count": 16, + "execution_count": null, "outputs": [ { "output_type": "display_data", @@ -606,7 +610,11 @@ "cell_type": "code", "source": [ "agent_attributes = initial_conditions.agent_attributes\n", - "scene_plotter.initialize_recording(initial_conditions.agent_states, agent_attributes=agent_attributes, traffic_light_states=traffic_light)\n", + "scene_plotter.initialize_recording(\n", + " agent_states=initial_conditions.agent_states,\n", + " agent_attributes=agent_attributes,\n", + " traffic_light_states=traffic_light\n", + ")\n", "updated_state = initial_conditions;\n", "times = []\n", "for i in range(SIMULATION_LENGTH):\n", @@ -634,7 +642,7 @@ "id": "jBbcx6b1M9wr", "outputId": "ecdb996b-cadf-45cc-8582-463e11af793e" }, - "execution_count": 17, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -673,7 +681,7 @@ "metadata": { "id": "5VbCDU7FNVls" }, - "execution_count": 19, + "execution_count": null, "outputs": [] }, { @@ -689,7 +697,7 @@ "id": "Em2JTX29H5cY", "outputId": "484ecc31-c26e-4d7c-d92c-02f53b0fa5a5" }, - "execution_count": 20, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -726,7 +734,7 @@ "metadata": { "id": "UrZAifNOMwVe" }, - "execution_count": 21, + "execution_count": null, "outputs": [] }, { @@ -753,7 +761,7 @@ "metadata": { "id": "K0MwoVWqLowk" }, - "execution_count": 42, + "execution_count": null, "outputs": [] }, { @@ -771,10 +779,10 @@ "fig, ax = plt.subplots(constrained_layout=True, figsize=(FIGURE_SIZE, FIGURE_SIZE))\n", "ax.set_axis_off()\n", "scene_plotter.plot_scene(\n", - " conditional_agent_states,\n", - " conditional_agent_attributes,\n", - " traffic_light_states = traffic_light,\n", - " conditional_agents = [0, 1],\n", + " agent_states=conditional_agent_states,\n", + " agent_attributes=conditional_agent_attributes,\n", + " traffic_light_states=traffic_light,\n", + " conditional_agents=[0, 1],\n", " ax=ax,\n", " numbers=True\n", ")" @@ -787,7 +795,7 @@ "height": 1000 } }, - "execution_count": 43, + "execution_count": null, "outputs": [ { "output_type": "display_data", @@ -834,7 +842,7 @@ }, "outputId": "cc59e83f-f5c3-49d6-a28a-f8925efe73ee" }, - "execution_count": 49, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -860,10 +868,10 @@ "fig, ax = plt.subplots(constrained_layout=True, figsize=(FIGURE_SIZE, FIGURE_SIZE))\n", "ax.set_axis_off()\n", "scene_plotter.plot_scene(\n", - " initial_conditions.agent_states,\n", - " initial_conditions.agent_attributes,\n", - " conditional_agents = [0, 1],\n", - " traffic_light_states = traffic_light,\n", + " agent_states=initial_conditions.agent_states,\n", + " agent_attributes=initial_conditions.agent_attributes,\n", + " conditional_agents=[0, 1],\n", + " traffic_light_states=traffic_light,\n", " ax=ax,\n", " numbers=True,\n", " velocity_vec=False,\n", @@ -878,7 +886,7 @@ "id": "IEuyMqInOi9s", "outputId": "9afe755b-3cc0-4171-e9c6-ce4c12a9282b" }, - "execution_count": 50, + "execution_count": null, "outputs": [ { "output_type": "display_data", @@ -905,7 +913,11 @@ "cell_type": "code", "source": [ "agent_attributes = initial_conditions.agent_attributes\n", - "scene_plotter.initialize_recording(initial_conditions.agent_states, agent_attributes=agent_attributes, traffic_light_states=traffic_light, conditional_agents = [0, 1])\n", + "scene_plotter.initialize_recording(\n", + " agent_states=initial_conditions.agent_states,\n", + " agent_attributes=agent_attributes,\n", + " traffic_light_states=traffic_light,\n", + " conditional_agents=[0, 1])\n", "updated_state = initial_conditions;\n", "times = []\n", "for i in range(SIMULATION_LENGTH):\n", @@ -933,7 +945,7 @@ }, "outputId": "67a87501-732d-42d3-c726-7c08df593b36" }, - "execution_count": 51, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -972,7 +984,7 @@ "metadata": { "id": "Cg8vKaqqKKgD" }, - "execution_count": 52, + "execution_count": null, "outputs": [] }, { @@ -988,7 +1000,7 @@ "id": "6fzL0EsZMUkL", "outputId": "006bf21e-8916-4374-effb-1ae16166aa65" }, - "execution_count": 53, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -1040,7 +1052,11 @@ "source": [ "fig, ax = plt.subplots(constrained_layout=True, figsize=(FIGURE_SIZE, FIGURE_SIZE))\n", "light_response = iai.light(location=location, random_seed=5)\n", - "scene_plotter.plot_scene([], agent_attributes=[], traffic_light_states=light_response.traffic_lights_states, ax=ax)" + "scene_plotter.plot_scene(\n", + " agent_states=[],\n", + " agent_attributes=[],\n", + " traffic_light_states=light_response.traffic_lights_states,\n", + " ax=ax)" ], "metadata": { "colab": { @@ -1050,7 +1066,7 @@ "id": "JZ9newDGUkSl", "outputId": "c25bc46e-db7e-4f67-f0fe-643f43e1bf26" }, - "execution_count": 30, + "execution_count": null, "outputs": [ { "output_type": "display_data", @@ -1093,7 +1109,7 @@ }, "outputId": "834517e9-6a75-42e6-b489-0e03d5afe424" }, - "execution_count": 31, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -1117,7 +1133,10 @@ "cell_type": "code", "source": [ "light_response = initial_light\n", - "scene_plotter.initialize_recording(agent_states=[], agent_attributes=[], traffic_light_states=light_response.traffic_lights_states)\n", + "scene_plotter.initialize_recording(\n", + " agent_states=[],\n", + " agent_attributes=[],\n", + " traffic_light_states=light_response.traffic_lights_states)\n", "times = []\n", "for i in range(SIMULATION_LENGTH):\n", " t0 = time.time()\n", @@ -1136,7 +1155,7 @@ "id": "nX2dmlXqXbhr", "outputId": "3cf659e2-9f3e-48ad-d1bc-f07c6eb8b3dd" }, - "execution_count": 54, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -1166,7 +1185,7 @@ "metadata": { "id": "MPRAGGQYWuKx" }, - "execution_count": 55, + "execution_count": null, "outputs": [] }, { @@ -1191,7 +1210,7 @@ "id": "DbjOzTaGNISd", "outputId": "ccce2fcd-a173-411f-a637-05b21abce826" }, - "execution_count": 56, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -1246,7 +1265,7 @@ "metadata": { "id": "c7roTG4kNSXx" }, - "execution_count": 57, + "execution_count": null, "outputs": [] }, { @@ -1255,10 +1274,10 @@ "fig, ax = plt.subplots(constrained_layout=True, figsize=(FIGURE_SIZE, FIGURE_SIZE))\n", "ax.set_axis_off()\n", "scene_plotter.plot_scene(\n", - " initial_conditions.agent_states,\n", - " initial_conditions.agent_attributes,\n", - " conditional_agents = [0, 1],\n", - " traffic_light_states = traffic_light,\n", + " agent_states=initial_conditions.agent_states,\n", + " agent_attributes=initial_conditions.agent_attributes,\n", + " conditional_agents=[0, 1],\n", + " traffic_light_states=traffic_light,\n", " ax=ax,\n", " numbers=True\n", ")" @@ -1271,7 +1290,7 @@ "id": "eAf__SZwSR8U", "outputId": "9c54d48a-8e91-40ed-babf-6bc71898e6de" }, - "execution_count": 58, + "execution_count": null, "outputs": [ { "output_type": "display_data", @@ -1301,10 +1320,10 @@ "light_response = initial_light\n", "\n", "scene_plotter.initialize_recording(\n", - " initial_conditions.agent_states,\n", + " agent_states=initial_conditions.agent_states,\n", " agent_attributes=agent_attributes,\n", " traffic_light_states=light_response.traffic_lights_states,\n", - " conditional_agents = [0, 1]\n", + " conditional_agents=[0, 1]\n", ")\n", "updated_state = initial_conditions\n", "times = []\n", @@ -1334,7 +1353,7 @@ "id": "CrfCo-22Rfd6", "outputId": "ff34050e-7ad5-4ebd-d918-a9a321f7f9c3" }, - "execution_count": 59, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -1373,7 +1392,7 @@ "metadata": { "id": "670VO9X4ShfB" }, - "execution_count": 60, + "execution_count": null, "outputs": [] }, { @@ -1389,7 +1408,7 @@ "id": "WDvUPewKSmro", "outputId": "65546e8e-2b5d-4d15-d53e-ad071b799d41" }, - "execution_count": 61, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -1448,7 +1467,7 @@ "metadata": { "id": "58-feX0fME6i" }, - "execution_count": 62, + "execution_count": null, "outputs": [] }, { @@ -1466,10 +1485,10 @@ "fig, ax = plt.subplots(constrained_layout=True, figsize=(FIGURE_SIZE, FIGURE_SIZE))\n", "ax.set_axis_off()\n", "scene_plotter.plot_scene(\n", - " infraction_conditional_agent_states,\n", - " infraction_conditional_agent_attributes,\n", - " traffic_light_states = traffic_light,\n", - " conditional_agents = [0, 1, 2],\n", + " agent_states=infraction_conditional_agent_states,\n", + " agent_attributes=infraction_conditional_agent_attributes,\n", + " traffic_light_states=traffic_light,\n", + " conditional_agents=[0, 1, 2],\n", " ax=ax,\n", " numbers=True\n", ")" @@ -1482,7 +1501,7 @@ }, "id": "GLSIKGjsME6i" }, - "execution_count": 63, + "execution_count": null, "outputs": [ { "output_type": "display_data", @@ -1513,7 +1532,7 @@ "metadata": { "id": "EMb_8seWTJaA" }, - "execution_count": 64, + "execution_count": null, "outputs": [] }, { @@ -1522,10 +1541,10 @@ "fig, ax = plt.subplots(constrained_layout=True, figsize=(FIGURE_SIZE, FIGURE_SIZE))\n", "ax.set_axis_off()\n", "scene_plotter.plot_scene(\n", - " initial_conditions.agent_states,\n", - " initial_conditions.agent_attributes,\n", - " conditional_agents = [0, 1, 2],\n", - " traffic_light_states = traffic_light,\n", + " agent_states=initial_conditions.agent_states,\n", + " agent_attributes=initial_conditions.agent_attributes,\n", + " conditional_agents=[0, 1, 2],\n", + " traffic_light_states=traffic_light,\n", " ax=ax,\n", " numbers=True,\n", " velocity_vec=True,\n", @@ -1540,7 +1559,7 @@ "id": "0Xn1OTy1VsjN", "outputId": "60e5ac1d-e848-412b-c8fc-22feea98a292" }, - "execution_count": 65, + "execution_count": null, "outputs": [ { "output_type": "display_data", @@ -1570,10 +1589,10 @@ "light_response = initial_light\n", "\n", "scene_plotter.initialize_recording(\n", - " initial_conditions.agent_states,\n", + " agent_states=initial_conditions.agent_states,\n", " agent_attributes=agent_attributes,\n", " traffic_light_states=light_response.traffic_lights_states,\n", - " conditional_agents = [0, 1, 2]\n", + " conditional_agents=[0, 1, 2]\n", ")\n", "updated_state = initial_conditions\n", "times = []\n", @@ -1608,7 +1627,7 @@ "id": "ahGBbPMXTatP", "outputId": "bf7e7bf8-6c79-4b1e-bb51-bb383631d4f4" }, - "execution_count": 66, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -1641,7 +1660,7 @@ "id": "G_iMq45oZ-Tl", "outputId": "7169dd6f-bb70-48cc-db1c-6354b5f60e88" }, - "execution_count": 67, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -1671,7 +1690,7 @@ "metadata": { "id": "UinJ3DZcTMmt" }, - "execution_count": 68, + "execution_count": null, "outputs": [] }, { @@ -1696,7 +1715,7 @@ "id": "JYidLtqTWO8x", "outputId": "b39f4541-bb4f-48eb-d68d-cf440c22624d" }, - "execution_count": 70, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -1758,7 +1777,7 @@ "metadata": { "id": "dLKiDEwRdsEb" }, - "execution_count": 71, + "execution_count": null, "outputs": [] }, { @@ -1767,9 +1786,9 @@ "fig, ax = plt.subplots(constrained_layout=True, figsize=(FIGURE_SIZE, FIGURE_SIZE))\n", "ax.set_axis_off()\n", "scene_plotter.plot_scene(\n", - " initial_conditions.agent_states,\n", - " initial_conditions.agent_attributes,\n", - " traffic_light_states = initial_light.traffic_lights_states,\n", + " agent_states=initial_conditions.agent_states,\n", + " agent_attributes=initial_conditions.agent_attributes,\n", + " traffic_light_states=initial_light.traffic_lights_states,\n", " ax=ax,\n", " numbers=True\n", ")" @@ -1782,7 +1801,7 @@ "id": "e6xYN3Fsd3Q0", "outputId": "a02107cd-ca51-4a10-f0b0-a0504ca307e2" }, - "execution_count": 72, + "execution_count": null, "outputs": [ { "output_type": "display_data", @@ -1844,7 +1863,7 @@ "id": "6eRun3EXd6As", "outputId": "1a3f05ea-20a9-43de-e1d0-cea416a1ba4d" }, - "execution_count": 74, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -1877,7 +1896,7 @@ "id": "6vNywqflfiFB", "outputId": "881cd4c0-4c5a-4621-8f6e-15c83534320b" }, - "execution_count": 75, + "execution_count": null, "outputs": [ { "output_type": "stream", diff --git a/examples/blame_example.ipynb b/examples/blame_example.ipynb index 9ee1e620..067d5ff0 100644 --- a/examples/blame_example.ipynb +++ b/examples/blame_example.ipynb @@ -1,356 +1,355 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "uYrB4Yk3aizw" - }, - "source": [ - "\"InvertedAI\"\n" - ] + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "uYrB4Yk3aizw" + }, + "source": [ + "\"InvertedAI\"\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "b7l_n8sULmAX" + }, + "outputs": [], + "source": [ + "import IPython\n", + "from IPython.display import display, Image, clear_output\n", + "from ipywidgets import interact\n", + "from IPython.utils import io\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import imageio\n", + "import numpy as np\n", + "import cv2\n", + "import invertedai as iai\n", + "\n", + "from shapely.geometry import Polygon\n", + "from shapely.errors import GEOSException\n", + "\n", + "from dataclasses import dataclass\n", + "from typing import Tuple" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "SFu9oOcDIQGs" + }, + "outputs": [], + "source": [ + "# API key:\n", + "iai.add_apikey(\"\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "PiySgisPG6mG" + }, + "outputs": [], + "source": [ + "# pick a location (4 way, signalized intgersection)\n", + "location = \"iai:drake_street_and_pacific_blvd\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "kT3m0-zoNdvW" + }, + "outputs": [], + "source": [ + "location_info_response = iai.location_info(location=location)\n", + "rendered_static_map = location_info_response.birdview_image.decode()\n", + "scene_plotter = iai.utils.ScenePlotter(location_info_response)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "L0ufxMO8NdvX", + "scrolled": true + }, + "outputs": [], + "source": [ + "@dataclass\n", + "class LogCollision:\n", + " collision_agents: Tuple[int, int]\n", + " start_time: int\n", + " end_time: int\n", + "\n", + "def transform_all_agent_vertices_into_world_frame(agent_states,agent_attributes):\n", + " \"\"\"\n", + " Transform the vertices of all agents into points within the world frame of the map environment\n", + " Args:\n", + " agent_states: List[AgentState] #List of all current agent states including x and y coordinates and angle.\n", + " agent_attributes: List[AgentAttributes] #List of static attributes of all agents including agent length and width.\n", + " Returns:\n", + " List[Polygon] #List of Polygon data types containing a list of vertices for each agent\n", + " \"\"\"\n", + " polygons = [None]*len(agent_states)\n", + " for i, (state, attributes) in enumerate(zip(agent_states,agent_attributes)):\n", + " dx = attributes.length/2\n", + " dy = attributes.width/2\n", + "\n", + " vehicle_origin = np.array([state.center.x, state.center.y])\n", + "\n", + " vehicle_orientation = state.orientation\n", + " c, s = np.cos(vehicle_orientation), np.sin(vehicle_orientation)\n", + "\n", + " rotation_matrix = np.array([[c, s],\n", + " [-s, c]])\n", + " stacked_vertices = np.array([[dx,dy],[dx,-dy],[-dx,-dy],[-dx,dy]]) #Formatted in a continuous sequence\n", + " rotated_vertices = np.matmul(stacked_vertices,rotation_matrix)\n", + "\n", + " polygons[i] = vehicle_origin + rotated_vertices\n", + "\n", + " return [Polygon(p) for p in polygons]\n", + "\n", + "def check_agent_pairwise_intersections(polygons):\n", + " \"\"\"\n", + " Check all pairs of polygons in a list for intersections in their area.\n", + " Args:\n", + " polygons: List[Polygon] #List of polygons representing agents in an environment\n", + " Returns:\n", + " List[Tuple[int,int]] #List of agent ID pair tuples indicating collisions\n", + " \"\"\"\n", + "\n", + " detected_overlap_agent_pairs = []\n", + " num_agents = len(polygons)\n", + " for j in range(num_agents):\n", + " for k in range(j+1,num_agents):\n", + " try:\n", + " if polygons[j].intersection(polygons[k]).area:\n", + " detected_overlap_agent_pairs.append((j,k))\n", + " except GEOSException as e:\n", + " print(f\"Collision candidates {j} and {k} failed with error {e}.\")\n", + " pass\n", + "\n", + " return detected_overlap_agent_pairs\n", + "\n", + "def compute_pairwise_collisions(agent_states_history,agent_attributes):\n", + " \"\"\"\n", + " Use polygon intersections to check each agent combination whether there is a collision.\n", + " Args:\n", + " agent_states: List[List[AgentState]] #At all time steps, list of all current agent states including x and y coordinates and angle.\n", + " agent_attributes: List[AgentAttributes] #List of static attributes of all agents including agent length and width.\n", + " Returns:\n", + " List[LogCollision] #List of collisions logs containing information about the colliding agent pairs IDs and the time period of the collision\n", + " \"\"\"\n", + "\n", + " collisions_ongoing = {}\n", + " collisions_all = []\n", + "\n", + " for t, agent_states in enumerate(agent_states_history):\n", + " if len(agent_states) != len(agent_attributes):\n", + " raise Exception(\"Incorrect number of agents or agent attributes.\")\n", + "\n", + " polygons = transform_all_agent_vertices_into_world_frame(agent_states,agent_attributes)\n", + " detected_agent_pairs = check_agent_pairwise_intersections(polygons)\n", + "\n", + " for agent_tuple in detected_agent_pairs:\n", + " if agent_tuple not in collisions_ongoing:\n", + " collisions_ongoing[agent_tuple] = LogCollision(\n", + " collision_agents=agent_tuple,\n", + " start_time=t,\n", + " end_time=None\n", + " )\n", + " untracked_agent_pairs = []\n", + " for agent_tuple, collision in collisions_ongoing.items():\n", + " if agent_tuple not in detected_agent_pairs:\n", + " #The previous time step is the last in which the collision was observed\n", + " collisions_ongoing[agent_tuple].end_time = t-1\n", + " elif t >= SIMULATION_LENGTH-1:\n", + " #The collision has not necessarily ended at this time step but it is the last time step it was observed to occur\n", + " collisions_ongoing[agent_tuple].end_time = t\n", + "\n", + " if collisions_ongoing[agent_tuple].end_time is not None:\n", + " collisions_all.append(collisions_ongoing[agent_tuple])\n", + " untracked_agent_pairs.append(agent_tuple)\n", + "\n", + " collisions_ongoing = {k:v for k, v in collisions_ongoing.items() if not k in untracked_agent_pairs}\n", + "\n", + " return collisions_all\n", + "\n", + "# Simulate with `initialize`, `drive` and `light` until there are collisions.\n", + "for _ in range(20): #Attempt 20 simulations looking for a collision\n", + " light_response = iai.light(location=location)\n", + "\n", + " response = iai.initialize(\n", + " location=location,\n", + " agent_count=15,\n", + " get_birdview=True,\n", + " traffic_light_state_history=[light_response.traffic_lights_states]\n", + " )\n", + " agent_attributes = response.agent_attributes\n", + " scene_plotter.initialize_recording(\n", + " agent_states=response.agent_states,\n", + " agent_attributes=agent_attributes,\n", + " traffic_light_states=light_response.traffic_lights_states\n", + " )\n", + "\n", + " agent_state_history = []\n", + " traffic_light_state_history = []\n", + "\n", + " # 10-second scene\n", + " SIMULATION_LENGTH = 100\n", + " for t in range(SIMULATION_LENGTH):\n", + " light_response = iai.light(\n", + " location=location,\n", + " recurrent_states=light_response.recurrent_states\n", + " )\n", + " response = iai.drive(\n", + " location=location,\n", + " agent_attributes=agent_attributes,\n", + " agent_states=response.agent_states,\n", + " recurrent_states=response.recurrent_states,\n", + " get_birdview=False,\n", + " traffic_lights_states=light_response.traffic_lights_states,\n", + " get_infractions=True,\n", + " random_seed=1\n", + " )\n", + " scene_plotter.record_step(\n", + " response.agent_states,\n", + " traffic_light_states=light_response.traffic_lights_states\n", + " )\n", + " agent_state_history.append(response.agent_states)\n", + " traffic_light_state_history.append(light_response.traffic_lights_states)\n", + "\n", + " print(f\"Attempted collision simulation number {_} iteration number {t}.\")\n", + " clear_output(wait=True)\n", + "\n", + " collisions = compute_pairwise_collisions(agent_state_history,agent_attributes)\n", + " if collisions:\n", + " #If a collision is detected, cease generating more simulations\n", + " break\n", + "\n", + "print(collisions)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "YQ4dXaKQNdvZ" + }, + "outputs": [], + "source": [ + "blame_responses = []\n", + "all_collision_agents = []\n", + "for collision_data in collisions:\n", + " all_collision_agents.extend(list(collision_data.collision_agents))\n", + " blame_response = iai.blame(\n", + " location=location,\n", + " colliding_agents=collision_data.collision_agents,\n", + " agent_state_history=agent_state_history[:collision_data.start_time],\n", + " traffic_light_state_history=traffic_light_state_history[:collision_data.start_time],\n", + " agent_attributes=agent_attributes,\n", + " get_reasons=True,\n", + " get_confidence_score=True,\n", + " get_birdviews=False\n", + " )\n", + " print(blame_response.agents_at_fault)\n", + " blame_responses.append(blame_response)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "jRRaiLInNdvZ" + }, + "outputs": [], + "source": [ + "for response in blame_responses:\n", + " print(response.reasons)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "oZ79k112Ndva" + }, + "outputs": [], + "source": [ + "for response in blame_responses:\n", + " print(response.confidence_score)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "QzbqXvS7Ndva" + }, + "outputs": [], + "source": [ + "%%capture\n", + "fig, ax = plt.subplots(constrained_layout=True, figsize=(50, 50))\n", + "gif_name = 'blame-example.gif'\n", + "scene_plotter.animate_scene(\n", + " output_name=gif_name,\n", + " ax=ax,\n", + " numbers=all_collision_agents,\n", + " direction_vec=False,\n", + " velocity_vec=False,\n", + " plot_frame_number=True\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "aUYCAHfsNdva" + }, + "outputs": [], + "source": [ + "Image(gif_name, width=1000, height=800)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "O9uuSTHsRV-8" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10" + } }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "b7l_n8sULmAX" - }, - "outputs": [], - "source": [ - "import IPython\n", - "from IPython.display import display, Image, clear_output\n", - "from ipywidgets import interact\n", - "from IPython.utils import io\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import imageio\n", - "import numpy as np\n", - "import cv2\n", - "import invertedai as iai\n", - "\n", - "from shapely.geometry import Polygon\n", - "from shapely.errors import GEOSException\n", - "\n", - "from dataclasses import dataclass\n", - "from typing import Tuple" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "SFu9oOcDIQGs" - }, - "outputs": [], - "source": [ - "# API key:\n", - "iai.add_apikey(\"\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "PiySgisPG6mG" - }, - "outputs": [], - "source": [ - "# pick a location (4 way, signalized intgersection)\n", - "location = \"iai:drake_street_and_pacific_blvd\"" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "kT3m0-zoNdvW" - }, - "outputs": [], - "source": [ - "location_info_response = iai.location_info(location=location)\n", - "rendered_static_map = location_info_response.birdview_image.decode()\n", - "scene_plotter = iai.utils.ScenePlotter(rendered_static_map,\n", - " location_info_response.map_fov,\n", - " (location_info_response.map_center.x, location_info_response.map_center.y),\n", - " location_info_response.static_actors)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "L0ufxMO8NdvX", - "scrolled": true - }, - "outputs": [], - "source": [ - "@dataclass\n", - "class LogCollision:\n", - " collision_agents: Tuple[int, int]\n", - " start_time: int \n", - " end_time: int\n", - "\n", - "def transform_all_agent_vertices_into_world_frame(agent_states,agent_attributes):\n", - " \"\"\"\n", - " Transform the vertices of all agents into points within the world frame of the map environment\n", - " Args:\n", - " agent_states: List[AgentState] #List of all current agent states including x and y coordinates and angle.\n", - " agent_attributes: List[AgentAttributes] #List of static attributes of all agents including agent length and width.\n", - " Returns:\n", - " List[Polygon] #List of Polygon data types containing a list of vertices for each agent\n", - " \"\"\"\n", - " polygons = [None]*len(agent_states)\n", - " for i, (state, attributes) in enumerate(zip(agent_states,agent_attributes)):\n", - " dx = attributes.length/2\n", - " dy = attributes.width/2\n", - "\n", - " vehicle_origin = np.array([state.center.x, state.center.y])\n", - "\n", - " vehicle_orientation = state.orientation\n", - " c, s = np.cos(vehicle_orientation), np.sin(vehicle_orientation)\n", - "\n", - " rotation_matrix = np.array([[c, s],\n", - " [-s, c]])\n", - " stacked_vertices = np.array([[dx,dy],[dx,-dy],[-dx,-dy],[-dx,dy]]) #Formatted in a continuous sequence\n", - " rotated_vertices = np.matmul(stacked_vertices,rotation_matrix)\n", - " \n", - " polygons[i] = vehicle_origin + rotated_vertices\n", - "\n", - " return [Polygon(p) for p in polygons]\n", - "\n", - "def check_agent_pairwise_intersections(polygons):\n", - " \"\"\"\n", - " Check all pairs of polygons in a list for intersections in their area.\n", - " Args:\n", - " polygons: List[Polygon] #List of polygons representing agents in an environment\n", - " Returns:\n", - " List[Tuple[int,int]] #List of agent ID pair tuples indicating collisions\n", - " \"\"\"\n", - " \n", - " detected_overlap_agent_pairs = []\n", - " num_agents = len(polygons)\n", - " for j in range(num_agents):\n", - " for k in range(j+1,num_agents):\n", - " try:\n", - " if polygons[j].intersection(polygons[k]).area:\n", - " detected_overlap_agent_pairs.append((j,k))\n", - " except GEOSException as e:\n", - " print(f\"Collision candidates {j} and {k} failed with error {e}.\")\n", - " pass\n", - " \n", - " return detected_overlap_agent_pairs\n", - " \n", - "def compute_pairwise_collisions(agent_states_history,agent_attributes):\n", - " \"\"\"\n", - " Use polygon intersections to check each agent combination whether there is a collision.\n", - " Args:\n", - " agent_states: List[List[AgentState]] #At all time steps, list of all current agent states including x and y coordinates and angle.\n", - " agent_attributes: List[AgentAttributes] #List of static attributes of all agents including agent length and width.\n", - " Returns:\n", - " List[LogCollision] #List of collisions logs containing information about the colliding agent pairs IDs and the time period of the collision\n", - " \"\"\"\n", - " \n", - " collisions_ongoing = {}\n", - " collisions_all = []\n", - " \n", - " for t, agent_states in enumerate(agent_states_history):\n", - " if len(agent_states) != len(agent_attributes):\n", - " raise Exception(\"Incorrect number of agents or agent attributes.\")\n", - "\n", - " polygons = transform_all_agent_vertices_into_world_frame(agent_states,agent_attributes)\n", - " detected_agent_pairs = check_agent_pairwise_intersections(polygons) \n", - " \n", - " for agent_tuple in detected_agent_pairs:\n", - " if agent_tuple not in collisions_ongoing:\n", - " collisions_ongoing[agent_tuple] = LogCollision(\n", - " collision_agents=agent_tuple,\n", - " start_time=t,\n", - " end_time=None\n", - " )\n", - " untracked_agent_pairs = []\n", - " for agent_tuple, collision in collisions_ongoing.items():\n", - " if agent_tuple not in detected_agent_pairs:\n", - " #The previous time step is the last in which the collision was observed\n", - " collisions_ongoing[agent_tuple].end_time = t-1\n", - " elif t >= SIMULATION_LENGTH-1:\n", - " #The collision has not necessarily ended at this time step but it is the last time step it was observed to occur\n", - " collisions_ongoing[agent_tuple].end_time = t\n", - " \n", - " if collisions_ongoing[agent_tuple].end_time is not None:\n", - " collisions_all.append(collisions_ongoing[agent_tuple])\n", - " untracked_agent_pairs.append(agent_tuple)\n", - " \n", - " collisions_ongoing = {k:v for k, v in collisions_ongoing.items() if not k in untracked_agent_pairs}\n", - " \n", - " return collisions_all\n", - "\n", - "# Simulate with `initialize`, `drive` and `light` until there are collisions.\n", - "for _ in range(20): #Attempt 20 simulations looking for a collision\n", - " light_response = iai.light(location=location)\n", - "\n", - " response = iai.initialize(\n", - " location=location,\n", - " agent_count=15,\n", - " get_birdview=True,\n", - " traffic_light_state_history=[light_response.traffic_lights_states]\n", - " )\n", - " agent_attributes = response.agent_attributes\n", - " scene_plotter.initialize_recording(\n", - " response.agent_states,\n", - " agent_attributes=agent_attributes,\n", - " traffic_light_states=light_response.traffic_lights_states\n", - " )\n", - "\n", - " agent_state_history = []\n", - " traffic_light_state_history = []\n", - "\n", - " # 10-second scene\n", - " SIMULATION_LENGTH = 100\n", - " for t in range(SIMULATION_LENGTH):\n", - " light_response = iai.light(\n", - " location=location, \n", - " recurrent_states=light_response.recurrent_states\n", - " )\n", - " response = iai.drive(\n", - " location=location,\n", - " agent_attributes=agent_attributes,\n", - " agent_states=response.agent_states,\n", - " recurrent_states=response.recurrent_states,\n", - " get_birdview=False,\n", - " traffic_lights_states=light_response.traffic_lights_states,\n", - " get_infractions=True,\n", - " random_seed=1\n", - " )\n", - " scene_plotter.record_step(\n", - " response.agent_states, \n", - " traffic_light_states=light_response.traffic_lights_states\n", - " )\n", - " agent_state_history.append(response.agent_states)\n", - " traffic_light_state_history.append(light_response.traffic_lights_states)\n", - " \n", - " print(f\"Attempted collision simulation number {_} iteration number {t}.\")\n", - " clear_output(wait=True)\n", - " \n", - " collisions = compute_pairwise_collisions(agent_state_history,agent_attributes)\n", - " if collisions: \n", - " #If a collision is detected, cease generating more simulations\n", - " break\n", - "\n", - "print(collisions)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "YQ4dXaKQNdvZ" - }, - "outputs": [], - "source": [ - "blame_responses = []\n", - "all_collision_agents = []\n", - "for collision_data in collisions:\n", - " all_collision_agents.extend(list(collision_data.collision_agents))\n", - " blame_response = iai.blame(\n", - " location=location,\n", - " colliding_agents=collision_data.collision_agents,\n", - " agent_state_history=agent_state_history[:collision_data.start_time],\n", - " traffic_light_state_history=traffic_light_state_history[:collision_data.start_time],\n", - " agent_attributes=agent_attributes,\n", - " get_reasons=True,\n", - " get_confidence_score=True,\n", - " get_birdviews=False\n", - " )\n", - " print(blame_response.agents_at_fault)\n", - " blame_responses.append(blame_response)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "jRRaiLInNdvZ" - }, - "outputs": [], - "source": [ - "for response in blame_responses:\n", - " print(response.reasons)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "oZ79k112Ndva" - }, - "outputs": [], - "source": [ - "for response in blame_responses:\n", - " print(response.confidence_score)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "QzbqXvS7Ndva" - }, - "outputs": [], - "source": [ - "%%capture\n", - "fig, ax = plt.subplots(constrained_layout=True, figsize=(50, 50))\n", - "gif_name = 'blame-example.gif'\n", - "scene_plotter.animate_scene(\n", - " output_name=gif_name,\n", - " ax=ax,\n", - " numbers=all_collision_agents,\n", - " direction_vec=False,\n", - " velocity_vec=False,\n", - " plot_frame_number=True\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "aUYCAHfsNdva" - }, - "outputs": [], - "source": [ - "Image(gif_name, width=1000, height=800)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.10" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/examples/cosimulation_minimal_example.py b/examples/cosimulation_minimal_example.py index e31ee7ff..72d376fd 100644 --- a/examples/cosimulation_minimal_example.py +++ b/examples/cosimulation_minimal_example.py @@ -47,10 +47,7 @@ def step(self, predicted_npc_states): location_info_response = iai.location_info(location=location) rendered_static_map = location_info_response.birdview_image.decode() -scene_plotter = iai.utils.ScenePlotter(rendered_static_map, - location_info_response.map_fov, - (location_info_response.map_center.x, location_info_response.map_center.y), - location_info_response.static_actors) +scene_plotter = iai.utils.ScenePlotter(location_info_response) scene_plotter.initialize_recording( agent_states=iai_simulation.agent_states, agent_attributes=iai_simulation.agent_attributes, diff --git a/examples/cosimulation_npc_only.ipynb b/examples/cosimulation_npc_only.ipynb index 4ae48e38..2e1b0098 100644 --- a/examples/cosimulation_npc_only.ipynb +++ b/examples/cosimulation_npc_only.ipynb @@ -12,7 +12,6 @@ }, { "cell_type": "code", - "execution_count": null, "id": "911445d4-8b61-49a1-9620-d1f3eb0c4199", "metadata": { @@ -42,9 +41,7 @@ "id": "8-pHxcgkwygX" }, "id": "8-pHxcgkwygX", - "execution_count": null, - "outputs": [] }, { @@ -59,7 +56,6 @@ }, { "cell_type": "code", - "execution_count": null, "id": "50786ea1", "metadata": { @@ -84,7 +80,6 @@ }, { "cell_type": "code", - "execution_count": null, "id": "28a99825", "metadata": { @@ -115,7 +110,6 @@ }, { "cell_type": "code", - "execution_count": null, "id": "4c16d71f", "metadata": { @@ -158,13 +152,12 @@ { "cell_type": "code", "source": [ - "scene_plotter = iai.utils.ScenePlotter(rendered_map, RENDERING_FOV, (location_info.map_center.x, location_info.map_center.y), location_info.static_actors)" + "scene_plotter = iai.utils.ScenePlotter(location_info)" ], "metadata": { "id": "xMu0Qi981Fmz" }, "id": "xMu0Qi981Fmz", - "execution_count": null, "outputs": [] }, @@ -217,9 +210,9 @@ "fig, ax = plt.subplots(constrained_layout=True, figsize=(FIGURE_SIZE, FIGURE_SIZE))\n", "ax.set_axis_off()\n", "scene_plotter.plot_scene(\n", - " simulation.agent_states,\n", - " agent_attributes,\n", - " traffic_light_states = simulation.light_states,\n", + " agent_states=simulation.agent_states,\n", + " agent_attributes=agent_attributes,\n", + " traffic_light_states=simulation.light_states,\n", " ax=ax,\n", " numbers=True,\n", " velocity_vec=False,\n", @@ -259,7 +252,11 @@ } ], "source": [ - "scene_plotter.initialize_recording(simulation.agent_states, agent_attributes=agent_attributes, traffic_light_states=simulation.light_states)\n", + "scene_plotter.initialize_recording(\n", + " agent_states=simulation.agent_states,\n", + " agent_attributes=agent_attributes,\n", + " traffic_light_states=simulation.light_states\n", + ")\n", "times = []\n", "for t in range(SIMULATION_LENGTH):\n", " t0 = time.time()\n", @@ -355,4 +352,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/examples/minimal_example.py b/examples/minimal_example.py index cd18a13a..2b9a046d 100644 --- a/examples/minimal_example.py +++ b/examples/minimal_example.py @@ -25,10 +25,7 @@ location_info_response = iai.location_info(location=location) rendered_static_map = location_info_response.birdview_image.decode() -scene_plotter = iai.utils.ScenePlotter(rendered_static_map, - location_info_response.map_fov, - (location_info_response.map_center.x, location_info_response.map_center.y), - location_info_response.static_actors) +scene_plotter = iai.utils.ScenePlotter(location_info_response) scene_plotter.initialize_recording( agent_states=response.agent_states, agent_attributes=agent_attributes, diff --git a/examples/npc_only.ipynb b/examples/npc_only.ipynb index 803b9e59..3ec15598 100644 --- a/examples/npc_only.ipynb +++ b/examples/npc_only.ipynb @@ -12,7 +12,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "7e1472cc", "metadata": { "id": "7e1472cc" @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "119c4821", "metadata": { "id": "119c4821" @@ -41,7 +41,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "911445d4-8b61-49a1-9620-d1f3eb0c4199", "metadata": { "id": "911445d4-8b61-49a1-9620-d1f3eb0c4199" @@ -70,7 +70,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "50786ea1", "metadata": { "id": "50786ea1" @@ -94,7 +94,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "28a99825", "metadata": { "id": "28a99825" @@ -124,8 +124,7 @@ }, { "cell_type": "code", - - "execution_count": 9, + "execution_count": null, "id": "4c16d71f", "metadata": { "colab": { @@ -160,7 +159,6 @@ "source": [ "location_info = iai.location_info(location=location,rendering_fov=RENDERING_FOV)\n", "rendered_map = location_info.birdview_image.decode()\n", - "fig, ax = plt.subplots(constrained_layout=True, figsize=(FIGURE_SIZE, FIGURE_SIZE))\n", "ax.set_axis_off(), ax.imshow(rendered_map)" ] @@ -168,13 +166,13 @@ { "cell_type": "code", "source": [ - "scene_plotter = iai.utils.ScenePlotter(rendered_map, RENDERING_FOV, (location_info.map_center.x, location_info.map_center.y), location_info.static_actors)" + "scene_plotter = iai.utils.ScenePlotter(location_info)" ], "metadata": { "id": "evQ3RY8EgVhH" }, "id": "evQ3RY8EgVhH", - "execution_count": 10, + "execution_count": null, "outputs": [] }, { @@ -190,7 +188,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "6119f9e0-fc50-474f-9171-34c8a54e7729", "metadata": { "id": "6119f9e0-fc50-474f-9171-34c8a54e7729" @@ -218,7 +216,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "id": "bf79f937", "metadata": { "colab": { @@ -255,15 +253,14 @@ "fig, ax = plt.subplots(constrained_layout=True, figsize=(FIGURE_SIZE, FIGURE_SIZE))\n", "ax.set_axis_off()\n", "scene_plotter.plot_scene(\n", - " response.agent_states,\n", - " response.agent_attributes,\n", - " traffic_light_states = light_response.traffic_lights_states,\n", + " agent_states=response.agent_states,\n", + " agent_attributes=response.agent_attributes,\n", + " traffic_light_states=light_response.traffic_lights_states,\n", " ax=ax,\n", " numbers=True,\n", " velocity_vec=False,\n", " direction_vec=True\n", ")" - ] }, { @@ -280,7 +277,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "id": "94506da0-9a15-4dc0-9d57-5ac30bc36d72", "metadata": { "colab": { @@ -300,7 +297,11 @@ ], "source": [ "agent_attributes = response.agent_attributes\n", - "scene_plotter.initialize_recording(response.agent_states, agent_attributes=agent_attributes, traffic_light_states=light_response.traffic_lights_states)\n", + "scene_plotter.initialize_recording(\n", + " agent_states=response.agent_states,\n", + " agent_attributes=agent_attributes,\n", + " traffic_light_states=light_response.traffic_lights_states\n", + ")\n", "updated_state = response\n", "times = []\n", "for t in range(SIMULATION_LENGTH):\n", @@ -344,12 +345,12 @@ "id": "S5gDA2WEh7Sf" }, "id": "S5gDA2WEh7Sf", - "execution_count": 29, + "execution_count": null, "outputs": [] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "id": "2c689647-4a87-4bef-8723-785424b6356c", "metadata": { "colab": { @@ -364,12 +365,10 @@ "output_type": "execute_result", "data": { "image/gif": "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\n", - "text/plain": [ "" ] }, - "metadata": { "image/gif": { "width": 1000, @@ -408,4 +407,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file From 677545aa320290ffa225a86477dd483834ba4130 Mon Sep 17 00:00:00 2001 From: Kieran Ratcliffe Date: Mon, 11 Sep 2023 10:25:18 -0700 Subject: [PATCH 16/19] Fixed numbers parameter data type issue. --- invertedai/__init__.py | 2 +- invertedai/utils.py | 17 ++++++++--------- 2 files changed, 9 insertions(+), 10 deletions(-) diff --git a/invertedai/__init__.py b/invertedai/__init__.py index da7c1c4a..4e21195b 100644 --- a/invertedai/__init__.py +++ b/invertedai/__init__.py @@ -53,4 +53,4 @@ "async_blame", ] -__version__ = importlib.metadata.version("invertedai") +__version__ = importlib.metadata.version("invertedai") \ No newline at end of file diff --git a/invertedai/utils.py b/invertedai/utils.py index 3b535486..793a3c41 100644 --- a/invertedai/utils.py +++ b/invertedai/utils.py @@ -722,7 +722,7 @@ def __init__( self.frame_label = None self.current_ax = None - self.numbers = False + self.numbers = None self.agent_face_colors = None self.agent_edge_colors = None @@ -802,7 +802,7 @@ def plot_scene( traffic_light_states: Optional[Dict[int, TrafficLightState]] = None, conditional_agents: Optional[List[int]] = None, ax: Optional[Axes] = None, - numbers: bool = False, + numbers: Optional[List[int]] = None, direction_vec: bool = True, velocity_vec: bool = False, agent_face_colors: Optional[List[Optional[Tuple[float,float,float]]]] = None, @@ -824,7 +824,7 @@ def plot_scene( ax: A matplotlib Axes object used to plot the image. By default, an Axes object is created if a value of None is passed. numbers: - Flag to determine if the ID's of all agents should be plotted in the image. By default this flag is set to False. + A list of agent ID's that should be plotted in the image. By default this value is set to None. direction_vec: Flag to determine if a vector showing the vehicles direction should be plotted in the image. By default this flag is set to True. velocity_vec: @@ -853,7 +853,7 @@ def animate_scene( start_idx: int = 0, end_idx: int = -1, ax: Optional[Axes] = None, - numbers: bool = False, + numbers: Optional[List[int]] = None, direction_vec: bool = True, velocity_vec: bool = False, plot_frame_number: bool = False, @@ -874,7 +874,7 @@ def animate_scene( ax: A matplotlib Axes object used to plot the animation. By default, an Axes object is created if a value of None is passed. numbers: - Flag to determine if the ID's of all agents should be plotted in the animation. By default this flag is set to False. + A list of agent ID's that should be plotted in the image. By default this value is set to None. direction_vec: Flag to determine if a vector showing the vehicles direction should be plotted in the animation. By default this flag is set to True. velocity_vec: @@ -911,7 +911,7 @@ def _validate_kwargs(self,arg_name,kwargs): raise Exception(f"Expected keyword argument '{arg_name}' but none was given.") - def _plot_frame(self, idx, ax=None, numbers=False, direction_vec=False, + def _plot_frame(self, idx, ax=None, numbers=None, direction_vec=False, velocity_vec=False, plot_frame_number=False): self._initialize_plot(ax=ax, numbers=numbers, direction_vec=direction_vec, velocity_vec=velocity_vec, plot_frame_number=plot_frame_number) @@ -929,7 +929,7 @@ def _validate_agent_style_data(self,agent_face_colors,agent_edge_colors): self.agent_face_colors = agent_face_colors self.agent_edge_colors = agent_edge_colors - def _initialize_plot(self, ax=None, numbers=False, direction_vec=True, + def _initialize_plot(self, ax=None, numbers=None, direction_vec=True, velocity_vec=False, plot_frame_number=False): if ax is None: plt.clf() @@ -1015,8 +1015,7 @@ def _update_agent(self, agent_idx, agent, agent_attribute): else: self.v_lines[agent_idx].set_xdata(box[2:4, 0]) self.v_lines[agent_idx].set_ydata(box[2:4, 1]) - if (type(self.numbers) == bool and self.numbers) or \ - (type(self.numbers) == list and agent_idx in self.numbers): + if self.numbers is not None and agent_idx in self.numbers: if agent_idx not in self.box_labels: self.box_labels[agent_idx] = self.current_ax.text( x, y, str(agent_idx), c='r', fontsize=18) From 9cd9c227cf7afdb69721352818bb118a53c94eca Mon Sep 17 00:00:00 2001 From: Kieran Ratcliffe Date: Wed, 13 Sep 2023 15:09:27 -0700 Subject: [PATCH 17/19] Added functionality for left-hand coordinate maps as well as fixing disappearing lights on large maps. --- invertedai/utils.py | 25 ++++++++++++++++++++++--- 1 file changed, 22 insertions(+), 3 deletions(-) diff --git a/invertedai/utils.py b/invertedai/utils.py index 793a3c41..4d21f580 100644 --- a/invertedai/utils.py +++ b/invertedai/utils.py @@ -647,6 +647,7 @@ def __init__( open_drive: Optional[str] = None, resolution: Tuple[int,int] = (640, 480), dpi: float = 100, + left_hand_coordinates: bool = False, **kwargs ): """ @@ -660,6 +661,8 @@ def __init__( The desired resolution of the map image expressed as a Tuple with two integers for the width and height respectively. dpi: Dots per inch to define the level of detail in the image. + left_hand_coordinates: + Boolean flag dictating whether the X-coordinates of all agents and actors should be reversed to fit a left hand coordinate system. Keyword Arguments ----------------- @@ -677,6 +680,8 @@ def __init__( :func:`location_info` """ + self.location_response = location_response + self._left_hand_coordinates = left_hand_coordinates self.conditional_agents = None self.agent_attributes = None self.traffic_lights_history = None @@ -751,7 +756,6 @@ def initialize_recording( conditional_agents: Optional parameter containing a list of agent IDs corresponding to conditional agents to be visualized to distinguish themselves. """ - self.agent_states_history = [agent_states] self.traffic_lights_history = [traffic_light_states] self.agent_attributes = agent_attributes @@ -790,7 +794,6 @@ def record_step( traffic_light_states: Optional parameter containing the state of the traffic lights corresponding to the initial time step to be visualized. This parameter should only be used if the corresponding map contains traffic light static actors. """ - self.agent_states_history.append(agent_states) self.traffic_lights_history.append(traffic_light_states) @@ -904,6 +907,15 @@ def animate(i): ani.save(f'{output_name}', writer='pillow', dpi=self._dpi) return ani + def _transform_point_to_left_hand_coordinate_frame(self,x,orientation): + t_x = 2*self.location_response.map_center.x - x + if orientation >= 0: + t_orientation = -orientation + math.pi + else: + t_orientation = -orientation - math.pi + + return t_x, t_orientation + def _validate_kwargs(self,arg_name,kwargs): if arg_name in kwargs: setattr(self,arg_name,kwargs[arg_name]) @@ -995,6 +1007,10 @@ def _update_agent(self, agent_idx, agent, agent_attribute): x, y = agent.center.x, agent.center.y v = agent.speed psi = agent.orientation + + if self._left_hand_coordinates: + x, psi = self._transform_point_to_left_hand_coordinate_frame(x,psi) + box = np.array([ [0, 0], [l * 0.5, 0], # direction vector [0, 0], [v * 0.5, 0], # speed vector at (0.5 m / s ) / m @@ -1048,7 +1064,10 @@ def _plot_traffic_light(self, light_id, light_state): light = self.traffic_lights[light_id] x, y = light.center.x, light.center.y psi = light.orientation - l, w = light.length, light.width + l, w = max(light.length,1.0), max(light.width,1.0) + + if self._left_hand_coordinates: + x, psi = self._transform_point_to_left_hand_coordinate_frame(x,psi) rect = Rectangle((x - l / 2, y - w / 2), l, w, angle=psi * 180 / np.pi, rotation_point='center', From e1635a5b492f7cd76a2dc05da3aae7af544b0f8d Mon Sep 17 00:00:00 2001 From: Kieran Ratcliffe Date: Mon, 11 Mar 2024 14:21:39 -0700 Subject: [PATCH 18/19] Updated documentation and other examples. --- examples/cosimulation_minimal_example.py | 5 ++++- examples/minimal_example.py | 7 ++++++- examples/npc_only.ipynb | 2 +- invertedai/utils.py | 11 ++++++++--- 4 files changed, 19 insertions(+), 6 deletions(-) diff --git a/examples/cosimulation_minimal_example.py b/examples/cosimulation_minimal_example.py index 72d376fd..e31ee7ff 100644 --- a/examples/cosimulation_minimal_example.py +++ b/examples/cosimulation_minimal_example.py @@ -47,7 +47,10 @@ def step(self, predicted_npc_states): location_info_response = iai.location_info(location=location) rendered_static_map = location_info_response.birdview_image.decode() -scene_plotter = iai.utils.ScenePlotter(location_info_response) +scene_plotter = iai.utils.ScenePlotter(rendered_static_map, + location_info_response.map_fov, + (location_info_response.map_center.x, location_info_response.map_center.y), + location_info_response.static_actors) scene_plotter.initialize_recording( agent_states=iai_simulation.agent_states, agent_attributes=iai_simulation.agent_attributes, diff --git a/examples/minimal_example.py b/examples/minimal_example.py index 2b9a046d..07d430ea 100644 --- a/examples/minimal_example.py +++ b/examples/minimal_example.py @@ -25,7 +25,12 @@ location_info_response = iai.location_info(location=location) rendered_static_map = location_info_response.birdview_image.decode() -scene_plotter = iai.utils.ScenePlotter(location_info_response) +scene_plotter = iai.utils.ScenePlotter( + rendered_static_map, + location_info_response.map_fov, + (location_info_response.map_center.x, location_info_response.map_center.y), + location_info_response.static_actors +) scene_plotter.initialize_recording( agent_states=response.agent_states, agent_attributes=agent_attributes, diff --git a/examples/npc_only.ipynb b/examples/npc_only.ipynb index 89cc3cdb..de5e2317 100644 --- a/examples/npc_only.ipynb +++ b/examples/npc_only.ipynb @@ -402,7 +402,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.8.18" } }, "nbformat": 4, diff --git a/invertedai/utils.py b/invertedai/utils.py index a98e18ca..a4121ef6 100644 --- a/invertedai/utils.py +++ b/invertedai/utils.py @@ -700,7 +700,6 @@ class ScenePlotter(): @validate_arguments def __init__( self, - # location_response: Optional[LocationResponse] = None, map_image: Optional[np.array] = None, fov: Optional[float] = None, xy_offset: Optional[Tuple[float,float]] = None, @@ -714,8 +713,14 @@ def __init__( """ Arguments ---------- - location_response: - A LocationResponse object taken from calling iai.location_info() containing relevant data regarding the location of the scene including the map image. + map_image: + An image used as the background for the visualization decoded from the birdview map taken from location info. + fov: + A single float value representing the field of view of the visualization that can be taken from location info. + xy_offset: + A tuple coordinate of the center of the map in metres that can be taken from location info. + static_actors: + A list of StaticMapActor objects representing objects such as traffic lights that can be taken from location info. open_drive: If using an ASAM OpenDRIVE format map for visualization, this string parameter is used to indicate the path to the corresponding CSV file. resolution: From 9ec2ea51926eaf112ce4e5c44b0aaedf533c8cca Mon Sep 17 00:00:00 2001 From: KieranRatcliffeInvertedAI Date: Thu, 1 Aug 2024 11:18:20 -0700 Subject: [PATCH 19/19] Fixed agent properties addition in scene plotter. --- invertedai/utils.py | 28 +++++++++++++++++++--------- 1 file changed, 19 insertions(+), 9 deletions(-) diff --git a/invertedai/utils.py b/invertedai/utils.py index e6545177..5837dfb9 100644 --- a/invertedai/utils.py +++ b/invertedai/utils.py @@ -865,7 +865,7 @@ def reset_recording(self): self.traffic_lights_history = [] self.agent_properties = None self.conditional_agents = [] - self.agent_attributes = None + self.agent_properties = None self.agent_face_colors = None self.agent_edge_colors = None @@ -893,7 +893,8 @@ def record_step( def plot_scene( self, agent_states: List[AgentState], - agent_attributes: List[AgentAttributes], + agent_attributes: Optional[List[AgentAttributes]] = None, + agent_properties: Optional[List[AgentProperties]] = None, traffic_light_states: Optional[Dict[int, TrafficLightState]] = None, conditional_agents: Optional[List[int]] = None, ax: Optional[Axes] = None, @@ -913,6 +914,9 @@ def plot_scene( agent_attributes: Static attributes of the agent, which don’t change over the course of a simulation. We assume every agent is a rectangle obeying a kinematic bicycle model. + agent_properties: + Static attributes of the agent (with the AgentProperties data type), which don’t change over the course of a simulation. We assume every + agent is a rectangle obeying a kinematic bicycle model. traffic_light_states: Optional parameter containing the state of the traffic lights to be visualized in the image. This parameter should only be used if the corresponding map contains traffic light static actors. @@ -934,16 +938,22 @@ def plot_scene( index ID. A value of None in this list will use the default color. This value gets overwritten by the conditional agent color. """ + assert (agent_attributes is not None) ^ (agent_properties is not None), \ + "Either agent_attributes or agent_properties is populated. Populating both or neither field is invalid." + + if agent_attributes is not None: + agent_properties = [convert_attributes_to_properties(attr) for attr in agent_attributes] + self.initialize_recording( - agent_states, - agent_attributes, + agent_states=agent_states, + agent_properties=agent_properties, traffic_light_states=traffic_light_states, conditional_agents=conditional_agents ) self._validate_agent_style_data( - agent_face_colors, - agent_edge_colors + agent_face_colors=agent_face_colors, + agent_edge_colors=agent_edge_colors ) self._plot_frame( @@ -1033,12 +1043,12 @@ def _plot_frame(self, idx, ax=None, numbers=None, direction_vec=False, self._update_frame_to(idx) def _validate_agent_style_data(self,agent_face_colors,agent_edge_colors): - if self.agent_attributes is not None: + if self.agent_properties is not None: if agent_face_colors is not None: - if len(agent_face_colors) != len(self.agent_attributes): + if len(agent_face_colors) != len(self.agent_properties): raise Exception("Number of agent face colors does not match number of agents.") if agent_edge_colors is not None: - if len(agent_edge_colors) != len(self.agent_attributes): + if len(agent_edge_colors) != len(self.agent_properties): raise Exception("Number of agent edge colors does not match number of agents.") self.agent_face_colors = agent_face_colors