data_preprocessing_map.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "======\n",
      "Loading NuScenes tables for version v1.0-mini...\n",
      "23 category,\n",
      "8 attribute,\n",
      "4 visibility,\n",
      "911 instance,\n",
      "12 sensor,\n",
      "120 calibrated_sensor,\n",
      "31206 ego_pose,\n",
      "8 log,\n",
      "10 scene,\n",
      "404 sample,\n",
      "31206 sample_data,\n",
      "18538 sample_annotation,\n",
      "4 map,\n",
      "Done loading in 0.8 seconds.\n",
      "======\n",
      "Reverse indexing ...\n",
      "Done reverse indexing in 0.2 seconds.\n",
      "======\n"
     ]
    }
   ],
   "source": [
    "import colorsys\n",
    "import os\n",
    "\n",
    "import cv2\n",
    "import numpy as np\n",
    "from pyquaternion import Quaternion\n",
    "\n",
    "from nuscenes.eval.common.utils import quaternion_yaw\n",
    "from nuscenes.map_expansion.map_api import NuScenesMap\n",
    "from nuscenes.prediction.helper import angle_of_rotation, angle_diff\n",
    "from nuscenes.prediction.input_representation.combinators import Rasterizer\n",
    "from nuscenes.prediction.input_representation.interface import \\\n",
    "    StaticLayerRepresentation, AgentRepresentation\n",
    "from nuscenes.prediction.input_representation.utils import get_crops, get_rotation_matrix, convert_to_pixel_coords\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "from nuscenes.prediction.input_representation.combinators import Rasterizer\n",
    "from nuscenes.prediction import PredictHelper\n",
    "\n",
    "from typing import Any, Dict, List, Tuple, Callable\n",
    "\n",
    "from nuscenes.prediction.helper import quaternion_yaw\n",
    "\n",
    "%matplotlib inline\n",
    "from nuscenes.nuscenes import NuScenes\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import copy\n",
    "import PIL\n",
    "import os\n",
    "from skimage import color\n",
    "from nuscenes.utils.geometry_utils import view_points, box_in_image, BoxVisibility, transform_matrix\n",
    "from nuscenes.utils.data_classes import LidarPointCloud\n",
    "from pyquaternion import Quaternion\n",
    "nusc = NuScenes(version='v1.0-mini', dataroot='/datasets/home/44/344/abkandoi/nuscenes-mini-data', verbose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "History = Dict[str, List[Dict[str, Any]]]\n",
    "\n",
    "\n",
    "def pixels_to_box_corners(row_pixel: int,\n",
    "                          column_pixel: int,\n",
    "                          length_in_pixels: float,\n",
    "                          width_in_pixels: float,\n",
    "                          yaw_in_radians: float) -> np.ndarray:\n",
    "    \"\"\"\n",
    "    Computes four corners of 2d bounding box for agent.\n",
    "    The coordinates of the box are in pixels.\n",
    "    :param row_pixel: Row pixel of the agent.\n",
    "    :param column_pixel: Column pixel of the agent.\n",
    "    :param length_in_pixels: Length of the agent.\n",
    "    :param width_in_pixels: Width of the agent.\n",
    "    :param yaw_in_radians: Yaw of the agent (global coordinates).\n",
    "    :return: numpy array representing the four corners of the agent.\n",
    "    \"\"\"\n",
    "\n",
    "    # cv2 has the convention where they flip rows and columns so it matches\n",
    "    # the convention of x and y on a coordinate plane\n",
    "    # Also, a positive angle is a clockwise rotation as opposed to counterclockwise\n",
    "    # so that is why we negate the rotation angle\n",
    "    coord_tuple = ((column_pixel, row_pixel), (length_in_pixels, width_in_pixels), -yaw_in_radians * 180 / np.pi)\n",
    "\n",
    "    box = cv2.boxPoints(coord_tuple)\n",
    "\n",
    "    return box\n",
    "\n",
    "\n",
    "def get_track_box(annotation: Dict[str, Any],\n",
    "                  center_coordinates: Tuple[float, float],\n",
    "                  center_pixels: Tuple[float, float],\n",
    "                  resolution: float = 0.1) -> np.ndarray:\n",
    "    \"\"\"\n",
    "    Get four corners of bounding box for agent in pixels.\n",
    "    :param annotation: The annotation record of the agent.\n",
    "    :param center_coordinates: (x, y) coordinates in global frame\n",
    "        of the center of the image.\n",
    "    :param center_pixels: (row_index, column_index) location of the center\n",
    "        of the image in pixel coordinates.\n",
    "    :param resolution: Resolution pixels/meter of the image.\n",
    "    \"\"\"\n",
    "\n",
    "    assert resolution > 0\n",
    "\n",
    "    location = annotation['translation'][:2]\n",
    "    yaw_in_radians = quaternion_yaw(Quaternion(annotation['rotation']))\n",
    "\n",
    "    #print('yaw_in_radians', yaw_in_radians)\n",
    "    row_pixel, column_pixel = convert_to_pixel_coords(location,\n",
    "                                                      center_coordinates,\n",
    "                                                      center_pixels, resolution)\n",
    "    #print('row_pixel, column_pixel', row_pixel, column_pixel)\n",
    "    #print('center_pixels', center_pixels)\n",
    "\n",
    "    width = annotation['size'][0] / resolution\n",
    "    length = annotation['size'][1] / resolution\n",
    "\n",
    "    # Width and length are switched here so that we can draw them along the x-axis as\n",
    "    # opposed to the y. This makes rotation easier.\n",
    "    return pixels_to_box_corners(row_pixel, column_pixel, length, width, yaw_in_radians)\n",
    "\n",
    "\n",
    "def reverse_history(history: History) -> History:\n",
    "    \"\"\"\n",
    "    Reverse history so that most distant observations are first.\n",
    "    We do this because we want to draw more recent bounding boxes on top of older ones.\n",
    "    :param history: result of get_past_for_sample PredictHelper method.\n",
    "    :return: History with the values reversed.\n",
    "    \"\"\"\n",
    "    return {token: anns[::-1] for token, anns in history.items()}\n",
    "\n",
    "\n",
    "def add_present_time_to_history(current_time: List[Dict[str, Any]],\n",
    "                                history: History) -> History:\n",
    "    \"\"\"\n",
    "    Adds the sample annotation records from the current time to the\n",
    "    history object.\n",
    "    :param current_time: List of sample annotation records from the\n",
    "        current time. Result of get_annotations_for_sample method of\n",
    "        PredictHelper.\n",
    "    :param history: Result of get_past_for_sample method of PredictHelper.\n",
    "    :return: History with values from current_time appended.\n",
    "    \"\"\"\n",
    "\n",
    "    for annotation in current_time:\n",
    "        token = annotation['instance_token']\n",
    "\n",
    "        if token in history:\n",
    "\n",
    "            # We append because we've reversed the history\n",
    "            history[token].append(annotation)\n",
    "\n",
    "        else:\n",
    "            history[token] = [annotation]\n",
    "\n",
    "    return history\n",
    "\n",
    "\n",
    "def fade_color(color: Tuple[int, int, int],\n",
    "               step: int,\n",
    "               total_number_of_steps: int) -> Tuple[int, int, int]:\n",
    "    \"\"\"\n",
    "    Fades a color so that past observations are darker in the image.\n",
    "    :param color: Tuple of ints describing an RGB color.\n",
    "    :param step: The current time step.\n",
    "    :param total_number_of_steps: The total number of time steps\n",
    "        the agent has in the image.\n",
    "    :return: Tuple representing faded rgb color.\n",
    "    \"\"\"\n",
    "\n",
    "    LOWEST_VALUE = 0.4\n",
    "\n",
    "    if step == total_number_of_steps:\n",
    "        return color\n",
    "\n",
    "    hsv_color = colorsys.rgb_to_hsv(*color)\n",
    "\n",
    "    increment = (float(hsv_color[2])/255. - LOWEST_VALUE) / total_number_of_steps\n",
    "\n",
    "    new_value = LOWEST_VALUE + step * increment\n",
    "\n",
    "    new_rgb = colorsys.hsv_to_rgb(float(hsv_color[0]),\n",
    "                                  float(hsv_color[1]),\n",
    "                                  new_value * 255.)\n",
    "    return new_rgb\n",
    "\n",
    "\n",
    "def default_colors(category_name: str) -> Tuple[int, int, int]:\n",
    "    \"\"\"\n",
    "    Maps a category name to an rgb color (without fading).\n",
    "    :param category_name: Name of object category for the annotation.\n",
    "    :return: Tuple representing rgb color.\n",
    "    \"\"\"\n",
    "\n",
    "    if 'vehicle' in category_name:\n",
    "        return 255, 255, 0  # yellow\n",
    "    elif 'object' in category_name:\n",
    "        return 204, 0, 204  # violet\n",
    "    elif 'human' in category_name or 'animal' in category_name:\n",
    "        return 255, 153, 51  # orange\n",
    "    else:\n",
    "        raise ValueError(f\"Cannot map {category_name} to a color.\")\n",
    "\n",
    "\n",
    "def draw_agent_boxes(center_agent_annotation: Dict[str, Any],\n",
    "                     center_agent_pixels: Tuple[float, float],\n",
    "                     agent_history: History,\n",
    "                     base_image: np.ndarray,\n",
    "                     get_color: Callable[[str], Tuple[int, int, int]],\n",
    "                     resolution: float = 0.1) -> None:\n",
    "    \"\"\"\n",
    "    Draws past sequence of agent boxes on the image.\n",
    "    :param center_agent_annotation: Annotation record for the agent\n",
    "        that is in the center of the image.\n",
    "    :param center_agent_pixels: Pixel location of the agent in the\n",
    "        center of the image.\n",
    "    :param agent_history: History for all agents in the scene.\n",
    "    :param base_image: Image to draw the agents in.\n",
    "    :param get_color: Mapping from category_name to RGB tuple.\n",
    "    :param resolution: Size of the image in pixels / meter.\n",
    "    :return: None.\n",
    "    \"\"\"\n",
    "\n",
    "    agent_x, agent_y = center_agent_annotation['translation'][:2]\n",
    "    print('agent_x, agent_y are', agent_x, agent_y)\n",
    "\n",
    "    for instance_token, annotations in agent_history.items():\n",
    "\n",
    "        num_points = len(annotations)\n",
    "\n",
    "        for i, annotation in enumerate(annotations):\n",
    "            #if instance_token != center_agent_annotation['instance_token']:\n",
    "            #    continue\n",
    "\n",
    "            box = get_track_box(annotation, (agent_x, agent_y+25), center_agent_pixels, resolution)\n",
    "            #box2 = get_track_box(annotation, (agent_x, agent_y), center_agent_pixels, resolution)\n",
    "            #cv2.fillPoly(base_image, pts=[np.int0(box2)], color=(255,0,0))\n",
    "            #print(box)\n",
    "            #print(box.shape)\n",
    "\n",
    "            if instance_token == center_agent_annotation['instance_token']:\n",
    "                #continue\n",
    "                color = (255, 0, 0)\n",
    "                print('center agent')\n",
    "            else:\n",
    "                #continue\n",
    "                if 'object' in annotation['category_name']:\n",
    "                    #print(annotation['category_name'])\n",
    "                    continue\n",
    "                    color = get_color(annotation['category_name'])\n",
    "                    color = (255,255,255)\n",
    "                else:\n",
    "                    color = (255,255,255)\n",
    "\n",
    "            # Don't fade the colors if there is no history\n",
    "            if num_points > 1:\n",
    "                #color = (0,0,0)\n",
    "                color = fade_color(color, i, num_points - 1)\n",
    "            if color == (255,0,0):\n",
    "                color = (255,255,255)\n",
    "            cv2.fillPoly(base_image, pts=[np.int0(box)], color=color)\n",
    "\n",
    "def get_target_vehicle_box(ego_pose: Dict[str, Any],\n",
    "                  center_coordinates: Tuple[float, float],\n",
    "                  center_pixels: Tuple[float, float],\n",
    "                  resolution: float = 0.1) -> np.ndarray:\n",
    "    location = ego_pose['translation'][:2]\n",
    "    yaw_in_radians = quaternion_yaw(Quaternion(ego_pose['rotation']))\n",
    "\n",
    "    row_pixel, column_pixel = convert_to_pixel_coords(location,\n",
    "                                                      center_coordinates,\n",
    "                                                      center_pixels, resolution)\n",
    "    \n",
    "    width = 2 / resolution\n",
    "    length = 5 / resolution\n",
    "\n",
    "    # Width and length are switched here so that we can draw them along the x-axis as\n",
    "    # opposed to the y. This makes rotation easier.\n",
    "    return pixels_to_box_corners(row_pixel, column_pixel, length, width, yaw_in_radians)\n",
    "            \n",
    "def draw_target_vehicle(ego_pose: Dict[str, Any],\n",
    "                        ref_ego_pose: Dict[str, Any],\n",
    "                        center_agent_pixels: Tuple[float, float],\n",
    "                        base_image: np.ndarray,\n",
    "                        resolution: float = 0.1) -> None:\n",
    "    color = (255, 255, 255)\n",
    "    ref_loc_x, ref_loc_y = ref_ego_pose['translation'][:2]\n",
    "    box = get_target_vehicle_box(ego_pose, (ref_loc_x, ref_loc_y), center_agent_pixels, resolution)\n",
    "    \n",
    "    cv2.fillPoly(base_image, pts=[np.int0(box)], color=color)\n",
    "    \n",
    "def draw_target_vehicle_red(ego_pose: Dict[str, Any],\n",
    "                        ref_ego_pose: Dict[str, Any],\n",
    "                        center_agent_pixels: Tuple[float, float],\n",
    "                        base_image: np.ndarray,\n",
    "                        resolution: float = 0.1) -> None:\n",
    "    color = (255, 0, 0)\n",
    "    ref_loc_x, ref_loc_y = ref_ego_pose['translation'][:2]\n",
    "    box = get_target_vehicle_box(ego_pose, (ref_loc_x, ref_loc_y), center_agent_pixels, resolution)\n",
    "    \n",
    "    cv2.fillPoly(base_image, pts=[np.int0(box)], color=color)\n",
    "    \n",
    "def draw_other_vehicle_boxes(ref_ego_pose: Dict[str, Any],\n",
    "                        center_agent_pixels: Tuple[float, float],\n",
    "                        vehicle_history: History,\n",
    "                        base_image: np.ndarray,\n",
    "                        resolution: float = 0.1) -> None:\n",
    "    color = (255, 255, 255)\n",
    "    ref_loc_x, ref_loc_y = ref_ego_pose['translation'][:2]\n",
    "\n",
    "    for instance_token, annotations in vehicle_history.items():\n",
    "\n",
    "        num_points = len(annotations)\n",
    "\n",
    "        for i, annotation in enumerate(annotations):\n",
    "\n",
    "            box = get_track_box(annotation, (ref_loc_x, ref_loc_y), center_agent_pixels, resolution)\n",
    "\n",
    "            if 'object' in annotation['category_name']:\n",
    "                continue\n",
    "            \n",
    "            cv2.fillPoly(base_image, pts=[np.int0(box)], color=color)\n",
    "\n",
    "def draw_obstacle_boxes(ref_ego_pose: Dict[str, Any],\n",
    "                        center_agent_pixels: Tuple[float, float],\n",
    "                        vehicle_history: History,\n",
    "                        base_image: np.ndarray,\n",
    "                        resolution: float = 0.1) -> None:\n",
    "    color = (255, 255, 255)\n",
    "    ref_loc_x, ref_loc_y = ref_ego_pose['translation'][:2]\n",
    "\n",
    "    for instance_token, annotations in vehicle_history.items():\n",
    "\n",
    "        num_points = len(annotations)\n",
    "\n",
    "        for i, annotation in enumerate(annotations):\n",
    "\n",
    "            box = get_track_box(annotation, (ref_loc_x, ref_loc_y), center_agent_pixels, resolution)\n",
    "\n",
    "            if 'object' not in annotation['category_name']:\n",
    "                continue\n",
    "            \n",
    "            cv2.fillPoly(base_image, pts=[np.int0(box)], color=color)            \n",
    "            \n",
    "class ObstacleAgentRepresentation(AgentRepresentation):\n",
    "    def __init__(self, helper: PredictHelper,\n",
    "                 resolution: float = 0.1,  # meters / pixel\n",
    "                 meters_ahead: float = 40, meters_behind: float = 10,\n",
    "                 meters_left: float = 25, meters_right: float = 25):\n",
    "        self.helper = helper\n",
    "        \n",
    "        if not resolution > 0:\n",
    "            raise ValueError(f\"Resolution must be positive. Received {resolution}.\")\n",
    "        \n",
    "        self.resolution = resolution\n",
    "        \n",
    "        self.meters_ahead = meters_ahead\n",
    "        self.meters_behind = meters_behind\n",
    "        self.meters_left = meters_left\n",
    "        self.meters_right = meters_right\n",
    "    \n",
    "    def make_representation(self, ego_pose: Dict[str, Any],\n",
    "                            ref_ego_pose: Dict[str, Any],\n",
    "                            sample_token: str) -> np.ndarray:\n",
    "        # Taking radius around track before to ensure all actors are in image\n",
    "        buffer = max([self.meters_ahead, self.meters_behind,\n",
    "                      self.meters_left, self.meters_right]) * 2\n",
    "\n",
    "        image_side_length = int(buffer/self.resolution)\n",
    "        \n",
    "        # We will center the track in the image\n",
    "        central_track_pixels = ((image_side_length / 2), (image_side_length / 2))\n",
    "\n",
    "        base_image = np.zeros((image_side_length, image_side_length, 3))\n",
    "        \n",
    "        history = self.helper.get_past_for_sample(sample_token,\n",
    "                                                  0,\n",
    "                                                  in_agent_frame=False,\n",
    "                                                  just_xy=False)\n",
    "        history = reverse_history(history)\n",
    "\n",
    "        present_time = self.helper.get_annotations_for_sample(sample_token)\n",
    "\n",
    "        history = add_present_time_to_history(present_time, history)\n",
    "        \n",
    "\n",
    "        draw_obstacle_boxes(ref_ego_pose, central_track_pixels,\n",
    "                         history, base_image, resolution=self.resolution)\n",
    "        \n",
    "        \n",
    "        ref_pose_yaw = quaternion_yaw(Quaternion(ref_ego_pose['rotation']))\n",
    "        rotation_mat = get_rotation_matrix(base_image.shape, ref_pose_yaw+np.pi/2)\n",
    "\n",
    "        rotated_image = cv2.warpAffine(base_image, rotation_mat, (base_image.shape[1],\n",
    "                                                                  base_image.shape[0]))\n",
    "\n",
    "        row_crop, col_crop = get_crops(self.meters_ahead, self.meters_behind,\n",
    "                                       self.meters_left, self.meters_right, self.resolution,\n",
    "                                       image_side_length)\n",
    "\n",
    "        return rotated_image[row_crop, col_crop].astype('uint8')\n",
    "    \n",
    "class OtherVehicleRepresentation(AgentRepresentation):\n",
    "    def __init__(self, helper: PredictHelper,\n",
    "                 resolution: float = 0.1,  # meters / pixel\n",
    "                 meters_ahead: float = 40, meters_behind: float = 10,\n",
    "                 meters_left: float = 25, meters_right: float = 25):\n",
    "        self.helper = helper\n",
    "        \n",
    "        if not resolution > 0:\n",
    "            raise ValueError(f\"Resolution must be positive. Received {resolution}.\")\n",
    "        \n",
    "        self.resolution = resolution\n",
    "        \n",
    "        self.meters_ahead = meters_ahead\n",
    "        self.meters_behind = meters_behind\n",
    "        self.meters_left = meters_left\n",
    "        self.meters_right = meters_right\n",
    "    \n",
    "    def make_representation(self, ego_pose: Dict[str, Any],\n",
    "                            ref_ego_pose: Dict[str, Any],\n",
    "                            sample_token: str) -> np.ndarray:\n",
    "        # Taking radius around track before to ensure all actors are in image\n",
    "        buffer = max([self.meters_ahead, self.meters_behind,\n",
    "                      self.meters_left, self.meters_right]) * 2\n",
    "\n",
    "        image_side_length = int(buffer/self.resolution)\n",
    "        \n",
    "        # We will center the track in the image\n",
    "        central_track_pixels = ((image_side_length / 2), (image_side_length / 2))\n",
    "\n",
    "        base_image = np.zeros((image_side_length, image_side_length, 3))\n",
    "        \n",
    "        history = self.helper.get_past_for_sample(sample_token,\n",
    "                                                  0,\n",
    "                                                  in_agent_frame=False,\n",
    "                                                  just_xy=False)\n",
    "        history = reverse_history(history)\n",
    "\n",
    "        present_time = self.helper.get_annotations_for_sample(sample_token)\n",
    "\n",
    "        history = add_present_time_to_history(present_time, history)\n",
    "        \n",
    "\n",
    "        draw_other_vehicle_boxes(ref_ego_pose, central_track_pixels,\n",
    "                         history, base_image, resolution=self.resolution)\n",
    "        \n",
    "        #draw_target_vehicle_red(ego_pose, ref_ego_pose, central_track_pixels,\n",
    "        #                     base_image, resolution=self.resolution)\n",
    "        \n",
    "        ref_pose_yaw = quaternion_yaw(Quaternion(ref_ego_pose['rotation']))\n",
    "        rotation_mat = get_rotation_matrix(base_image.shape, ref_pose_yaw+np.pi/2)\n",
    "\n",
    "        rotated_image = cv2.warpAffine(base_image, rotation_mat, (base_image.shape[1],\n",
    "                                                                  base_image.shape[0]))\n",
    "\n",
    "        row_crop, col_crop = get_crops(self.meters_ahead, self.meters_behind,\n",
    "                                       self.meters_left, self.meters_right, self.resolution,\n",
    "                                       image_side_length)\n",
    "\n",
    "        return rotated_image[row_crop, col_crop].astype('uint8')\n",
    "        \n",
    "    \n",
    "class TargetVehicleRepresentation(AgentRepresentation):\n",
    "    def __init__(self, helper: PredictHelper,\n",
    "                 resolution: float = 0.1,  # meters / pixel\n",
    "                 meters_ahead: float = 40, meters_behind: float = 10,\n",
    "                 meters_left: float = 25, meters_right: float = 25):\n",
    "        self.helper = helper\n",
    "        \n",
    "        if not resolution > 0:\n",
    "            raise ValueError(f\"Resolution must be positive. Received {resolution}.\")\n",
    "        \n",
    "        self.resolution = resolution\n",
    "        \n",
    "        self.meters_ahead = meters_ahead\n",
    "        self.meters_behind = meters_behind\n",
    "        self.meters_left = meters_left\n",
    "        self.meters_right = meters_right\n",
    "    \n",
    "    def make_representation(self, ego_pose: Dict[str, Any],\n",
    "                            ref_ego_pose: Dict[str, Any],\n",
    "                            sample_token: str) -> np.ndarray:\n",
    "        # Taking radius around track before to ensure all actors are in image\n",
    "        buffer = max([self.meters_ahead, self.meters_behind,\n",
    "                      self.meters_left, self.meters_right]) * 2\n",
    "\n",
    "        image_side_length = int(buffer/self.resolution)\n",
    "        \n",
    "        # We will center the track in the image\n",
    "        central_track_pixels = ((image_side_length / 2), (image_side_length / 2))\n",
    "\n",
    "        base_image = np.zeros((image_side_length, image_side_length, 3))\n",
    "        \n",
    "        draw_target_vehicle(ego_pose, ref_ego_pose, central_track_pixels,\n",
    "                             base_image, resolution=self.resolution)\n",
    "        \n",
    "        #return base_image.astype('uint8')\n",
    "        \n",
    "        ref_pose_yaw = quaternion_yaw(Quaternion(ref_ego_pose['rotation']))\n",
    "        rotation_mat = get_rotation_matrix(base_image.shape, ref_pose_yaw+np.pi/2)\n",
    "\n",
    "        rotated_image = cv2.warpAffine(base_image, rotation_mat, (base_image.shape[1],\n",
    "                                                                  base_image.shape[0]))\n",
    "\n",
    "        row_crop, col_crop = get_crops(self.meters_ahead, self.meters_behind,\n",
    "                                       self.meters_left, self.meters_right, self.resolution,\n",
    "                                       image_side_length)\n",
    "\n",
    "        return rotated_image[row_crop, col_crop].astype('uint8')\n",
    "        \n",
    "        \n",
    "        \n",
    "            \n",
    "class AgentBoxesWithFadedHistory(AgentRepresentation):\n",
    "    \"\"\"\n",
    "    Represents the past sequence of agent states as a three-channel\n",
    "    image with faded 2d boxes.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, helper: PredictHelper,\n",
    "                 seconds_of_history: float = 2,\n",
    "                 frequency_in_hz: float = 2,\n",
    "                 resolution: float = 0.1,  # meters / pixel\n",
    "                 meters_ahead: float = 40, meters_behind: float = 10,\n",
    "                 meters_left: float = 25, meters_right: float = 25,\n",
    "                 color_mapping: Callable[[str], Tuple[int, int, int]] = None):\n",
    "\n",
    "        self.helper = helper\n",
    "        self.seconds_of_history = seconds_of_history\n",
    "        self.frequency_in_hz = frequency_in_hz\n",
    "\n",
    "        if not resolution > 0:\n",
    "            raise ValueError(f\"Resolution must be positive. Received {resolution}.\")\n",
    "\n",
    "        self.resolution = resolution\n",
    "\n",
    "        self.meters_ahead = meters_ahead\n",
    "        self.meters_behind = meters_behind\n",
    "        self.meters_left = meters_left\n",
    "        self.meters_right = meters_right\n",
    "\n",
    "        if not color_mapping:\n",
    "            color_mapping = default_colors\n",
    "\n",
    "        self.color_mapping = color_mapping\n",
    "\n",
    "    def make_representation(self, instance_token: str, sample_token: str) -> np.ndarray:\n",
    "        \"\"\"\n",
    "        Draws agent boxes with faded history into a black background.\n",
    "        :param instance_token: Instance token.\n",
    "        :param sample_token: Sample token.\n",
    "        :return: np.ndarray representing a 3 channel image.\n",
    "        \"\"\"\n",
    "\n",
    "        # Taking radius around track before to ensure all actors are in image\n",
    "        buffer = max([self.meters_ahead, self.meters_behind,\n",
    "                      self.meters_left, self.meters_right]) * 2\n",
    "\n",
    "        image_side_length = int(buffer/self.resolution)\n",
    "\n",
    "        # We will center the track in the image\n",
    "        central_track_pixels = ((image_side_length / 2), (image_side_length / 2))\n",
    "\n",
    "        base_image = np.zeros((image_side_length, image_side_length, 3))\n",
    "\n",
    "        history = self.helper.get_past_for_sample(sample_token,\n",
    "                                                  self.seconds_of_history,\n",
    "                                                  in_agent_frame=False,\n",
    "                                                  just_xy=False)\n",
    "        history = reverse_history(history)\n",
    "\n",
    "        present_time = self.helper.get_annotations_for_sample(sample_token)\n",
    "\n",
    "        history = add_present_time_to_history(present_time, history)\n",
    "\n",
    "        center_agent_annotation = self.helper.get_sample_annotation(instance_token, sample_token)\n",
    "\n",
    "        draw_agent_boxes(center_agent_annotation, central_track_pixels,\n",
    "                         history, base_image, resolution=self.resolution, get_color=self.color_mapping)\n",
    "\n",
    "        center_agent_yaw = quaternion_yaw(Quaternion(center_agent_annotation['rotation']))\n",
    "        rotation_mat = get_rotation_matrix(base_image.shape, center_agent_yaw)\n",
    "#         return base_image.astype('uint8')\n",
    "\n",
    "        rotated_image = cv2.warpAffine(base_image, rotation_mat, (base_image.shape[1],\n",
    "                                                                  base_image.shape[0]))\n",
    "\n",
    "        row_crop, col_crop = get_crops(self.meters_ahead, self.meters_behind,\n",
    "                                       self.meters_left, self.meters_right, self.resolution,\n",
    "                                       image_side_length)\n",
    "\n",
    "        return rotated_image[row_crop, col_crop].astype('uint8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "Color = Tuple[float, float, float]\n",
    "\n",
    "\n",
    "def load_all_maps(helper: PredictHelper) -> Dict[str, NuScenesMap]:\n",
    "    \"\"\"\n",
    "    Loads all NuScenesMap instances for all available maps.\n",
    "    :param helper: Instance of PredictHelper.\n",
    "    :return: Mapping from map-name to the NuScenesMap api instance.\n",
    "    \"\"\"\n",
    "    dataroot = helper.data.dataroot\n",
    "\n",
    "    json_files = filter(lambda f: \"json\" in f and \"prediction_scenes\" not in f,\n",
    "                        os.listdir(os.path.join(dataroot, \"maps\")))\n",
    "    maps = {}\n",
    "\n",
    "    for map_file in json_files:\n",
    "\n",
    "        map_name = str(map_file.split(\".\")[0])\n",
    "\n",
    "        print(f'static_layers.py - Loading Map: {map_name}')\n",
    "\n",
    "        maps[map_name] = NuScenesMap(dataroot, map_name=map_name)\n",
    "\n",
    "    return maps\n",
    "\n",
    "\n",
    "def get_patchbox(x_in_meters: float, y_in_meters: float,\n",
    "                 image_side_length: float) -> Tuple[float, float, float, float]:\n",
    "    \"\"\"\n",
    "    Gets the patchbox representing the area to crop the base image.\n",
    "    :param x_in_meters: X coordinate.\n",
    "    :param y_in_meters: Y coordiante.\n",
    "    :param image_side_length: Length of the image.\n",
    "    :return: Patch box tuple.\n",
    "    \"\"\"\n",
    "\n",
    "    patch_box = (x_in_meters, y_in_meters, image_side_length, image_side_length)\n",
    "\n",
    "    return patch_box\n",
    "\n",
    "\n",
    "def change_color_of_binary_mask(image: np.ndarray, color: Color) -> np.ndarray:\n",
    "    \"\"\"\n",
    "    Changes color of binary mask. The image has values 0 or 1 but has three channels.\n",
    "    :param image: Image with either 0 or 1 values and three channels.\n",
    "    :param color: RGB color tuple.\n",
    "    :return: Image with color changed (type uint8).\n",
    "    \"\"\"\n",
    "\n",
    "    image = image * color\n",
    "\n",
    "    # Return as type int so cv2 can manipulate it later.\n",
    "    image = image.astype(\"uint8\")\n",
    "\n",
    "    return image\n",
    "\n",
    "\n",
    "def correct_yaw(yaw: float) -> float:\n",
    "    \"\"\"\n",
    "    nuScenes maps were flipped over the y-axis, so we need to\n",
    "    add pi to the angle needed to rotate the heading.\n",
    "    :param yaw: Yaw angle to rotate the image.\n",
    "    :return: Yaw after correction.\n",
    "    \"\"\"\n",
    "    if yaw <= 0:\n",
    "        yaw = -np.pi - yaw\n",
    "    else:\n",
    "        yaw = np.pi - yaw\n",
    "\n",
    "    return yaw\n",
    "\n",
    "\n",
    "def get_lanes_in_radius(x: float, y: float, radius: float,\n",
    "                        discretization_meters: float,\n",
    "                        map_api: NuScenesMap) -> Dict[str, List[Tuple[float, float, float]]]:\n",
    "    \"\"\"\n",
    "    Retrieves all the lanes and lane connectors in a radius of the query point.\n",
    "    :param x: x-coordinate of point in global coordinates.\n",
    "    :param y: y-coordinate of point in global coordinates.\n",
    "    :param radius: Any lanes within radius meters of the (x, y) point will be returned.\n",
    "    :param discretization_meters: How finely to discretize the lane. If 1 is given, for example,\n",
    "        the lane will be discretized into a list of points such that the distances between points\n",
    "        is approximately 1 meter.\n",
    "    :param map_api: The NuScenesMap instance to query.\n",
    "    :return: Mapping from lane id to list of coordinate tuples in global coordinate system.\n",
    "    \"\"\"\n",
    "\n",
    "    lanes = map_api.get_records_in_radius(x, y, radius, ['lane', 'lane_connector'])\n",
    "    lanes = lanes['lane'] + lanes['lane_connector']\n",
    "    lanes = map_api.discretize_lanes(lanes, discretization_meters)\n",
    "\n",
    "    return lanes\n",
    "\n",
    "\n",
    "def color_by_yaw(agent_yaw_in_radians: float,\n",
    "                 lane_yaw_in_radians: float) -> Color:\n",
    "    \"\"\"\n",
    "    Color the pose one the lane based on its yaw difference to the agent yaw.\n",
    "    :param agent_yaw_in_radians: Yaw of the agent with respect to the global frame.\n",
    "    :param lane_yaw_in_radians: Yaw of the pose on the lane with respect to the global frame.\n",
    "    \"\"\"\n",
    "\n",
    "    # By adding pi, lanes in the same direction as the agent are colored blue.\n",
    "    angle = angle_diff(agent_yaw_in_radians, lane_yaw_in_radians, 2*np.pi) + np.pi\n",
    "\n",
    "    # Convert to degrees per colorsys requirement\n",
    "    angle = angle * 180/np.pi\n",
    "\n",
    "    normalized_rgb_color = colorsys.hsv_to_rgb(angle/360, 1., 1.)\n",
    "\n",
    "    color = [color*255 for color in normalized_rgb_color]\n",
    "\n",
    "    # To make the return type consistent with Color definition\n",
    "    return color[0], color[1], color[2]\n",
    "\n",
    "def color_by_yaw2(agent_yaw_in_radians: float,\n",
    "                 lane_yaw_in_radians: float) -> Color:\n",
    "    \"\"\"\n",
    "    Color the pose one the lane based on its yaw difference to the agent yaw.\n",
    "    :param agent_yaw_in_radians: Yaw of the agent with respect to the global frame.\n",
    "    :param lane_yaw_in_radians: Yaw of the pose on the lane with respect to the global frame.\n",
    "    \"\"\"\n",
    "\n",
    "    # By adding pi, lanes in the same direction as the agent are colored blue.\n",
    "    angle = angle_diff(agent_yaw_in_radians, lane_yaw_in_radians, 2*np.pi) + np.pi\n",
    "\n",
    "    # Convert to degrees per colorsys requirement\n",
    "    angle = angle * 180/np.pi\n",
    "\n",
    "    normalized_rgb_color = colorsys.hsv_to_rgb(angle/360, 1., 1.)\n",
    "\n",
    "    color = [color*255 for color in normalized_rgb_color]\n",
    "\n",
    "    # To make the return type consistent with Color definition\n",
    "    return 255,255,255\n",
    "\n",
    "\n",
    "\n",
    "def draw_lanes_on_image(image: np.ndarray,\n",
    "                        lanes: Dict[str, List[Tuple[float, float, float]]],\n",
    "                        agent_global_coords: Tuple[float, float],\n",
    "                        agent_yaw_in_radians: float,\n",
    "                        agent_pixels: Tuple[int, int],\n",
    "                        resolution: float,\n",
    "                        color_function: Callable[[float, float], Color] = color_by_yaw) -> np.ndarray:\n",
    "    \"\"\"\n",
    "    Draws lanes on image.\n",
    "    :param image: Image to draw lanes on. Preferably all-black or all-white image.\n",
    "    :param lanes: Mapping from lane id to list of coordinate tuples in global coordinate system.\n",
    "    :param agent_global_coords: Location of the agent in the global coordinate frame.\n",
    "    :param agent_yaw_in_radians: Yaw of agent in radians.\n",
    "    :param agent_pixels: Location of the agent in the image as (row_pixel, column_pixel).\n",
    "    :param resolution: Resolution in meters/pixel.\n",
    "    :param color_function: By default, lanes are colored by the yaw difference between the pose\n",
    "    on the lane and the agent yaw. However, you can supply your own function to color the lanes.\n",
    "    :return: Image (represented as np.ndarray) with lanes drawn.\n",
    "    \"\"\"\n",
    "\n",
    "    for poses_along_lane in lanes.values():\n",
    "\n",
    "        for start_pose, end_pose in zip(poses_along_lane[:-1], poses_along_lane[1:]):\n",
    "\n",
    "            start_pixels = convert_to_pixel_coords(start_pose[:2], agent_global_coords,\n",
    "                                                   agent_pixels, resolution)\n",
    "            end_pixels = convert_to_pixel_coords(end_pose[:2], agent_global_coords,\n",
    "                                                 agent_pixels, resolution)\n",
    "\n",
    "            start_pixels = (start_pixels[1], start_pixels[0])\n",
    "            end_pixels = (end_pixels[1], end_pixels[0])\n",
    "\n",
    "            color = color_function(agent_yaw_in_radians, start_pose[2])\n",
    "\n",
    "            # Need to flip the row coordinate and the column coordinate\n",
    "            # because of cv2 convention\n",
    "            cv2.line(image, start_pixels, end_pixels, color,\n",
    "                     thickness=5)\n",
    "\n",
    "    return image\n",
    "\n",
    "\n",
    "def draw_lanes_in_agent_frame(image_side_length: int,\n",
    "                              agent_x: float, agent_y: float,\n",
    "                              agent_yaw: float,\n",
    "                              radius: float,\n",
    "                              image_resolution: float,\n",
    "                              discretization_resolution_meters: float,\n",
    "                              map_api: NuScenesMap,\n",
    "                              color_function: Callable[[float, float], Color] = color_by_yaw2) -> np.ndarray:\n",
    "    \"\"\"\n",
    "    Queries the map api for the nearest lanes, discretizes them, draws them on an image\n",
    "    and rotates the image so the agent heading is aligned with the postive y axis.\n",
    "    :param image_side_length: Length of the image.\n",
    "    :param agent_x: Agent X-coordinate in global frame.\n",
    "    :param agent_y: Agent Y-coordinate in global frame.\n",
    "    :param agent_yaw: Agent yaw, in radians.\n",
    "    :param radius: Draws the lanes that are within radius meters of the agent.\n",
    "    :param image_resolution: Image resolution in pixels / meter.\n",
    "    :param discretization_resolution_meters: How finely to discretize the lanes.\n",
    "    :param map_api: Instance of NuScenesMap.\n",
    "    :param color_function: By default, lanes are colored by the yaw difference between the pose\n",
    "        on the lane and the agent yaw. However, you can supply your own function to color the lanes.\n",
    "    :return: np array with lanes drawn.\n",
    "    \"\"\"\n",
    "\n",
    "    agent_pixels = int(image_side_length / 2), int(image_side_length / 2)\n",
    "    base_image = np.zeros((image_side_length, image_side_length, 3))\n",
    "\n",
    "    lanes = get_lanes_in_radius(agent_x, agent_y, radius, discretization_resolution_meters, map_api)\n",
    "\n",
    "    image_with_lanes = draw_lanes_on_image(base_image, lanes, (agent_x, agent_y), agent_yaw,\n",
    "                                           agent_pixels, image_resolution, color_function)\n",
    "\n",
    "    rotation_mat = get_rotation_matrix(image_with_lanes.shape, agent_yaw)\n",
    "\n",
    "    rotated_image = cv2.warpAffine(image_with_lanes, rotation_mat, image_with_lanes.shape[:2])\n",
    "\n",
    "    return rotated_image.astype(\"uint8\")\n",
    "\n",
    "\n",
    "\n",
    "class StaticLayerRasterizer(StaticLayerRepresentation):\n",
    "    \"\"\"\n",
    "    Creates a representation of the static map layers where\n",
    "    the map layers are given a color and rasterized onto a\n",
    "    three channel image.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, helper: PredictHelper,\n",
    "                 layer_names: List[str] = None,\n",
    "                 colors: List[Color] = None,\n",
    "                 resolution: float = 0.1, # meters / pixel\n",
    "                 meters_ahead: float = 40, meters_behind: float = 10,\n",
    "                 meters_left: float = 25, meters_right: float = 25):\n",
    "\n",
    "        self.helper = helper\n",
    "        self.maps = load_all_maps(helper)\n",
    "\n",
    "        if not layer_names:\n",
    "            layer_names = ['drivable_area', 'ped_crossing', 'walkway']\n",
    "        self.layer_names = layer_names\n",
    "\n",
    "        if not colors:\n",
    "            colors = [(255, 255, 255), (119, 136, 153), (0, 0, 255)]\n",
    "        self.colors = colors\n",
    "\n",
    "        self.resolution = resolution\n",
    "        self.meters_ahead = meters_ahead\n",
    "        self.meters_behind = meters_behind\n",
    "        self.meters_left = meters_left\n",
    "        self.meters_right = meters_right\n",
    "        self.combinator = Rasterizer()\n",
    "\n",
    "    def make_representation(self, instance_token: str, sample_token: str) -> np.ndarray:\n",
    "        \"\"\"\n",
    "        Makes rasterized representation of static map layers.\n",
    "        :param instance_token: Token for instance.\n",
    "        :param sample_token: Token for sample.\n",
    "        :return: Three channel image.\n",
    "        \"\"\"\n",
    "\n",
    "        sample_annotation = self.helper.get_sample_annotation(instance_token, sample_token)\n",
    "        map_name = self.helper.get_map_name_from_sample_token(sample_token)\n",
    "\n",
    "        x, y = sample_annotation['translation'][:2]\n",
    "\n",
    "        yaw = quaternion_yaw(Quaternion(sample_annotation['rotation']))\n",
    "\n",
    "        yaw_corrected = correct_yaw(yaw)\n",
    "\n",
    "        image_side_length = 2 * max(self.meters_ahead, self.meters_behind,\n",
    "                                    self.meters_left, self.meters_right)\n",
    "        image_side_length_pixels = int(image_side_length / self.resolution)\n",
    "\n",
    "        patchbox = get_patchbox(x, y, image_side_length)\n",
    "\n",
    "        angle_in_degrees = angle_of_rotation(yaw_corrected) * 180 / np.pi\n",
    "\n",
    "        canvas_size = (image_side_length_pixels, image_side_length_pixels)\n",
    "\n",
    "        masks = self.maps[map_name].get_map_mask(patchbox, angle_in_degrees, self.layer_names, canvas_size=canvas_size)\n",
    "\n",
    "        images = []\n",
    "        for mask, color in zip(masks, self.colors):\n",
    "            images.append(change_color_of_binary_mask(np.repeat(mask[::-1, :, np.newaxis], 3, 2), color))\n",
    "        \n",
    "        #print(len(images))\n",
    "        #images = []\n",
    "\n",
    "        \n",
    "        #lanes = draw_lanes_in_agent_frame(image_side_length_pixels, x, y, yaw, radius=50,\n",
    "        #                                  image_resolution=self.resolution, discretization_resolution_meters=1,\n",
    "        #                                  map_api=self.maps[map_name])\n",
    "                                          \n",
    "\n",
    "        #images.append(lanes)\n",
    "\n",
    "        image = self.combinator.combine(images)\n",
    "\n",
    "        row_crop, col_crop = get_crops(self.meters_ahead, self.meters_behind, self.meters_left,\n",
    "                                       self.meters_right, self.resolution,\n",
    "                                       int(image_side_length / self.resolution))\n",
    "\n",
    "        return image[row_crop, col_crop, :]\n",
    "\n",
    "    \n",
    "class StaticLayerRasterizer2(StaticLayerRepresentation):\n",
    "    \"\"\"\n",
    "    Creates a representation of the static map layers where\n",
    "    the map layers are given a color and rasterized onto a\n",
    "    three channel image.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, helper: PredictHelper,\n",
    "                 layer_names: List[str] = None,\n",
    "                 colors: List[Color] = None,\n",
    "                 resolution: float = 0.1, # meters / pixel\n",
    "                 meters_ahead: float = 40, meters_behind: float = 10,\n",
    "                 meters_left: float = 25, meters_right: float = 25):\n",
    "\n",
    "        self.helper = helper\n",
    "        self.maps = load_all_maps(helper)\n",
    "\n",
    "        if not layer_names:\n",
    "            layer_names = ['drivable_area', 'ped_crossing', 'walkway']\n",
    "        self.layer_names = layer_names\n",
    "\n",
    "        if not colors:\n",
    "            colors = [(255, 255, 255), (119, 136, 153), (0, 0, 255)]\n",
    "        self.colors = colors\n",
    "\n",
    "        self.resolution = resolution\n",
    "        self.meters_ahead = meters_ahead\n",
    "        self.meters_behind = meters_behind\n",
    "        self.meters_left = meters_left\n",
    "        self.meters_right = meters_right\n",
    "        self.combinator = Rasterizer()\n",
    "\n",
    "    def make_representation(self, ref_ego_pose: Dict[str, Any],\n",
    "                            instance_token: str, sample_token: str) -> np.ndarray:\n",
    "        \"\"\"\n",
    "        Makes rasterized representation of static map layers.\n",
    "        :param instance_token: Token for instance.\n",
    "        :param sample_token: Token for sample.\n",
    "        :return: Three channel image.\n",
    "        \"\"\"\n",
    "\n",
    "        #sample_annotation = self.helper.get_sample_annotation(instance_token, sample_token)\n",
    "        \n",
    "        map_name = self.helper.get_map_name_from_sample_token(sample_token)\n",
    "\n",
    "        x, y = ref_ego_pose['translation'][:2]\n",
    "\n",
    "        yaw = quaternion_yaw(Quaternion(ref_ego_pose['rotation']))\n",
    "\n",
    "        yaw_corrected = correct_yaw(yaw) - np.pi/2\n",
    "\n",
    "        image_side_length = 2 * max(self.meters_ahead, self.meters_behind,\n",
    "                                    self.meters_left, self.meters_right)\n",
    "        image_side_length_pixels = int(image_side_length / self.resolution)\n",
    "\n",
    "        patchbox = get_patchbox(x, y, image_side_length)\n",
    "\n",
    "        angle_in_degrees = angle_of_rotation(yaw_corrected) * 180 / np.pi\n",
    "\n",
    "        canvas_size = (image_side_length_pixels, image_side_length_pixels)\n",
    "\n",
    "        masks = self.maps[map_name].get_map_mask(patchbox, angle_in_degrees, self.layer_names, canvas_size=canvas_size)\n",
    "\n",
    "        images = []\n",
    "        for mask, color in zip(masks, self.colors):\n",
    "            images.append(change_color_of_binary_mask(np.repeat(mask[::-1, :, np.newaxis], 3, 2), color))\n",
    "        \n",
    "        #print(len(images))\n",
    "        #images = []\n",
    "\n",
    "        \n",
    "        #lanes = draw_lanes_in_agent_frame(image_side_length_pixels, x, y, yaw, radius=50,\n",
    "        #                                  image_resolution=self.resolution, discretization_resolution_meters=1,\n",
    "        #                                  map_api=self.maps[map_name])\n",
    "                                          \n",
    "\n",
    "        #images.append(lanes)\n",
    "\n",
    "        image = self.combinator.combine(images)\n",
    "\n",
    "        row_crop, col_crop = get_crops(self.meters_ahead, self.meters_behind, self.meters_left,\n",
    "                                       self.meters_right, self.resolution,\n",
    "                                       int(image_side_length / self.resolution))\n",
    "\n",
    "        return image[row_crop, col_crop, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "import abc\n",
    "\n",
    "class StaticLayerRepresentation(abc.ABC):\n",
    "    \"\"\" Represents static map information as a numpy array. \"\"\"\n",
    "\n",
    "    @abc.abstractmethod\n",
    "    def make_representation(self, instance_token: str, sample_token: str) -> np.ndarray:\n",
    "        raise NotImplementedError()\n",
    "\n",
    "\n",
    "class AgentRepresentation(abc.ABC):\n",
    "    \"\"\" Represents information of agents in scene as numpy array. \"\"\"\n",
    "\n",
    "    @abc.abstractmethod\n",
    "    def make_representation(self, instance_token: str, sample_token: str) -> np.ndarray:\n",
    "        raise NotImplementedError()\n",
    "\n",
    "\n",
    "class Combinator(abc.ABC):\n",
    "    \"\"\" Combines the StaticLayer and Agent representations into a single one. \"\"\"\n",
    "\n",
    "    @abc.abstractmethod\n",
    "    def combine(self, data: List[np.ndarray]) -> np.ndarray:\n",
    "        raise NotImplementedError()\n",
    "\n",
    "\n",
    "class InputRepresentation:\n",
    "    \"\"\"\n",
    "    Specifies how to represent the input for a prediction model.\n",
    "    Need to provide a StaticLayerRepresentation - how the map is represented,\n",
    "    an AgentRepresentation - how agents in the scene are represented,\n",
    "    and a Combinator, how the StaticLayerRepresentation and AgentRepresentation should be combined.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, static_layer: StaticLayerRepresentation, agent: AgentRepresentation,\n",
    "                 combinator: Combinator):\n",
    "\n",
    "        self.static_layer_rasterizer = static_layer\n",
    "        self.agent_rasterizer = agent\n",
    "        self.combinator = combinator\n",
    "\n",
    "    def make_input_representation(self, ego_pose: Dict[str, Any],\n",
    "                                  ref_ego_pose: Dict[str, Any],\n",
    "                                  instance_token: str,\n",
    "                                  sample_token: str) -> np.ndarray:\n",
    "\n",
    "        static_layers = self.static_layer_rasterizer.make_representation(instance_token, sample_token)\n",
    "        agents = self.agent_rasterizer.make_representation(ego_pose, ref_ego_pose, sample_token)\n",
    "\n",
    "        return self.combinator.combine([agents])\n",
    "\n",
    "class InputRepresentationStaticOnly:\n",
    "    \"\"\"\n",
    "    Specifies how to represent the input for a prediction model.\n",
    "    Need to provide a StaticLayerRepresentation - how the map is represented,\n",
    "    an AgentRepresentation - how agents in the scene are represented,\n",
    "    and a Combinator, how the StaticLayerRepresentation and AgentRepresentation should be combined.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, static_layer: StaticLayerRepresentation, agent: AgentRepresentation,\n",
    "                 combinator: Combinator):\n",
    "\n",
    "        self.static_layer_rasterizer = static_layer\n",
    "        self.agent_rasterizer = agent\n",
    "        self.combinator = combinator\n",
    "\n",
    "    def make_input_representation(self, ego_pose: Dict[str, Any],\n",
    "                                  ref_ego_pose: Dict[str, Any],\n",
    "                                  instance_token: str,\n",
    "                                  sample_token: str) -> np.ndarray:\n",
    "\n",
    "        static_layers = self.static_layer_rasterizer.make_representation(ref_ego_pose, instance_token, sample_token)\n",
    "        agents = self.agent_rasterizer.make_representation(ego_pose, ref_ego_pose, sample_token)\n",
    "\n",
    "        return self.combinator.combine([static_layers])\n",
    "\n",
    "class InputRepresentationAgentOnly:\n",
    "    \"\"\"\n",
    "    Specifies how to represent the input for a prediction model.\n",
    "    Need to provide a StaticLayerRepresentation - how the map is represented,\n",
    "    an AgentRepresentation - how agents in the scene are represented,\n",
    "    and a Combinator, how the StaticLayerRepresentation and AgentRepresentation should be combined.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, static_layer: StaticLayerRepresentation, agent: AgentRepresentation,\n",
    "                 combinator: Combinator):\n",
    "\n",
    "        self.static_layer_rasterizer = static_layer\n",
    "        self.agent_rasterizer = agent\n",
    "        self.combinator = combinator\n",
    "\n",
    "    def make_input_representation(self, ego_pose: Dict[str, Any],\n",
    "                                  ref_ego_pose: Dict[str, Any],\n",
    "                                  instance_token: str,\n",
    "                                  sample_token: str) -> np.ndarray:\n",
    "\n",
    "        static_layers = self.static_layer_rasterizer.make_representation(ref_ego_pose, instance_token, sample_token)\n",
    "        agents = self.agent_rasterizer.make_representation(ego_pose, ref_ego_pose, sample_token)\n",
    "\n",
    "        return self.combinator.combine([agents])\n",
    "\n",
    "class InputRepresentationBoth:\n",
    "    \"\"\"\n",
    "    Specifies how to represent the input for a prediction model.\n",
    "    Need to provide a StaticLayerRepresentation - how the map is represented,\n",
    "    an AgentRepresentation - how agents in the scene are represented,\n",
    "    and a Combinator, how the StaticLayerRepresentation and AgentRepresentation should be combined.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, static_layer: StaticLayerRepresentation, agent: AgentRepresentation,\n",
    "                 combinator: Combinator):\n",
    "\n",
    "        self.static_layer_rasterizer = static_layer\n",
    "        self.agent_rasterizer = agent\n",
    "        self.combinator = combinator\n",
    "\n",
    "    def make_input_representation(self, ego_pose: Dict[str, Any],\n",
    "                                  ref_ego_pose: Dict[str, Any],\n",
    "                                  instance_token: str,\n",
    "                                  sample_token: str) -> np.ndarray:\n",
    "\n",
    "        static_layers = self.static_layer_rasterizer.make_representation(ref_ego_pose, instance_token, sample_token)\n",
    "        agents = self.agent_rasterizer.make_representation(ego_pose, ref_ego_pose, sample_token)\n",
    "\n",
    "        return self.combinator.combine([static_layers, agents])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "static_layers.py - Loading Map: singapore-hollandvillage\n",
      "static_layers.py - Loading Map: singapore-onenorth\n",
      "static_layers.py - Loading Map: singapore-queenstown\n",
      "static_layers.py - Loading Map: boston-seaport\n"
     ]
    }
   ],
   "source": [
    "helper = PredictHelper(nusc)\n",
    "# ego_pose: Dict[str, Any], ref_ego_pose: Dict[str, Any], sample_token: str\n",
    "static_layer_rasterizer = StaticLayerRasterizer2(helper, layer_names=['drivable_area'], resolution=0.25, meters_ahead = 64, meters_behind = 64,meters_left = 64, meters_right=64)\n",
    "agent_rasterizer = OtherVehicleRepresentation(helper, resolution=0.25, meters_ahead = 64, meters_behind = 64,meters_left = 64, meters_right=64)\n",
    "mtp_input_representation = InputRepresentation2(static_layer_rasterizer, agent_rasterizer, Rasterizer())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_ego_pose(sample_rec):\n",
    "    toplidar_token = sample_rec['data']['LIDAR_TOP']\n",
    "    toplidar = nusc.get('sample_data', toplidar_token)\n",
    "    ego_pose = nusc.get('ego_pose', toplidar['ego_pose_token'])\n",
    "    return ego_pose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'token': 'cc8c0bf57f984915a77078b10eb33198', 'log_token': '7e25a2c8ea1f41c5b0da1e69ecfa71a2', 'nbr_samples': 39, 'first_sample_token': 'ca9a282c9e77460f8360f564131a8af5', 'last_sample_token': 'ed5fc18c31904f96a8f0dbb99ff069c0', 'name': 'scene-0061', 'description': 'Parked truck, construction, intersection, turn left, following a van'}\n"
     ]
    }
   ],
   "source": [
    "my_scene = nusc.scene[0]\n",
    "print(my_scene)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "39586f9d59004284a7114a68825e8eec\n",
      "356d81f38dd9473ba590f39e266f54e5\n",
      "e0845f5322254dafadbbed75aaa07969\n",
      "2\n",
      "c923fe08b2ff4e27975d2bf30934383b\n",
      "f1e3d9d08f044c439ce86a2d6fcca57b\n",
      "4f545737bf3347fbbc9af60b0be9a963\n",
      "7626dde27d604ac28a0240bdd54eba7a\n",
      "be99ffc878b24aca8956bbb4e0f97d0c\n",
      "9813c23a5f1448b09bb7910fea9baf20\n",
      "023c4df2d451409881d8e6ea82f14704\n",
      "c235638ed66145988d17f9d0601923f2\n",
      "bc3c8a953f6b4dcdb77b521d89f3d9d5\n",
      "1e3d79dae62742a0ad64c91679863358\n",
      "2afb9d32310e4546a71cbe432911eca2\n",
      "cd21dbfc3bd749c7b10a5c42562e0c42\n",
      "88449a5cb1644a199c1c11f6ac034867\n",
      "2ff86dc19c4644a1a88ce5ba848f56e5\n",
      "bf2938e43c6f487497cda76b51bfc406\n",
      "b26e791522294bec90f86fd72226e35c\n",
      "c844bf5a9f2243ff8f4bf2c85fe218ff\n",
      "fedfb3a6cb804635a0f47143f9ca8d6f\n",
      "965f6af5a92449348409029a5f048a38\n",
      "4711bcd34644420da8bc77163431888e\n",
      "a34fabc7aa674713b71f98ec541eb2d4\n",
      "c78067571d104caba7c568a847d56971\n",
      "4246e57f018745c9b2bc68feb3d71b58\n",
      "a7acb150914b40bdad9a2dc4e657cbf9\n",
      "0cd661df01aa40c3bb3a773ba86f753a\n",
      "378a3a3e9af346308ab9dff8ced46d9c\n",
      "eef55c3b48f34d949959b45130ee293a\n",
      "5fda58ee3ae44ab9b4bbac7a2de66c27\n",
      "919e3c4cec934168a3152077a9adcbea\n",
      "b73152cab88f49d9ba195da81fde1809\n",
      "6aa6fa91e0d1492e812eb7e57c47df6e\n",
      "aa581aac963a4fad848ac11fe66e8637\n",
      "67e5f88901214f3aa03d68e028185e22\n",
      "29e056fc277543c9bc42310b122c640e\n",
      "ed5fc18c31904f96a8f0dbb99ff069c0\n"
     ]
    }
   ],
   "source": [
    "needle = 'e0845f5322254dafadbbed75aaa07969'\n",
    "my_scene = nusc.scene[0]\n",
    "my_scene_token = my_scene['token']\n",
    "scene_rec = nusc.get('scene', my_scene_token)\n",
    "first_sample_token = scene_rec['first_sample_token']\n",
    "curr_sample_token = first_sample_token\n",
    "sample_rec = nusc.get('sample', curr_sample_token)\n",
    "for x in range(38):\n",
    "    curr_sample_token = sample_rec['next']\n",
    "    print(curr_sample_token)\n",
    "    if curr_sample_token == needle:\n",
    "        print(x)\n",
    "    sample_rec = nusc.get('sample', curr_sample_token)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_scene = nusc.scene[0]\n",
    "my_scene_token = my_scene['token']\n",
    "scene_rec = nusc.get('scene', my_scene_token)\n",
    "first_sample_token = scene_rec['first_sample_token']\n",
    "curr_sample_token = first_sample_token\n",
    "sample_rec = nusc.get('sample', curr_sample_token)\n",
    "for x in range(3):\n",
    "    curr_sample_token = sample_rec['next']\n",
    "    sample_rec = nusc.get('sample', curr_sample_token)\n",
    "\n",
    "ref_ego_pose = get_ego_pose(sample_rec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "delx is -13.443273371357293 meters, dely is -59.8129907587313 meters\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f20a5e83dd8>"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAI+CAYAAABdWRX9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Xt8FPW9//H3yiWBIAkiEgVKBOykXKOgpsKjRFEJ4GXbegnUChWvLSoPr7S/tnrO4xyFakUrVUq9FKkSe2PBC2mFNrZWgyYQLirDCRAOoOEiBAgQIDC/P7LZk5DL7mZnd3Z3Xs/HYx7szH53vp9kk82b73xnxmNZlgAAANzsDKcLAAAAcBqBCAAAuB6BCAAAuB6BCAAAuB6BCAAAuB6BCAAAuF7HaOzUMIx8Sc9J6iDpJdM0Z0ejHwAAADt47L4OkWEYHSRtknSVpB2SPpE02TTNz2ztCAAAwCbROGR2iaQK0zS3mKZ5XFKhpOuj0A8AAIAtonHIrI+k7Y3Wd0i69PRGZWVlXCIbAADE1MiRIz0tbY/KHKJQjRo1ysnuAQAulpaWpsOHD2vcuHHasGGDdu3apUsvvVRVVVUaPny4Bg8erNdff107duxQvN7myuNp8W973HL6+1hWVtbqc9EIRDsl9Wu03te/DQCAuHH48GFJ0sqVKwPbVq1aJUnatm2b3nrrLUfqgjOiEYg+kXSBYRjnqz4IFUiaEoV+AAAAbGH7pGrTNOskzZD0V0mfS/qDaZqf2t0PAABulmiHy+JdVOYQmab5rqR3o7FvAACAcHk8HpWWlrb6PFeqBgAAUef0hOpgCEQAAMD1CEQAAMD1CEQAAMD1CEQAAMD1CEQAAMD1CEQAAMD1CEQAAMD1CEQAAMD1CEQAACQYbtthPwIRAABwPQIRAABIaqGMqBGIAAAIgkNUyY9ABADAaTp37ux0CYgxAhEAwNWeeOIJ7d+/Xw8//LBefPFFffnll7rnnnucLiupxPud7iWpo9MFAADgpGPHjikjI0O/+MUvAtuGDh3qYEVwAiNEAADXSktLU2ZmZrPtDz30ULNtzCNKbgQiAIBrHT58WPn5+c22FxQUOFANnEQgAgC4WmFhoSTp6NGjgW0TJ050qhw4hEAEAABcj0AEAHC1l19+WQUFBfrGN74hn8+ngoIC3XTTTU6X1SrmMkUHZ5kBAFytoqJCFRUVkqRvf/vbDlcDpzBCBAAAXI9ABAAAXI9ABABAiJi/k3hCfc8IRAAAwPUIRAAAJAhGqKKHQAQAAFyPQAQAAKImEe50LxGIAAAACEQAAAAEIgAA4HoEIgAA4HoEIgAAwsCp78mJQAQAQAIgiEUXgQgAACSlcEIkgQgAALgegQgAALgegQgAALgegQgAALgegQgAgDB5PB7O+koyBCIAAOB6BCIAABAViXKne4lABAAAQCACAAAgEAEAANcjEAEAANcjEAEAANcjEAEA0E6xuhYR1zwKX7jfMwIRAABwPQIRAABwPQIRAABwPQIRAABwPQIRAABwPQIRAAAR4Ayw5EAgAgAAtkukG7tKBCIAAAACEQAAkeKwWeIjEAEAANcjEAEAANcjEAEAYAMOmyU2AhEAAEEYhqFHH31UktS/f3+lpaUpLS3N4apgJwIRAABBFBYWavbs2Vq/fr0qKyt1yy236JZbbnG6LNiIQAQAQBCFhYWSpKFDh0qSvF6vvF5vs3bROGzGobjwted7RiACACAIn8/XZD0/P1/5+fnq37+/QxUhXMEuFEkgAgAgCNM0VVJS0mx7S6NESEwdnS4AAIBE8MILL8jn8+nw4cOaPn26JKm6utrhquJTot22QyIQAQAQkkWLFkmqn58yb968Vtt5PJ6EDARuxyEzAADCQNhpW6J+fwhEAADAFokahiQCEQAAAHOIAABA+yXCqFAoNTJCBACAzdxwMUXLshIiDIWKQAQAAMKSTEGoAYfMAABASJIxCDUgEAEAEMcaQoiTh+GSOQg1IBABABAFdl+gsfG+YhWO3BCEGhCIAABIMOEElXDDk5tCUGMEIgAAkpibAk4kI2ecZQYAQJS44fT7ZEEgAgAASSvUETICEQAAcD0CEQAAUcRhs8RAIAIAAK5HIAIAAK5HIAIAIMo4bBb/CEQAAMD1CEQAAMD1CEQAAMQAh83iG4EIAIAYIRTFLwIRAAAxRCiKTwQiAABijFAUfwhEAAA4wOPxEIziCIEIAAAHEYriA4EIAACHMVoUuZa+f6He6V4iEAEAEDcIRs4hEAEAEGcIRbHXMVgDwzBekXSNpN2maQ71bztL0puSsiRVSrrJNM39hmF4JD0naaKkI5Kmmaa5OjqlAwCQvBpCUTiHfdB+oYwQ/U5S/mnbZklaaZrmBZJW+tclaYKkC/zLnZJetKdMAADcqeEwGofToitoIDJN85+S9p22+XpJC/2PF0ryNtr+mmmalmmaJZIyDMM4165iAQBwu9MDEmHJHkEPmbWit2maX/ofV0nq7X/cR9L2Ru12+Ld9KQAAEFWRhCK3H5qLeFK1aZqWJHd/FwEASHBuH2lqbyDa1XAozP/vbv/2nZL6NWrX178NAAAkCDcGo/YGomWSpvofT5W0tNH2Ww3D8BiGkSvpQKNDawAAIIG4KRSFctr9Ykl5ks42DGOHpMckzZb0B8MwpkvaJukmf/N3VX/KfYXqT7v/QRRqBgAAsFXQQGSa5uRWnhrXQltL0o8iLQoAAMSHRL0eUrj1cqVqAAAQVLIfPiMQAQCAkCRzKCIQAQCAkCVrKCIQAQCAsCRjKCIQAQCAsCXbtYoIRAAAoN3iIRTZUQOBCAAAuB6BCACAOLN27Vp9//vf14svvqi8vDz16NHD6ZLalAyHzwhEAADEkcmTJysrK0uvvfaa7r77bv3lL3/RI4884nRZSY9ABABAHNm3b5+6d+8eWD958qR+/OMfO1iROxCIAACIIxdccIGOHz8eWD/77LM1fvx4BytyBwIRAABx5OjRo3rvvfeabCsoKHCoGvcgEAEAEEdefvllPf/88022eb1ejR8/Xl26dHGoqsTSnhvREogAAIgz1113nU6dOhVYz8jI0HPPPaesrCznikpyBCIAAOKMz+fT7373uybblixZos8//9yZglyAQAQAAFyvo9MFAACApt577z0dP35cl19+ubp3765x48Zp7dq1TpeV1AhEAADEoffff18DBgzQQw89pMrKSqfLSXoEIgAA4tjTTz/tdAlBteesrnjDHCIAAOB6BCIAAOB6BCIAAOB6BCIAAJCwPB6PLfshEAEAANcjEAEAANcjEAEAANcjEAEAANcjEAEAANcjEAEAANcjEAEAANcjEAEAANfj5q4AACApRHKTWUaIAACA6xGIAABAu0UyKhNPCEQAAMD1CEQAAMD1CEQAAMD1CEQAAMD1CEQAAMD1CEQAACAheTwe2/ZFIAIAAK5HIAIAAK5HIAIAAK5HIAIAAK5HIAIAAK5HIAIAAK5HIAIAAK5HIAIAAK5HIAIAAK5HIAIAAK5HIAIAAAnPsqyIXk8gAgAArkcgAgAArkcgAgAA7RLpYap4QiACAACuRyACAACuRyACAAAJx+Px2Lo/AhEAAHA9AhEAAHA9AhEAAHA9AhEAAHA9AhEAAHA9AhEAAHA9AhEAAHA9AhEAAHA9AhEAAHA9AhEAAHA9AhEAAAhbMt3pXiIQAQCABGdHOOtoQx0AAMBlOnbsqBUrVmjq1KmaMGGCJOm9997Ttm3bVFdX53B14SMQAQCAsF1++eUaNGiQtm3bFti2YcMGrVixQjk5OSovL3ewuvBxyAwAAIRt4MCB6tu3b5NtQ4cO1X333acPPvhA8+fPV1VVlSZNmqTevXs7VGXoCEQAACBse/fubXH7GWecoW7duunuu+9WZmam5s+frwsuuCDG1YWPQ2YAACAslmVp9erVIbX99NNP9cEHH0S5osgxQgQAQJLq3LlzVPZ7xx136KKLLgqp7Te/+U317NkzKnXYiUAEAEASGjNmjJYuXapvfetbtu7Xsiz961//Crn9jBkz9NVXX9lag8fjsXV/EoEIAICkM378eE2fPl3jx4/X+++/r8WLF2vIkCG27f/BBx8Mqd2HH36oN99807Z+o4k5RAAAJJnZs2crJycnsJ6RkaHdu3fbtv+dO3eG1O6iiy7SGWckxthLYlQJAABCcvfddzcJQxs3btSyZcu0Z88eW/Z/9tlnhzx/6A9/+EPU5jHZjREiAACSRJ8+fXTfffc12XbppZfq4MGDtuzfsixddtllysvLC6n9qVOnbOs72ghEAAAkgX79+uk73/mO+vfvH9j25JNP2h5Ibr31VnXv3j1ou5MnT+rLL7+0te9o4pAZAABJYPbs2Xr22WfVtWtXSVJFRYX+8pe/2N7PRx99FFK7I0eO6I033rC9/2ghEAEAkODGjBmjKVOmNNlWXl6u0tJS2/v61a9+FVK7X//611q/fr3t/UcLgQgAALgegQgAgAT34YcfKiMjQ4sXL1ZVVZWuvPJK3Xjjjbb2YVmWHnvsMaWnp4fUvqCgwNb+o41ABABAgjt16pQOHDigKVOmqKCgQGVlZVHpxzTNkNv+8Ic/jEoN0UIgAgAgibz//vuqrq62fb8pKSkaN26cLMsK2raoqEgff/yx7TW0JJR6QkEgAgAAbbIsS8eOHVO/fv1Cuo9YRkaG9u7dG4PK7EMgAgAAQZ111lmqra0Nqe2mTZvUrVu3KFdkLy7MCAA26dmzp2bMmKGzzz5b8+bN02WXXSZJevXVVx2uDGi/hkNSXbt2DVxosaqqSt27dw9c8+h0q1evVk1NTcxqtAMjRABgk/PPP1+PP/64ZsyYoY0bN2rMmDEaM2aM0tLSnC4NiNiOHTt0zz336KKLLlJmZqbuuece/fnPf26x7dlnnx3j6iJHIAIAmzz11FNN1jdt2qRNmzbp8OHDDlUERKalCcurV6+WJC1cuFB33HGHLrnkEhUVFamoqEj33nuvpPqrZicaDpkBgE3eeeedJje97NGjh3PFADGwb9++Juv5+fnq1atXVA+XhTKpuz0IRABgg/POO0//9V//1WTb3LlzHaoGiFx7T2ffs2ePzZXEBoEIAGzwxRdfaM2aNaqtrVXPnj01bNiwwGjRm2++6WxxAIIiEAGATcaPH6+DBw9qyJAhqqurC+uqvgCcRSACAJscPHhQkvTpp586XAkQGbuu/pxIOMsMAAC4XtARIsMw+kl6TVJvSZakBaZpPmcYxlmS3pSUJalS0k2mae43DMMj6TlJEyUdkTTNNM3V0SkfAADYyY2jQ1JoI0R1kh40TXOwpFxJPzIMY7CkWZJWmqZ5gaSV/nVJmiDpAv9yp6QXba8aAADARkEDkWmaXzaM8JimeUjS55L6SLpe0kJ/s4WSvP7H10t6zTRNyzTNEkkZhmGca3vlAAAANglrDpFhGFmSLpS0SlJv0zS/9D9VpfpDalJ9WNre6GU7/NsAAEAcc+vhMimMQGQYRjdJf5Y00zTNg42fM03TUv38IgAAgIQTUiAyDKOT6sPQ66Zp/sW/eVfDoTD/v7v923dK6tfo5X392wAAQJxy8+iQFEIg8p819rKkz03TfKbRU8skTfU/nippaaPttxqG4TEMI1fSgUaH1gAAgAsNHTpUs2fP1tVXX62cnBzl5uZKks4555x279POEBfKhRlHS/q+pPWGYZT7t/1E0mxJfzAMY7qkbZJu8j/3rupPua9Q/Wn3P7CtWgAAYKtYjQxdc801mjVrlu666y716NFDW7ZsUUlJicrKyjRz5kxNnDhRknTrrbfK6/VqyZIlOnDggDIyMlRVVSUpejd2lVT/jXBiKS0tbZh3xMLCwsLCwuLAEkujRo0Kq315ebllWZY1d+7cwLZI6y8tLbWsVnIJV6oGACDGnnrqKe3fv1/79+/XpZde6kgNVoznDP32t78Nq/2IESMkSZmZmdEopxkCEQAAMTR27FiNGzdOGRkZysjIUEFBgdMlxYTP52vX65599lmbK2kZgQgAgBi55pprVFxcrAsvvDCwzev1tvGK6Ij16NDAgQP1wAMPtOu1o0ePtrmalhGIAACIkbffflu1tbVNtmVlZWns2LExqyHWYUiSNm/erC+++CLs123atEm//OUvo1BRcwQiAABiqLCwsMl6dXW1+vfvH9Y+xo4dq8GDBwfWzz777JBe50QYkqRrr71WvXr1Cvt1X//61wNziaItlNPuAQCATXw+n6ZNmybTNCVJ2dnZYb3+/vvv17PPPqs1a9aoS5cukqTKykpNmDChzdc5FYYk6dChQ+rZs2fYr1u4cKHWrl3b6vO5ubkqKSmJpLQAAhEAADG0dOlSvf7663rvvfckSWeccYZOnToV8uuLi4slqck8pOzsbPXu3Vu7du2ytVa7FBcXq7KyUllZWWG9zjCMZtsuueQSTZ48WV6vV1lZWcrLy1NxcbHS09N14MCBdtdIIAIAIMZuueWWdr927dq1WrFihTZs2KBRo0ZJqr8K9Ne//vVWA5GTo0OSdPHFFzc7VBiK3NxcZWdna+PGjYFt99xzj6ZNmxZYLygo0KRJk7Rw4cKIaiQQAQCQYK666ipJUr9+9bcO3b59e6ttnQ5DktSzZ08NHDgw7Ne9/fbb2r9/f5NtDYccG0yePFmDBw/Wt771Lf3whz+UJP35z38Oe7SMQAQAQIJqKwhJ8RGGJOnIkSM6fPiw0tLSwnpdt27dmgWbpUuXqrq6WhkZGaqtrdXx48f1rW99S5L0wgsvSJI6d+4cdo2cZQYAAFyPQISE19p9aVpbAMAN4unz7rbbbgt7dEiStmzZEjiTrvGNXX/84x+roKBAGRkZ+u///u/A9j179mjPnj3asmVL2H1xyAxxI55+eQEgkcXb5+mHH37YZN5PqP75z3/q6NGjzbbPnz8/8DVmZmaqS5cuevLJJwNB6O9//3vYfRGIAABIIvEWhjp37qzjx4+367WDBg0K2qaqqkpS/WTrBQsWSJJqamrC7svj1DeurKzMajhdEJBi90vceNgVAJJJa5+jBR6Phkj6mUN/8xctWqROnTopLS1N1157rdavX69hw4a1+Zra2trAxGmp+Wf36V9rr169tGfPnjb3WVZWppEjR7b4R4ARIgAAElyw/1C+JKmbpGyPR19IOhjjYDRt2jSdPHlSvXr10okTJ5SSkqJvf/vbKioq0oIFC/Tuu+/q3nvvlVQ/D+icc87RgAEDlJeXF3IfwcJQMAQiuAqjQwCSSbAg9IDHo0ckZfrXP5L0m3b21fD52Z7R/JMnT0pqPbRcffXVOueccyRJu3fv1pgxY1RTU6Py8vJ2Vhs+AhEAAAkoWDDJ8Xg0R/8XhiSph6SbJN3r8ej5MIJNLP4zuXv37sDjDz74IOr9nY7T7gEASCDBLiGS5fGo3ONRuaTxLTw/QNLzkvIZMW+CQAQAQIIINirU3+ORV9I3QthXQYh9umWqAYfMAACIc6HO23lG0ndD3OcUSdUeT+CQWm2cna4fawQiAADiWFthKNU/elMgyavQw5AkdfYv49po45bRIYlABABAXAplVCjL/+/v2rH/EknTJG1spR83hSGJQASXsSzLdb/kABJPsDB0tcejKaoPNe2xUdJbaj0MuRGBCHEh3i41DwBOCPWz8AFJ+RH0c4OkDW30Fe//cYzG3wzOMoPrEL4SR8PpxZEuQCII5Wc11+NRpcfTrjB0WPWH1vLVdhiKR7EIaAQiOI4/WO7RVmjp2LGjpk6dqmeeeUbPPPOMUlJSVFBQoEWLFik1NVVer1e9evWSJOXn5wfug5SXl6fx4+uvtpKbm6spU6YE+svJydEPf/hDWZalAQMGBPrq37+/0tLSZFmWevfurT59+siyLKWnp2vYsGGBx+np6crNzZVlWerUqVPsv2FwhVCDe7bHoxv0f/OGwvWWpGmWpaIgfbUVPpL585pABAAAYNeQdLhLaWmpJYmFxXKK0193oi7R9OWXXwYe19bWBh7X1NRYlmVZH330UaDNp59+am3dutWyLMvasWOH9fnnn1uWZVlHjx611qxZY61Zsybw+obHzz//vPWPf/zDsizLevPNN63ly5dblmVZf//7360lS5YE9rt48eLAa/ft22ctXrzYOnr0qPXd737XevXVV639+/db99xzj/Xiiy9a119/fbOvw+n3iCX+l/ZYI1lWO5bDkjVVslJC6DcaddvBrjpKS0stq5Vc4rEcGv4qKyuzRo4cGVLbeJ/chfZz6uevMTf9fMXD97st77zzjiZNmuR0GWEpLCxUQUGo1/yt56afOfyfSH//Znk8+o6kS8J8XbHqL8L4RQSHyho49Rlyem3traOsrEwjR45s8QtNiENmraW5YAsQikT9WUm234kJEyYkXBiqra3V3Llzw35dez/TEvn9dTO73p/ZlqWbwmj/B9XPN8qzrDbDkMfjiWlI79GjR8z6CkdCBKL24oMlvsXT9zmeamngtp/R5cuXq7q62ukywpKamqpzzz3X6TIC+JyLH9H6Pldalq6TtDxIu3JJ7/rbtyWWQSg3N1fl5eV68cUXY9ZnOJI6EEWCMBU98fp9imZd/ByFZsWKFU6XEDav1+t0Ce3Gz6C9YvW9W2ZZerOV52ok5UjKsSz9Lo7CUFZWliZOnKicnBwVFBQoIyMjZn2HigszRoFdvwzJOM8gET5kE6HGZJSXl6fi4mKnywhLbW2t/va3v2natGlOlxIVdvwuJOPnmOT850ShpMelwI1ZUyXtkfS6pP8N4fWxfl+KioqUnZ0tqf73ZsSIETHtPxSMEMWxZJpbEC91IH6VlJSotrbW6TLCkpqaqn379jldRlxLhM+nUMRbzbWWpSzLUqHqw5Ek/VLSTMvSvjbqC2e+0IgRI/Tkk0/qiSeeiLhen88nqX4UOCMjQ++//36rbfPy8tSlS5cm22LxPWeEyCXi4RcYaMuPfvQjnXFGYv0fbefOnfxu2SAW38NQQ0CivZ/P+v/1SfLZcIisW7duevDBB+X1epWTkyNJqq6u1k9+8pOI6iwsLFROTo7eeOONZv/xGT58uKZMmRI4W7O4uFh33313RP21B4EIQFz46quv1LlzZ6fLCMuJEyf017/+1ekyEIJECzqhKg/x6wo1ENbU1GjmzJlN5vg8/fTTkiL7HpaXl0uqv8r86b7zne9o1qxZTba1NDcv2u9hYv13DEDSahhSTyRZWVnKy8tzugygTeHMF+ratas2bNjQZFvfvn3tLqmJln738/PzlZmZ2ULr6CEQAYgLEydOTLj5OHV1dTrvvPOcLgNoVbiTp6+99lqNGTMmsO7z+fSPf/zD7rKaKC8vD4wgSfWTrgsLC5vNI4o2DpkBiAvdu3fXWWedpcOHD0uS0tLSJEnHjh1TSkqKk6W1qqKiQm+88YbTZQDNtPcsMp/Pp2XLlundd99VYWGhDhw4YHNlLXvssccCAcjn86m2tjbsK8BHKiFu3QEg+WVkZCgvLy8wfP7666/rrbfeks/n0+zZs1VeXq5rr71WaWlp8vl8GjRokEaNGiWfz6eTJ0/qe9/7nnw+n0zT1GOPPSap/oN1+fLlWrBggZYvXx74gPX5fBo1apRGjhypTz75RFVVVbr66qvl8/l08OBB3XnnnYE61qxZozlz5mj58uWaMGGCpPpTiL/5zW8qPT1dgwcP1meffebAdwxoWbROqU+GeVht3bqDQAQgYaSlpQVGkDp37qzjx49Lks444wydOnUq6OsHDBigLVu2SJL69Omj0aNH6yc/+Yk++eQT3XHHHYH9nnHGGU3OhOnevbsOHjyoSZMmqaysTFVVVRo7dqy2bdumyspKm79KoP2ieX0hAlGUEIgAOKVLly569dVX5fV6lZqaKknKzs7Wxo0bHa4MaJ9YXGgx2QMRk6oBuM7Ro0e1aNEirVy5UpK0ZMkS7dixw+GqgPA0XGQxWa8GHmsEIgAA4HoEIgCu9M4772jRokUqLy/XH//4R9XU1DhdEhASJ0aFIjlc1qdPnxa3Z2ZmqmPH+pPdO3To0O7924U5RABcK9TJ2EA8cPLQWHuzwplnnqk9e/bo4Ycf1ne/+1098sgj2rJli/bu3atly5Zp586dOvfcc1VSUqLly5dLktauXWtn6U20NYeI6xABcC3CEBJBIs8R+tnPfqbU1FQ9//zzkqSPP/5YkydP1sSJE7V06VJ16tRJknTddddp4MCBTpZKIAIAIB4lchBq8MUXXzRZX7VqlXbs2KH/+Z//CYQhqX609pe//KUkBS6BEWsEIgAA4kQyhKAG3bp108svv9xk26WXXqrnn39ef/3rX3X06NEmt+e48sorY11iEwQiAAAckEzhpyU1NTUqKChQZmamxo4dG9g+f/58bdiwQSdOnNANN9ygdevWadCgQZo3b56D1RKIAACImWQPQafbsWOHDMPQzp071adPH5WWlmr+/PmS6q8K/9Of/lTZ2dm67LLL9OGHHzpaK6fdAwAQJY0vnui2MCRJn332mbxerwYOHKinnnpKDz30UOC5hlvvSHI8DEmMEAEAYBs3hp627Nu3r8n6ww8/bNu+vV6v0tPTtWrVKmVmZqq4uFi9evWSJO3Zsyfs/RGIAAAIE8EnPjz//PPq3r27du3apeLiYm3fvl2SlJqa2uQGzaEgEAEA0AqCT/zq1atX4Cy13r17q3fv3oHnvF5v2PtjDhEAwPVOn+uTbHN++vfv73QJths3blyTaxk1dv755zfblp6e3ub+CEQAgKTXWuBJtuDTmGEYevTRR7VmzRpt3LhRKSkpTpdkK5/P12zbgQMHdODAAT355JMtPtcWRwNRsB9QN/3gAgDaj78bzfl8Ps2ePVs5OTlKTU1t12GkeFZYWBiYJ3T06FFJ9aNA6enpuvzyy5u1v/HGG9vcX0LOIbLjh9upm9oCACLn1pATjuXLlys7OzuwXlBQoDfffDPs/cTj38vCwkKtWrVKU6dOlc/nU6dOndShQwcVFhZKksrLy5u95l//+pdmzZrV6j4TMhDZgVAFAPGP4BO+Pn36aN68ec1GhFJTU9WpUyedOHHCocrsMWbMGC1evFgFBQWSpAEDBujjjz/WlVde2WbgqaqqUlmxs77pAAAgAElEQVRZWavPM4cIAAC4HoEoAsyBAoDosiwrsCA0o0aN0sSJEwPrc+bMUWZmpiZMmJDwo0OStHfvXvXr1y+w3r17d91+++0R75dA5ACCEwCEr3E4amlBvYKCAnXu3DmwblmWdu3a5WBF9vr617+u6urqJtvsmDBOIIpjjDoBQOiCBSa3BKjGE4pra2tVVVXlYDX269q1q5YuXSpJ+uSTT7R+/Xq9/PLLEe/XtZOqk00ooSiZPwAAIFzt+UyM9/+AduvWTbNnzw6sp6amqri42LmCoqCwsFBnnnmmHn30Ue3bt0933XWXjhw5EvF+CUQuQmgCgMhE8hkZizBVU1OjV199VceOHVO/fv00evRoZWVlae3atVHvO5YOHTrUZP3555+PeJ8EIjQR7BeWwAQA7ROrMHXbbbdJks455xzt3r273X26DYEIYWGUCQBiz67P1XCClds+ywlEsB2/cAAQn/jMbZ2jgai1NybeJ63BPhyiAwDEg7gcIUrGmf9on1DfV4ITACAScRmI2iPeZ/4juhhpAgBEImkCUSTa+8eSIJU4mAwOAGgLgSgCkf4BJVDFF0aZAMC9CEQOcuI0SrQfo0wAkLwIREkgFn+ECV2hCff7RIACgPhAIEJInPrDnexBzI6vj1AFAJHjbvcAAMD1GCFCXHNy9KPx6I3H44nbkRhGmQAgcowQAaf5xS9+oaqqKk2fPl1z587V1q1bddNNN8myLNuWeOPxeNq1AECyYIQIOE337t2VmZmpl156KbBtzJgxtvaRLBcSZRI5gGTBCBHQyJlnnqnU1NQm2w4dOqQZM2Y4VFFziTwq1d6RqHgKgQCSEyNEQCOHDh1SdXV1k21nnnmmvF6vfD6fQ1XZI9EvJBpJ//ESCAHEL0aIgNM0BJ+6urrAtoKCAqfKiRuJPHeKkSkAwRCIgNP86le/UkFBgUaPHq2ioiJNmzZNd999t9NlJYVEDFUEKcAdOGQGnGb16tVN1vPz8x2qBC2xIxTFIrBE2geH+YDYIhABp7ngggs0ffp0bdu2TR999JG8Xq9SUlL04x//2OnSYJNEmE/F9aWA2CIQAacZMmSIZs2apcOHDystLU2Smk20hru1J2g4cRiNUSogdMwhAk5TXl6uo0ePBsKQJD399NMOVoRkEO9zpVrC/Cm4CSNEwGmeffZZdenSpcm2vn37OlQN3CpRRqFaEk4d8RL+AEaIgNMUFhY22+b1eh2oBAhPIpy1d7pILonAyBTsRCACTuPz+bRs2TLdfffd2r59u4qLizV79uxmo0ZAMkiUyx+EgjCFSHic+sEuKyuzRo4c6UjfQKjOOuss7du3z+kygKSQrMEjXgMimisrK9PIkSNb/EFkDhHQBsIQYJ9YB4dYBbD29kOQii8cMgMAAK7HCBEAIClFMgITbxffZDQp+oIGIsMwUiX9U1KKv/2fTNN8zDCM8yUVSuopqUzS903TPG4YRoqk1ySNlPSVpJtN06yMUv0AANgu3q5m3tL+CEn2CuWQ2TFJV5imOUJSjqR8wzByJc2RNNc0zUGS9kua7m8/XdJ+//a5/nYAALhGLM7eS9ZJ6k4JGohM07RM06zxr3byL5akKyT9yb99oaSGC7Vc71+X//lxhmHwrgEAEEQyXP4gUYU0qdowjA6GYZRL2i3pPUmbJVWbplnnb7JDUh//4z6StkuS//kDqj+sBgAAEJdCCkSmaZ40TTNHUl9Jl0jKtqNzLowFAADiQVin3ZumWS3pH5K+KSnDMIyGSdl9Je30P94pqZ8k+Z9PV/3k6qC4kigAAHBC0EBkGEYvwzAy/I+7SLpK0ueqD0Y3+JtNlbTU/3iZf13+5/9umqYtBzoJSwAAIBpCuQ7RuZIWGobRQfUB6g+mab5tGMZnkgoNw/gvSWskvexv/7KkRYZhVEjaJ6kgCnU3E2koYnIaAADu5ei9zEaNGuVI3+1FaAIAIHFxLzObxPrQHAEMAIDYIBDFMbsCGMEqMdkdwPk5AIDWEYhcgPlVwblhYn4kX6MbfgYAuBuBCEG5ISygbXb+DBCuAMQjAhGAmAo3XBGgAMQCgQhAXOOQL4BYCOtK1QAAAMmIESIASe30ESZGjAC0hEAEwFUISABaQiAC4GotzVEiJAHuQyACgNNwUUzAfQhEABBl4QQswhPgDAIRAMQRrtMEOINABAAJjHseAvYgEAEA2gxWhCW4AYEIANCmUEehCE5IZAQiAIAtuM0KEhmBCAAQFzhsBycRiAAAca+1sJRIQanha0ikmt2EQAQASFiJFDIsy5LH40mKcJeMCEQAgITXOGTEc7BoCEUtISg5i0AEAEgq8R6O2gpFLeFinbFBIAIAJK14PaQWbigKB5dJaJ8znC4AAADAaYwQAQCSXjyOFDXUEq2RomCYs9QUgQgA4Bqnh4B4+OPvdDBCPQIRAMC14mkCtp3BKD09XQUFBaqpqdHrr78e8f7cgDlEAABIbV4jKJYsy2p3OBs4cKCWLFmi6upqzZ8/Xz/96U9tri55EYgAAGgkkYPR3r175fV6A+sLFy5Uhw4d7C4tKRGIAABoQTwFo9bk5+crPz9fmZmZkqTc3Fxt3bq1yWtPnjwZ9RqTAXOIAABoQzycodbadYumT58uScrMzNSgQYN05MgRnX/++YHnCwoKNGfOnLD6cSsCEQAAIXA6GJ0eiq666irdcMMNgfUtW7bosssuU1VVVWBbTk6ORowYobVr18a01kTEITMAAMLg5GG0xmHsvffe07p167Ru3TodOHBAAwYMUJ8+fVRUVBRo8+9//1s1NTVKTU11otyEwggRAABhcnq0qMGIESMkSTfeeKMOHjyoDRs2aNeuXYHnzznnHD399NPKyclpcigNzXmcejPLysqsUaNGOdI3AAB2ceLvaGujVP3791dlZWWLz+Xl5en9999vc79OB7xoKysr08iRI1v85jFCBABABDweT8yDRGuTrLdt26Zf/OIX2rJliy6//HL17t1bdXV1uvLKK3XhhRcGDURuRiACACBC8RSKHn30UUnSa6+9pqNHj6pPnz7q1q2bTNOMaX2JhkAEAIANnAhFbTl69KgkaefOnQ5Xkhg4ywwAAJvE+gy0cK5mnZ6ertzcXElSp06dollWQiIQAQBcYdSoUXrllVc0duxYjR07Vg899FBU+olWKGrrFhzBQlFWVpaqq6u1YsUKLV68WAcPHlTv3r3tLjGhEYgAAAAahttivZSWllqSWFhYWFhYor506tTJeuqpp6xTp05ZjW3ZssW6+OKLo9ZvpPr372/df//91kcffWRNnTq1zbbBalmzZk2T9nfddZettSaC0tJSy2ollzCpGgCQ9Dp27KihQ4c2O5y1cuVKffLJJ1HrN5KJ1tOmTWtyTaHq6uo221utnHXWoLCwULW1tdq+fbtuvPFGDRs2rF11JSsOmQEAktr06dM1b9487du3r9lzY8aMabbt+uuv13nnnSdJ6tmzZ8T9t3dOUXl5eZP1xne1b01b4Wvu3Ln65je/qVtvvVU5OTmaMWNGu+pKVgQiAEDSOuecc3TnnXfqtttu05QpUyRJtbW1qq2t1dGjRzVv3jxJTYPP1KlTtWzZMu3fv1+33nqrLXW0JxSVl5c3C0WXXHJJ0Ne1FoqOHz8uqf7r52avzXHIDACQtHbv3q3u3bs32XbvvfdKkk6dOqWPP/5YM2fO1JVXXqnt27fL6/UGRmE2b96suXPnxrzmxhoOcxUWFsrn87V6Ww7YoLXJRdFemFTNwsLCwhLtZejQoda6deuaTKxdsmSJtWTJEkuSdd5551m7d+9u8vy6deus/fv3W5ZlWSNGjLC1nnB17tw57Nc0iHZtiYhJ1QAAV+rQoYOKioo0bNgwlZWVafjw4YFbW0jSF198oZ07d6pXr16Bbb/+9a+1c+dO7dmzJ6xDS6mpqaqtrW2zTbiTrI8dOxZyW0SGQAQASFpr167V2rVr9cILL6iyslLf+973tHv37sDz48aN09lnn93kNV6vVxMmTAirnwULFqi2tladOnVSVVWVfv/732vz5s22fA3tZQU56wxNEYgAAEmvYe7N66+/3mR7TU2N+vbt22RbXl6e0tPTdeDAgZD2nZubqxtuuEE9evSQJJ04cUJjxozRVVdd1WL7eLvnWTLKz89XQUGBBg8erEceeUQFBQXyer1tvoZABABwrVWrVmnjxo3Kzs4ObLv33ntDDkOStGbNmkAYkurvE/bTn/60zdfEKhS5aZSoa9eu2rJliySpqKgosL24uDjwuK0b3XLaPQDAtUaMGKETJ0402TZp0qSw9nHddddp7969TbZNnDgx4trQNo/H0yTsHTlyRCUlJSopKWnX/ghEABBESkqKrrzySqfLQJSsWLFCklRWVqYTJ05o5syZIb+2a9eu8nq9TeYhbd68WY899ljQ157+Bz1akv3wXOPvYWFhoQoLC9u3o9ZOP4v2wmn3LCws8bzcfPPN1s0332wtXrzYOnr0qGVZlmUYhuN1sURnycrKsiRZ3/ve96yMjIyQX9e/f/9mp3bPmDHD8ng8Ie8jFuKlDju1VHtKSoqVkpIS+J09HafdA0CYpk2bJql+cmYDr9erOXPmOFQRoqm1SdfBbNu2TRs2bNDQoUMD29LS0sIalYnFfCIryeYStfa1NFxSITU1Nex9csgMAFrg8/nk8/mabCsoKHCoGsSrmTNnNvnjW11d3a6rSSdTWHHStm3btG3btna9lkAEAC04PRBt3LhRRUVF6tq1q4NVId7MmzdPl156qWbNmqXs7GytX7++yRlO8STao1DxoKX/yISKQAQAAFzP41RiLCsrs0aNGuVI3wAQqrvuukvl5eVatWqV06XABaL9N7mtQ3OJNIJ0+tdxeu0+n6/FCzGWlZVp5MiRLX4TGCECgDb85je/IQwhZphLZI/2nHpPIAIAwCVaGgVqOO08mfh8vqA32j0dgQgAgDjCKFHkamtrw55cTSACAMBF4mk0KCcnR9dcc40kqW/fvs1utBuJcAMRF2YEACDOxOrmr04yDEOmaerQoUMqKSnRjh07JEk///nPdcUVV+hnP/uZhgwZotLSUpWWloa178Y3eg1Za5ewjvbCrTtYWFhYWFhaX6IpVv0Es27duqBtXn311WbbQql/yZIlzba1desODpkBABBDv/rVrzR8+HD16NFDPXr0aLVdNOcSWSGMPnXv3j1q/UvSrbfeqmHDhrXZ5ujRo/rb3/7WZFuo3xfmEAEAEKcGDx6ssWPHatWqVVqwYIEWLFigyZMnO11WE9/+9rdVWVmpefPmafbs2XrmmWeUk5MTuL/fwIEDbeln06ZNQdt06dJFX3zxRbv2f/qp99XV1W22Zw4RAAAxctVVV2n48OGSpOuuu06S9O9//7vV9k7MJdq/f7+ysrKUlZUlSTp16pQeeOABSdKaNWu0efNm5eXlqbi4OKJ+vvOd76iurk4dO7YeRXbt2qVu3bq1a/+1tbVatGiROnXqpMLCwqAjRgQiAABiZM6cOYHHX331lSRp6dKljtRiWVaLh5+GDRumY8eOKSUlRZJ0xhn/dzDpwgsvVF1dnc4777yI++/cuXObYUiqD2dvv/12u/uYNm2aTp48GdKNmTlkBgBADMyePVsnTpwIrM+bN0/z5s3T1q1b23xdrOcSDRkyJBCGWlJRUaE33ngj4r5DmeOTnZ2t3Nzcdvdx8uTJkNsSiAAAiIG5c+fq5ptvVlFRkT7//HM98cQTeuKJJ5wuq4kOHTpo//79bbbJzs7W4MGDI+7rG9/4RtCrSdfV1ckwjIj7CgWHzAAAiIFdu3bp3Xff1bvvvqtrrrkmMPITyhyhWM0lOnnyZNDJx3PmzNFnn30WcV8jRoxQampqm20+/fRTLVy4MOK+QsEIEQAAMfb222/H7T3ESkpK2nx+/PjxtvQTyiGzESNGRHTILBwEIgAAIEm69tprlZ+f32ab//iP/7Clr1OnTunIkSNB21166aW29BcMgQgAALgegQgAgAQQzbPNGrz33ns6duxYm23smuQ8ZcoUde3atc0269at03PPPWdLf8EQiAAAgCTpP//zP9s85f7LL79UWVmZLX2FcsPW4cOHB729h104ywwAgAQR7bPNgp09du6552r9+vUR95OSkhJ0JEqSXn75ZVv6CwUjRAAAQFJoZ36FctXnYI4dO9bsXmMtGTJkSMR9hYpABAAAJEm33XZbmxdLPHDgQNDrFIUqlPCVm5ur7OxsW/oLhkNmAABAknTkyJE2L5aYnp4eUpAJpmvXriHdxX7JkiXas2dPq8/befiQESIAABJItM42S0lJ0aBBg9psc/jwYQ0fPjzivo4cOaLi4mKVlJQELgT5xRdfNAtJPXr0CNwEN9oYIQIAADp27FjQq1S/9dZb+uc//2lLf1OnTtWBAweUlZWljIwMHTp0SJJ0xx13aOXKlVq0aJHKy8uVn58fOIwXzUsPeJy6bHhZWZk1atQoR/oGACCRReNvd2pqql555RVNmTKlzXadO3fW8ePHbe8/FKcHonC/D2VlZRo5cmSLqYpDZgAAQNnZ2UHD0A9+8APHwlC0EYgAAIDKy8u1efPmNtuMHTs2RtXEHoEIAADo//2//6eBAwe2+nxNTY3mzp0bw4pii0AEAECCicbk4pUrV2rjxo16+umnJUmVlZWBycwnTpxQt27ddO6559rW34wZMzRhwgTl5uYqNzc3sD0zM9O2PsLBWWYAACBwhll2draGDx+udevWaerUqdq1a5dycnKUnZ2tqqoq2/rr2LGjCgsLlZ6eroqKCpWXl0uSiouLbesjrHoc6RUAAMStdevWSZIWLlzYZPu0adNs2X9KSop+/vOfKz09XZKaXP9oz549GjBggLZs2WJLX6EiEAEAgJhq65pHv/71r2MehiTmEAEAABCIAABAbHXs2FFbt25t8Tmv1xvjauoRiAAAQEwNGTJEkydPbvG5O+64I8bV1CMQAQCQgKJ5X69oW7t2rSoqKlp8bty4cTGuph6BCAAAxNSjjz7a5MwySaqoqFBFRYX+8pe/OFITZ5kBAICYev/997VlyxYNGDAgsK0hIB08eNCRmkIORIZhdJBUKmmnaZrXGIZxvqRCST0llUn6vmmaxw3DSJH0mqSRkr6SdLNpmpW2Vw4AABJSwyn3jz76qFatWqU77rhDJ06ckCSlpqa2+JpI73QfTDgjRPdL+lxSd//6HElzTdMsNAxjvqTpkl70/7vfNM1BhmEU+NvdbGPNAAAgCcyZM6fZNrsu/hiukOYQGYbRV9IkSS/51z2SrpD0J3+ThZIazpO73r8u//Pj/O0BAECcGD16tObPn69JkyZp0qRJysvL0+jRoyVJubm5uvbaayVJ559/vpNlxkyoI0TPSnpE0pn+9Z6Sqk3TrPOv75DUx/+4j6TtkmSaZp1hGAf87ffaUjEAAIjYVVddpbvvvlu33HKLJKlbt27asmWLNm7cqJKSEtXU1Ki8vFxbt25VRkaGqqurHa44uoKOEBmGcY2k3aZplsWgHgAAEANr166VVB+EunXrJkkaMGCAsrOzA9tzcnK0f/9+feMb33CszlgJ5ZDZaEnXGYZRqfpJ1FdIek5ShmEYDSNMfSXt9D/eKamfJPmfT1f95GoAABAnnnzyyZDa/fWvf9VHH31kW785OTmBUanGh+OysrKUlZWljh3ro0XDv7ESNBCZpvlj0zT7mqaZJalA0t9N0/yepH9IusHfbKqkpf7Hy/zr8j//d9M07Z0KDgAAIuLz+UJq5/V61blzZ1v6PPPMM1VeXq7f//73Kisr09atWzVnzhwVFxersrJSlZWVmj9/voqKivTQQw/Z0meoIolfj0oqNAzjvyStkfSyf/vLkhYZhlEhaZ/qQxQAAIgTQ4cO1YYNG0Jqe8stt+j48eO29Hvo0CG98847mjRpkkaOHCmp/tT7xm6//XZJUkZGhi19hsyyLEeW0tJSSxILCwsLCwtLO5dIbN26NaR2r776akT9NDZ+/PiQ2w4bNqzJuh1fe2lpqWW1kku4dQcAAC5UWFgYUjs77z5fXl4ectsrrrjCtn5DQSACAMBlDMNQQUFoM1oef/xx2/qdOnWqjh07FrRdRUWF3n77bdv6DQWBCAAAuB6BCAAAlzFNs9V7hp2u4bpEdjh27JhSUlKCths0aJBqamps6zcUBCIAAFzm8ssvV11dXdB2Bw8eVFFRkW39hnqqv2Tv3KVQEIgAAHCZ9PR09e3bN2i77t27q6qqyrZ+L7744pBuAbJjxw5t2rQpsB7tO91LBCIAAFzH5/OFfG+yUCdfh2LgwIEhXV+ob9++Wr16tW39hoJABACAywwePFg7d+4M2q62tlaVlZW29RvqvCDTNNWvXz/b+g0FgQgAAJcZPny4hgwZErRdamqqiouLbet3xowZIbVbs2aN1q9fb1u/oSAQAQDgMoWFhaqtrQ2prZ2HzMK5GGSoZ8HZhUAEAIDL9OjRQ+vWrQuprV03dpWktWvXhtTu5MmTGjFihG39hoJABACAy1x//fW65JJLQmq7YMEC2/qdO3duSO3++Mc/atWqVbb1GwoCEQAALhPqoStJGjNmTMz7jfU1iCQCEQAArvP73/8+pHYff/yxXnrpJdv6DfXCjBkZGRo7dqxt/YaCQAQAgMusWLFCJSUleuWVVwLbTNNs8riurk6XXHKJBg4caFu/CxcuDKldYWGh3n//fdv6DUXHmPYGAAAc99vf/lbz589Xbm6uhg4dKknasGGDHn74Yf3rX/9SSUmJbr/9dlVUVGjz5s229bt8+XIZhhG0XV5eXqvPReMq1YEdO7GUlpZaklhYWFhYWFjauSQSwzCsbdu2hdT2/vvvDzy282suLS21rFZyCYfMAABA1G3cuDFwb7Q9e/ZIkk6cOBF4vq6uLnDD2aysrJjXxyEzAAASkBWtQ0dRNHr0aH366aeBs8gyMjKUn58vn88XuEXIrFmz9MEHH2jmzJkxrY0RIgAA4HoepxJmWVmZNWrUKEf6BgAg0SXiCFF7eDyeJuuRfN1lZWUaOXKkp6XnGCECAACuRyACAACuRyACAACuRyACAACuRyACACDBuGVCtR3OPffckNoRiAAAQEJoTxBctWqVHn/8cRUVFbXZjkAEAACS0n333aevfe1revzxx5Wfn99mWwIRAABISps2bQq5LYEIAADEpdMvyhiODh06aNKkSTp58mRI7QlEAAAgZmbNmqWSkhJdfPHFmjlzpgYPHqyMjAwNGjRIgwYNkiR17Bj5rVZPnjypXr16qUOHDiG15+auAAAkkEQ/wywnJ0e5ubn65JNPJEmbN2/WwIED9eGHH0qSCgsLtWLFioj7SU9P129+85uQ2xOIAABATHTs2FHPPPNMk20DBw6UJF122WWBfw3DkGmaEfXl8XhUUFAQcnsOmQEAgJjo1q2b7rvvvqDtLr/88oj7qqur0+rVq0NuTyACAAAxUV1drQ8++KDNNhs3brTlkNktt9yiiy66KOT2BCIAABATt912m8aMGdNmm+zsbO3duzfivnw+X5P14uLiNtsTiAAAgOsRiAAAQEy8++67QdsUFRUpLS2t2fZwz6574YUXVFJSolmzZikrK0t5eXlttucsMwAAEBM///nPg7aprq7Wzp07I+7r9ttv1759+5Sbm6vZs2cHbc8IEQAAiIn//d//DdrG6/UqNTU14r727dsXVnsCEQAAiLr09HSNHj06aLuKigr1798/BhU1RSACACBBJPJVqg8cOKB+/foFbVdaWhrxRRnbg0AEAACi7mtf+5pqamqCtgvn2kF2IhABAICoO++884Jeg0iSHnjggRhU0xxnmQEAgKjbuXOndu3apd69ezfZXl1dLZ/PF7iQoh1XqW4PRogAAEDUPfjgg4EwVFtbq8LCQnm9XmVkZGjatGlNQpETGCECAABR5/P5lJWVpcLCQvl8PtXW1oZ1N/poIxABAICoa7iXmNfrdbaQVnDIDAAAxB2PxxPT/ghEAADA9QhEAAAgrsXigpQEIgAA4HoEIgAA4HoEIgAA4HoEIgAAEkAi39g1ERCIAACA6xGIAACA6xGIAACA6xGIAACA6xGIAACA6xGIAACA6xGIAACA6xGIAACA6xGIAACA6xGIAABAXPF4PDHvk0AEAABcj0AEAABcj0AEAADiVqxuaksgAgAArkcgAgAArkcgAgAArkcgAgAArkcgAgAArkcgAgAAccOJizJKBCIAAAACEQAA8S5W1+JxMwIRAABwPQIRAABwPQIRAABwPQIRAABwPQIRAABwPQIRAABwPQIRAABwPQIRAABwPQIRAACIS7G8IGXHmPUEAADQCqfuYdaAESIAAOB6BCIAAOB6BCIAAOB6BCIAAOB6BCIAAOB6BCIAAOB6BCIAAOB6BCIAAOB6BCIAAOJYLK/W7GYEIgAA4HoEIgAA4Hoh3cvMMIxKSYcknZRUZ5rmKMMwzpL0pqQsSZWSbjJNc79hGB5Jz0maKOmIpGmmaa62vXIAAACbhDNCdLlpmjmmaY7yr8+StNI0zQskrfSvS9IESRf4lzslvWhXsQAAANEQySGz6yUt9D9eKMnbaPtrpmlapmmWSMowDOPcCPoBAACIqlADkSXpb4ZhlBmGcad/W2/TNL/0P66S1Nv/uI+k7Y1eu8O/DQAAIC6FGojGmKZ5keoPh/3IMIxvNX7SNE1L9aEJAAAg4YQUiEzT3On/d7ekJZIukbSr4VCY/9/d/uY7JfVr9PK+/m0AACAMbrkGkcfjabYt1l970EBkGEaaYRhnNjyWdLWkDZKWSZrqbzZV0lL/42WSbjUMw2MYRq6kA40OrQEAAMSdUE677y1piWEYDe3fME2zyDCMTyT9wTCM6ZK2SbrJ3/5d1Z9yX6H60+5/YHvVAAAANgoaiEzT3CJpRAvbv5I0roXtlqQf2VIdAABADEx5gRkAAASMSURBVHClagAA4HoEIgAA4HoEIgAA4HoEIgAA4HoEIgAA4HoEIgAA4Hoep66CWVZW5o7LbwIAgLgxcuTI5pfFloOBCAAAIF5wyAwAALgegQgAALgegQgAALheKDd3tZ1hGPmSnpPUQdJLpmnOdqIOSIZhvCLpGkm7TdMc6t92lqQ3JWVJqpR0k2ma+w3D8Kj+fZuo+hv3TjNNc7UTdbuNYRj9JL2m+pstW5IWmKb5HO9VfDEMI1XSPyWlqP7z9U+maT5mGMb5kgol9ZRUJun7pmkeNwwjRfXv60hJX0m62TTNSkeKdyHDMDpIKpW00zTNa3if4o9hGJWSDkk6KanONM1R0frci/kIkf8H8NeSJkgaLGmyYRiDY10HAn4nKf+0bbMkrTRN8wJJK/3rUv17doF/uVPSizGqEVKdpAdN0xwsKVfSj/y/N7xX8eWYpCtM0xwhKUdSvmEYuZLmSJprmuYgSfslTfe3ny5pv3/7XH87xM79kj5vtM77FJ8uN00zxzTNUf71qHzuOXHI7BJJFaZpbjFN87jq0/j1DtQBSaZp/lPSvtM2Xy9pof/xQkneRttfM03TMk2zRFKGYRjnxqZSdzNN88uG/+mYpnlI9R/ifcR7FVf83+8a/2on/2JJukLSn/zbT3+fGt6/P0ka5/9fLqLMMIy+kiZJesm/7hHvU6KIyueeE4Goj6TtjdZ3+LchfvQ2TfNL/+Mq1R+mkXjv4oJhGFmSLpS0SrxXcccwjA6GYZRL2i3pPUmbJVWbplnnb9L4vQi8T/7nD6j+cA2i71lJj0g65V/vKd6neGRJ+pthGGWGYdzp3xaVzz0mVaNNpmlaqv+BRBwwDKObpD9Lmmma5sHGz/FexQfTNE+appkjqa/qR8SzHS4JpzEMo2HeZJnTtfz/9u6etYogCuP4X0FBRLRQRIighTy9nUTERkurIAHRIJbaizY2FlaCH0BBRA0pDAaR2CQfIIWFbzyQRjCFqbS3sJi5YRHExr27MM+vmb2zWwwcmHt29xw2/ums7dOU12E3JZ3rnvyf+94QCdEWcLzze6bOxXh8nzxmrON2nU/sBiRpDyUZem77VZ1OrEbK9g9gHThDeXQ/aWLpxmInTvX8QUrRbvRrFrhUC3YXKa/KHpE4jY7trTpuA8uUm4xe9r0hEqIN4JSkk5L2AvPAygDriL9bARbq8QLwujN/TdKuWij6s/PYMnpU6xUeA19sP+ycSqxGRNIRSYfq8T7gAqXeax2Yq5f9GadJ/OaAtXrHGz2yfcf2jO0TlP+gNdtXSJxGRdJ+SQcmx8BF4CM97XtTb7u3/UvSLeAdpe3+ie1P015HFJJeAueBw5K+AfeAB8CSpBvAV+ByvfwtpZ1xk9LSeH3qC27XLHAV+FDrUwDukliNzTHgae2m3Q0s2X4j6TOwKOk+8J6S3FLHZ5I2Kc0N80MsOnbcJnEak6PAsiQo+coL26uSNuhh38u3zCIiIqJ5KaqOiIiI5iUhioiIiOYlIYqIiIjmJSGKiIiI5iUhioiIiOYlIYqIiIjmJSGKiIiI5v0GsjqXaHNkWRQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "instance_token_img, sample_token_img = 'bc38961ca0ac4b14ab90e547ba79fbb6', 'e0845f5322254dafadbbed75aaa07969'\n",
    "my_scene = nusc.scene[0]\n",
    "my_scene_token = my_scene['token']\n",
    "scene_rec = nusc.get('scene', my_scene_token)\n",
    "first_sample_token = scene_rec['first_sample_token']\n",
    "curr_sample_token = first_sample_token\n",
    "sample_rec = nusc.get('sample', curr_sample_token)\n",
    "first_ego_pose = get_ego_pose(sample_rec)\n",
    "curr_frame = 20\n",
    "for x in range(curr_frame-1):\n",
    "    curr_sample_token = sample_rec['next']\n",
    "    sample_rec = nusc.get('sample', curr_sample_token)\n",
    "ego_pose = get_ego_pose(sample_rec)\n",
    "\n",
    "\n",
    "img = mtp_input_representation.make_input_representation(ego_pose, ref_ego_pose, instance_token_img, curr_sample_token)\n",
    "\n",
    "print('delx is {} meters, dely is {} meters'\\\n",
    "      .format(ego_pose['translation'][0]-first_ego_pose['translation'][0],\\\n",
    "              ego_pose['translation'][1]-first_ego_pose['translation'][1]))\n",
    "plt.figure(figsize=(20,10))\n",
    "plt.grid(False)\n",
    "plt.imshow(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'token': 'cc8c0bf57f984915a77078b10eb33198',\n",
       " 'log_token': '7e25a2c8ea1f41c5b0da1e69ecfa71a2',\n",
       " 'nbr_samples': 39,\n",
       " 'first_sample_token': 'ca9a282c9e77460f8360f564131a8af5',\n",
       " 'last_sample_token': 'ed5fc18c31904f96a8f0dbb99ff069c0',\n",
       " 'name': 'scene-0061',\n",
       " 'description': 'Parked truck, construction, intersection, turn left, following a van'}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nusc.scene[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate For All 85 scenes in part 1 of dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "======\n",
      "Loading NuScenes tables for version v1.0-trainval...\n",
      "23 category,\n",
      "8 attribute,\n",
      "4 visibility,\n",
      "64386 instance,\n",
      "12 sensor,\n",
      "10200 calibrated_sensor,\n",
      "2631083 ego_pose,\n",
      "68 log,\n",
      "850 scene,\n",
      "34149 sample,\n",
      "2631083 sample_data,\n",
      "1166187 sample_annotation,\n",
      "4 map,\n",
      "Done loading in 47.3 seconds.\n",
      "======\n",
      "Reverse indexing ...\n",
      "Done reverse indexing in 14.5 seconds.\n",
      "======\n"
     ]
    }
   ],
   "source": [
    "import colorsys\n",
    "import os\n",
    "\n",
    "import cv2\n",
    "import numpy as np\n",
    "from pyquaternion import Quaternion\n",
    "\n",
    "from nuscenes.eval.common.utils import quaternion_yaw\n",
    "from nuscenes.map_expansion.map_api import NuScenesMap\n",
    "from nuscenes.prediction.helper import angle_of_rotation, angle_diff\n",
    "from nuscenes.prediction.input_representation.combinators import Rasterizer\n",
    "from nuscenes.prediction.input_representation.interface import \\\n",
    "    StaticLayerRepresentation, AgentRepresentation\n",
    "from nuscenes.prediction.input_representation.utils import get_crops, get_rotation_matrix, convert_to_pixel_coords\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "from nuscenes.prediction.input_representation.combinators import Rasterizer\n",
    "from nuscenes.prediction import PredictHelper\n",
    "\n",
    "from typing import Any, Dict, List, Tuple, Callable\n",
    "\n",
    "from nuscenes.prediction.helper import quaternion_yaw\n",
    "\n",
    "%matplotlib inline\n",
    "from nuscenes.nuscenes import NuScenes\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import copy\n",
    "import PIL\n",
    "import os\n",
    "from skimage import color\n",
    "from nuscenes.utils.geometry_utils import view_points, box_in_image, BoxVisibility, transform_matrix\n",
    "from nuscenes.utils.data_classes import LidarPointCloud\n",
    "from pyquaternion import Quaternion\n",
    "nusc = NuScenes(version='v1.0-trainval', dataroot='/datasets/home/44/344/abkandoi/nuscenes-full-data', verbose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "static_layers.py - Loading Map: boston-seaport\n",
      "static_layers.py - Loading Map: singapore-hollandvillage\n",
      "static_layers.py - Loading Map: singapore-queenstown\n",
      "static_layers.py - Loading Map: singapore-onenorth\n",
      "static_layers.py - Loading Map: boston-seaport\n",
      "static_layers.py - Loading Map: singapore-hollandvillage\n",
      "static_layers.py - Loading Map: singapore-queenstown\n",
      "static_layers.py - Loading Map: singapore-onenorth\n",
      "static_layers.py - Loading Map: boston-seaport\n",
      "static_layers.py - Loading Map: singapore-hollandvillage\n",
      "static_layers.py - Loading Map: singapore-queenstown\n",
      "static_layers.py - Loading Map: singapore-onenorth\n",
      "static_layers.py - Loading Map: boston-seaport\n",
      "static_layers.py - Loading Map: singapore-hollandvillage\n",
      "static_layers.py - Loading Map: singapore-queenstown\n",
      "static_layers.py - Loading Map: singapore-onenorth\n",
      "static_layers.py - Loading Map: boston-seaport\n",
      "static_layers.py - Loading Map: singapore-hollandvillage\n",
      "static_layers.py - Loading Map: singapore-queenstown\n",
      "static_layers.py - Loading Map: singapore-onenorth\n"
     ]
    }
   ],
   "source": [
    "helper = PredictHelper(nusc)\n",
    "\n",
    "static_layer_rasterizer = StaticLayerRasterizer2(helper, layer_names=['drivable_area'], resolution=0.5, meters_ahead = 64, meters_behind = 64,meters_left = 64, meters_right=64)\n",
    "agent_rasterizer = OtherVehicleRepresentation(helper, resolution=0.5, meters_ahead = 64, meters_behind = 64,meters_left = 64, meters_right=64)\n",
    "road_rep = InputRepresentationStaticOnly(static_layer_rasterizer, agent_rasterizer, Rasterizer())\n",
    "\n",
    "static_layer_rasterizer2 = StaticLayerRasterizer2(helper, layer_names=['lane_divider'], resolution=0.5, meters_ahead = 64, meters_behind = 64,meters_left = 64, meters_right=64)\n",
    "agent_rasterizer2 = OtherVehicleRepresentation(helper, resolution=0.5, meters_ahead = 64, meters_behind = 64,meters_left = 64, meters_right=64)\n",
    "lane_rep = InputRepresentationStaticOnly(static_layer_rasterizer2, agent_rasterizer2, Rasterizer())\n",
    "\n",
    "static_layer_rasterizer3 = StaticLayerRasterizer2(helper, layer_names=['walkway'], resolution=0.5, meters_ahead = 64, meters_behind = 64,meters_left = 64, meters_right=64)\n",
    "agent_rasterizer3 = ObstacleAgentRepresentation(helper, resolution=0.5, meters_ahead = 64, meters_behind = 64,meters_left = 64, meters_right=64)\n",
    "obstacle_rep = InputRepresentationBoth(static_layer_rasterizer3, agent_rasterizer3, Rasterizer())\n",
    "\n",
    "static_layer_rasterizer4 = StaticLayerRasterizer2(helper, layer_names=['drivable_area'], resolution=0.5, meters_ahead = 64, meters_behind = 64,meters_left = 64, meters_right=64)\n",
    "agent_rasterizer4 = OtherVehicleRepresentation(helper, resolution=0.5, meters_ahead = 64, meters_behind = 64,meters_left = 64, meters_right=64)\n",
    "other_rep = InputRepresentationAgentOnly(static_layer_rasterizer4, agent_rasterizer4, Rasterizer())\n",
    "\n",
    "static_layer_rasterizer5 = StaticLayerRasterizer2(helper, layer_names=['drivable_area'], resolution=0.5, meters_ahead = 64, meters_behind = 64,meters_left = 64, meters_right=64)\n",
    "agent_rasterizer5 = TargetVehicleRepresentation(helper, resolution=0.5, meters_ahead = 64, meters_behind = 64,meters_left = 64, meters_right=64)\n",
    "target_rep = InputRepresentationAgentOnly(static_layer_rasterizer5, agent_rasterizer5, Rasterizer())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating for scene idx, 1, name:scene-0002\n",
      "current_frame is  4\n",
      "11\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "past_seconds = 2\n",
    "future_seconds = 4\n",
    "\n",
    "for j in range(1,len(nusc.scene)//10):\n",
    "    print('Generating for scene idx, {}, name:{}'.format(j, nusc.scene[j]['name']))\n",
    "    my_scene_token = nusc.scene[j]['token']\n",
    "    scene_rec = nusc.get('scene', my_scene_token)\n",
    "\n",
    "    current_token = scene_rec['first_sample_token']\n",
    "    current_seq = []\n",
    "    \n",
    "    #for i in range(scene_rec['nbr_samples']):\n",
    "    for i in range(12):\n",
    "        #get current sample data\n",
    "        sample_rec = nusc.get('sample', current_token)\n",
    "        \n",
    "        pointsensor_token = sample_rec['data']['LIDAR_TOP']\n",
    "        pointsensor = nusc.get('sample_data', pointsensor_token)\n",
    "        #get ego vehicle pose\n",
    "        pose_record = nusc.get('ego_pose', pointsensor['ego_pose_token'])\n",
    "        \n",
    "        current_seq.append(pose_record)\n",
    "        \n",
    "        if len(current_seq) >= 12:\n",
    "            current_frame = i - 2*future_seconds + 1\n",
    "            print('current_frame is ', current_frame)\n",
    "            \n",
    "            time_frame = current_seq[current_frame-2*past_seconds:-1]\n",
    "            print(len(time_frame))\n",
    "            ref_ego_pose = current_seq[current_frame]\n",
    "            \n",
    "            count = 0\n",
    "            for ego_pose in time_frame:\n",
    "                target_chan = target_rep.make_input_representation(ego_pose, ref_ego_pose, '', current_token)\n",
    "                other_chan = other_rep.make_input_representation(ego_pose, ref_ego_pose, '', current_token)\n",
    "                obstacle_chan = obstacle_rep.make_input_representation(ego_pose, ref_ego_pose, '', current_token)\n",
    "                road_chan = road_rep.make_input_representation(ego_pose, ref_ego_pose, '', current_token)\n",
    "                lane_chan = lane_rep.make_input_representation(ego_pose, ref_ego_pose, '', current_token)\n",
    "                plt.figure(figsize=(12,6))\n",
    "                plt.grid(False)\n",
    "                plt.imshow(target_chan)\n",
    "                count+=1\n",
    "        # next sample\n",
    "        current_token = sample_rec['next']\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}