trap/test_trajectron_maps.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trajectron seems to support providing a map for a scene. This might be a way to get better predictions, that actually stay on the pathways instead of go through buildings. However, by default it supports maps from NuScenes, but not images (even though some traces of that remain in the code.)  More info about support in trajectron is in [issue #14](https://github.com/StanfordASL/Trajectron-plus-plus/issues/14) on their Github.\n",
    "\n",
    "This notebook is used to test my implementation to add map support to Trajectron."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CHANGELOG:\n",
    "\n",
    "* 2024-12-27 : Created\n",
    "    * Draw the map image\n",
    "    * Training _sometimes_ (randomly?) gives NaN matrixes since using map encoding.\n",
    "        * Call Image map and test if converted points of all tracks fall within realistic image bounds (e.g. no negative points)\n",
    "* 2024-12-28: Cells to double check heading\n",
    "    * Found bug in `config.json`: heading state index was derived from position instead of velocity. (changed [0,1] into [2,3])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ruben/suspicion/trap/.venv/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "from pathlib import Path\n",
    "from trap.frame_emitter import Camera\n",
    "from trap.utils import ImageMap\n",
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "path = Path(\"EXPERIMENTS/raw/hof3/\")\n",
    "calibration_path = Path(\"../DATASETS/hof3/calibration.json\")\n",
    "homography_path = Path(\"../DATASETS/hof3/homography.json\")\n",
    "\n",
    "camera = Camera.from_paths(calibration_path, homography_path, 12)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "../DATASETS/hof3/map-undistorted-H-2.png True\n"
     ]
    }
   ],
   "source": [
    "image_path = Path(\"../DATASETS/hof3/map-undistorted-H-2.png\")\n",
    "print(image_path, image_path.exists())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1440, 2560, 3)\n",
      "(72, 128, 3)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7feda2cca4d0>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "homography_matrix = np.array([\n",
    "            [5, 0,0],\n",
    "            [0, 5,0],\n",
    "            [0,0,1],\n",
    "        ]) # 100 scale\n",
    "img = cv2.imread(image_path)\n",
    "print(img.shape)\n",
    "img = cv2.resize(img, (img.shape[1]//20, img.shape[0]//20))\n",
    "\n",
    "print(img.shape)\n",
    "imgmap = ImageMap(img, homography_matrix, \"hof3-undistorted-H-2\")\n",
    "# img = cv2.imread(image_path)\n",
    "\n",
    "\n",
    "\n",
    "plt.imshow(img)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "img = imgmap.as_image()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fed93b3a1a0>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "# img = np.flipud(img)\n",
    "plt.imshow(img)\n",
    "# plt.gca().invert_yaxis()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from trap.tracker import TrackReader\n",
    "\n",
    "\n",
    "reader = TrackReader(path, camera.fps, exclude_whitelisted = False, include_blacklisted=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "from typing import List\n",
    "from trap.frame_emitter import Track\n",
    "from trap.tracker import FinalDisplacementFilter\n",
    "\n",
    "\n",
    "tracks: List[Track] = [t for t in reader]\n",
    "filter = FinalDisplacementFilter(2)\n",
    "tracks = filter.apply(tracks, camera)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[     12.247      6.8275]\n",
      " [     12.416      6.5942]\n",
      " [     12.528      6.5035]\n",
      " [     12.594      6.4782]\n",
      " [     12.631       6.477]\n",
      " [      12.66       6.424]\n",
      " [     12.706       6.369]\n",
      " [     12.785      6.2094]\n",
      " [     12.849      6.0079]\n",
      " [     12.919      5.7624]\n",
      " [     12.954      5.6717]\n",
      " [     12.979      5.6476]\n",
      " [     12.985       5.613]\n",
      " [     13.027      5.4535]\n",
      " [     13.072      5.2315]\n",
      " [     13.129       4.995]\n",
      " [     13.159       4.894]\n",
      " [     13.167      4.8371]\n",
      " [     13.163      4.8151]\n",
      " [     13.174      4.7545]\n",
      " [       13.2      4.5546]\n",
      " [     13.237      4.2617]\n",
      " [     13.241       4.165]\n",
      " [     13.242      4.1164]\n",
      " [     13.233      4.1089]\n",
      " [     13.238      4.0344]\n",
      " [      13.24       3.967]\n",
      " [     13.318      3.5567]\n",
      " [     13.329      3.4015]\n",
      " [     13.344      3.3385]\n",
      " [     13.357      3.3064]\n",
      " [     13.331      3.3068]\n",
      " [     13.298      3.0786]\n",
      " [      13.35      2.8114]\n",
      " [     13.364      2.6867]\n",
      " [     13.346      2.6791]\n",
      " [     13.326      2.6335]] [[61 34]\n",
      " [62 32]\n",
      " [62 32]\n",
      " [62 32]\n",
      " [63 32]\n",
      " [63 32]\n",
      " [63 31]\n",
      " [63 31]\n",
      " [64 30]\n",
      " [64 28]\n",
      " [64 28]\n",
      " [64 28]\n",
      " [64 28]\n",
      " [65 27]\n",
      " [65 26]\n",
      " [65 24]\n",
      " [65 24]\n",
      " [65 24]\n",
      " [65 24]\n",
      " [65 23]\n",
      " [65 22]\n",
      " [66 21]\n",
      " [66 20]\n",
      " [66 20]\n",
      " [66 20]\n",
      " [66 20]\n",
      " [66 19]\n",
      " [66 17]\n",
      " [66 17]\n",
      " [66 16]\n",
      " [66 16]\n",
      " [66 16]\n",
      " [66 15]\n",
      " [66 14]\n",
      " [66 13]\n",
      " [66 13]\n",
      " [66 13]]\n"
     ]
    }
   ],
   "source": [
    "# track = tracks[0]\n",
    "for track in tracks:\n",
    "    history = track.get_projected_history(None, camera)\n",
    "    points = imgmap.to_map_points(history)\n",
    "    print(history, points)\n",
    "    if not ((points[:,0] > 0 ) & (points[:,0] < 2440) & (points[:,1] > 0) & (points[:,1] < 1440)).all():\n",
    "        print(\"not all points between limits\")\n",
    "        print(points)\n",
    "    break\n",
    "\n",
    "# track.to_trajectron_node(camera, env)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7fed7c381ba0>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 2000x1600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "track = tracks[20]\n",
    "len(track.history)\n",
    "\n",
    "fig = plt.figure(figsize=(20,16))\n",
    "ax1, ax2 = fig.subplots(2)\n",
    "\n",
    "im = cv2.imread(\"../DATASETS/hof3/output.png\")\n",
    "ax2.imshow(im)\n",
    "ax1.set_aspect(1)\n",
    "ax2.set_aspect(1)\n",
    "\n",
    "t = track.get_with_interpolated_history()\n",
    "points = t.get_projected_history(None, camera)\n",
    "x, y = points[:,0], points[:,1]\n",
    "ax1.plot(x, y, alpha=.2)\n",
    "ax1.scatter(x, y, marker='x', alpha=.5)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "l = [d.get_foot_coords()[0] for d in track.history]\n",
    "t = [d.get_foot_coords()[1] for d in track.history]\n",
    "ax2.plot(l, t, alpha=.2)\n",
    "ax2.scatter(l, t, marker='x', alpha=.2)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test cropping of maps\n",
    "Similar to `get_cropped_maps_from_scene_map_batch()`  as used in `prediction_server.py`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[99.17289191829194,\n",
       " 145.38359542733454,\n",
       " 145.45747075339742,\n",
       " 153.38132347369094,\n",
       " 143.50219249969786,\n",
       " 107.41324194434551,\n",
       " 103.18682333877918,\n",
       " 135.1039011792769,\n",
       " 119.59945372561799,\n",
       " 116.7801428815335,\n",
       " 109.98894043130318,\n",
       " 99.18912044775988,\n",
       " 96.7451694797026,\n",
       " 103.30612625301178,\n",
       " 123.6212057127049,\n",
       " 172.02391500189054,\n",
       " -176.03717023364996,\n",
       " 177.03564826765745,\n",
       " 93.76808809597998,\n",
       " 91.28307403063258,\n",
       " -152.45887910552403,\n",
       " 151.12995651947134,\n",
       " 165.28228606465618,\n",
       " -170.19503622897125,\n",
       " -179.06726071552106,\n",
       " 155.01689423272055,\n",
       " 128.5345842544236,\n",
       " 168.35294787019714,\n",
       " 154.26131138597705,\n",
       " 179.88656922722078,\n",
       " -174.10210933989364,\n",
       " -169.64773317077814,\n",
       " 77.26207536280874,\n",
       " 157.18404495447388,\n",
       " -175.67544341520608,\n",
       " 169.4682767805252,\n",
       " -177.34318436522642,\n",
       " -171.63388387952614,\n",
       " 172.6662123310602,\n",
       " 169.51409368947765,\n",
       " 58.74581501349769,\n",
       " -173.0200297904452,\n",
       " -170.82651453849562,\n",
       " -171.04745749776717,\n",
       " -169.06545954403455,\n",
       " -166.30394576070668,\n",
       " 20.9939285462061,\n",
       " 167.70675733320058,\n",
       " -170.92950013080107,\n",
       " -177.6338225747888,\n",
       " -178.4176277631828,\n",
       " 174.89647400074446,\n",
       " 178.45985199263183,\n",
       " 156.5489739654461,\n",
       " 171.493427869434,\n",
       " -175.77997263026396,\n",
       " -171.6422986725836,\n",
       " -176.09525416235175,\n",
       " 159.944725454723,\n",
       " 130.671204030587,\n",
       " 152.62580892883915,\n",
       " 175.07192790014375,\n",
       " -177.54403290795983,\n",
       " 166.19004552610755,\n",
       " -154.67239315136342,\n",
       " 126.78090586426616,\n",
       " 134.64108756111685,\n",
       " 165.1003571459237,\n",
       " 156.33947840322347,\n",
       " -178.08924592826693,\n",
       " -178.07355015355424]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = np.diff(points, axis=0)\n",
    "# this angle formula comes from \n",
    "angles = [-np.arctan2(v[i, 0],\n",
    "                                v[i, 1]) * 180 / np.pi for i in range(v.shape[0])]\n",
    "angles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((71, 2), 71)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "points[1:].shape, len(angles)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "# torch.tensor(imgmap.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 2) 10 10\n"
     ]
    }
   ],
   "source": [
    "input_points = points[0:10:1]\n",
    "input_angles = angles[0:10:1]\n",
    "input_maps = [imgmap] * input_points.shape[0]\n",
    "print(input_points.shape, len(input_angles), len(input_maps))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ruben/suspicion/trap/.venv/lib/python3.10/site-packages/trajectron/environment/map.py:121: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at  ../torch/csrc/utils/tensor_new.cpp:201.)\n",
      "  centers = torch.tensor([s_map.to_map_points(scene_pts[np.newaxis, i]) for i, s_map in enumerate(maps)],\n",
      "/home/ruben/suspicion/trap/.venv/lib/python3.10/site-packages/torch/functional.py:478: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at  ../aten/src/ATen/native/TensorShape.cpp:2894.)\n",
      "  return _VF.meshgrid(tensors, **kwargs)  # type: ignore[attr-defined]\n"
     ]
    }
   ],
   "source": [
    "cropped_maps = ImageMap.get_cropped_maps_from_scene_map_batch(input_maps, input_points, [50, 10, 50, 90], input_angles)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# cropped_maps.all()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**I still cheat a little bit by drawing the reverse angle, as this is used by trajectron as the map should turn the opposite direction towards the angle** TODO: make sure these maths line up with prediction server and `process data`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def print_maps(cropped_maps, angles, input_points, previous_points = None):\n",
    "    if previous_points is None:\n",
    "        previous_points = [None] * len(cropped_maps)\n",
    "    for i, (m, angle, input_point, previous_point) in enumerate(zip(cropped_maps, angles, input_points, previous_points)):\n",
    "        fig, (ax1, ax2) = plt.subplots(1,2)\n",
    "        ax1.imshow(np.transpose(m.cpu().numpy(), (2, 1, 0)).astype(np.uint)*255)\n",
    "        ax1.arrow(10, 50, 15, 0, color='r')\n",
    "        ax1.scatter([10], [50], marker='o')\n",
    "\n",
    "        ax1.invert_yaxis()\n",
    "        # plt.show()\n",
    "        ax2.imshow(imgmap.as_image())\n",
    "        point = imgmap.to_map_points(np.array([input_point]))\n",
    "        \n",
    "        # print(p)\n",
    "        \n",
    "        # if len(input_points) > i+1:\n",
    "        y = np.sin(np.deg2rad(-angle))\n",
    "        x = np.cos(np.deg2rad(-angle))\n",
    "        d = np.array([x,y]) * 15\n",
    "        # dxy = (input_points[i+1] - input_points[i])\n",
    "        # d = (dxy / np.linalg.norm(dxy)) * 15\n",
    "        # # print(p[0][0], p[0][1],d[0], d[1])\n",
    "        ax2.arrow(point[0][0], point[0][1],d[0], d[1], color='r')\n",
    "        ax2.scatter(point[0][0], point[0][1], marker='x')\n",
    "\n",
    "        if previous_point is not None:\n",
    "            prevp = imgmap.to_map_points(np.array([previous_point]))\n",
    "            ax2.arrow(prevp[0][0], prevp[0][1],d[0], d[1], color='r')\n",
    "            ax2.scatter(prevp[0][0], prevp[0][1], marker='x')\n",
    "\n",
    "        ax2.invert_yaxis()\n",
    "        plt.show()\n",
    "print_maps(cropped_maps, input_angles, input_points)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test with only rotation, from a fixed point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.0, -45.0, -90.0, -135.0, -180.0, 135.0, 90.0, 45.0]\n"
     ]
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh8AAAENCAYAAACvqwfcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAABMvUlEQVR4nO3deXhU5dn48e9kmwTIQoBMEkggIMqmiARCwK2SllqxIGhdqD9EKy6gAr4uWNGKSlBbpSpKoRroq4hYxQUrvDQIFmUNYEUkgKCsCWsyIZCFmef3x5OZZLLOJLPn/lzXuSBnzpxzz2Q59zzL/RiUUgohhBBCCC8J8XUAQgghhGhdJPkQQgghhFdJ8iGEEEIIr5LkQwghhBBeJcmHEEIIIbxKkg8hhBBCeJUkH0IIIYTwKkk+hBBCCOFVYb4OoDar1cqRI0eIjo7GYDD4OhwhWiWlFCUlJSQnJxMSIp9RhBDu5XfJx5EjR0hJSfF1GEII4ODBg3Tp0sXXYQghgozffaSJjo72dQhCiCry+yiE8AS/Sz6kq0UI/yG/j0IIT/C75EMIIYQQwU2SDyGEEEJ4lSQfQgghhPAqST6EEEII4VWSfAghhBDCqyT5EEIIIYRXSfIhhBBCCK+S5EMIIYQQXiXJhxBCCCG8SpIPIYQQQniVJB9CCCGE8CpJPoQQQgjhVZJ8CCGEEMKrJPkQQgghhFdJ8iGEEEIIr5LkQwghhBBeJcmHEEIIIbxKkg8hhBBCeJUkH0IIIYTwKkk+hBBCCOFVknwIIYQQwqsk+RBCCCGEV0nyIYQQQgivkuRDCCGEEF4lyYcQQgghvEqSDyGEEEJ4lSQfQgghhPAqST6EEEII4VWSfAghhBDCq8J8HUBDMjIyCAtzPbxTp2DvXqistO2xAPuAY26MzqYdcCHh4VFccAHEx3vgEiLgnTp1ij179nD+/HlfhyKEEH7Bb5OPefPmER0d7fLz1qyBxx+HEydse84BzwD/dF9wdj2Al4iN7crDD8PVV3vgEiLg5ebmMn36dE6dOuXrUIQQwi/4bfLRvXt3YmJiXH7erl0QGlpzTyng+nmcEwmkEBrag8RE6NHDQ5cRAe37778n1PGHUgghWjUZ8yGEEEIIr/Lblg9XKAVWq94sFv21EEIIIfxTUCQfAF99BV98oQebnjnj62iEEEII0ZCgST42b4ZXXgGZUCCEEEL4N5fGfFgsFmbMmEFaWhpRUVH06NGDZ599FlWjn0MpxVNPPUVSUhJRUVFkZWWxZ88etwdem1LS3SKEEEIEApeSjxdeeIE333yT119/nR9++IEXXniBF198kddee81+zIsvvsirr77KvHnz2LhxI23btmXEiBGUlZW5PXghhBBCBB6Xul2++eYbRo0axXXXXQdAt27deO+999i0aROgWz3mzJnDk08+yahRowD4xz/+gclk4uOPP+aWW25xc/hCCCGECDQutXwMHTqU3Nxcdu/eDcC3337LunXruPbaawHYv38/BQUFZGVl2Z8TGxtLRkYG69evd2PYQgghhAhULrV8PP7445jNZnr16kVoaCgWi4Xnn3+ecePGAVBQUACAyWRyeJ7JZLI/Vlt5eTnl5eX2r81ms0svQAghhBCBxaWWj6VLl/Luu++yePFitm7dyqJFi/jzn//MokWLmh1AdnY2sbGx9i0lJaXZ5xJCCCGE/3Mp+XjkkUd4/PHHueWWW7j44ou5/fbbmTp1KtnZ2QAkJiYCUFhY6PC8wsJC+2O1TZ8+neLiYvt28ODB5rwOIYQQQgQIl5KPs2fPEhLi+JTQ0FCsVisAaWlpJCYmkpuba3/cbDazceNGMjMz6z2n0WgkJibGYRNCCCFE8HJpzMf111/P888/T2pqKn379mXbtm28/PLL3HnnnQAYDAamTJnCc889R8+ePUlLS2PGjBkkJyczevRoT8QvhBBCiADjUvLx2muvMWPGDO6//36OHTtGcnIy99xzD0899ZT9mEcffZTS0lImTpxIUVERl19+OStWrCAyMtLtwQshhI3VauXIkSNER0djMBh8HY4QrY5SipKSEpKTk+v0ktTmUvIRHR3NnDlzmDNnToPHGAwGZs6cycyZM105tRBCtMiRI0dkwLoQfuDgwYN06dKl0WOCZm0XX6qshH37YPt2SEqChASQD15CeFd0dHTV/w4CtceOFQHTgV3ANqBlazGEhIQQERHB4sWLGT58eIvO1dpYrVYqKys5ceIE+fn5LT5fYWEhx48f54033uDo0aMNHhcfH899991HYmIinTt3dqp1rF+/fiQkJDQrLqvVyrZt2yguLgZg06ZN9skZ7tKmTRsuu+wyrr76av7nf/7H5y1+ZrOZlJSUGr+LDZPkww3MZvjLX+Ctt+DBB2HCBF9HJETrU/2HN4a6yUc0sAj4BhgBtGy5B9sNNCoqSgbJu+j8+fOcPHmSr7/+mkmTJqGUclgfrDmUUlgslkaPOXXqFLNnzwZw6iZtMBhYvHgxN954Y7NiKi8v59lnn+U///mPPUZ369q1Kx9++CHx8fGEhob6PPmwcSYOST7c4Px5+PlnOHQIjh/3dTRCiLoM6D937vuTp5Ri6dKl7N27l9tvv53Y2Fi3ndvf2BKEf/3rX+zbt49z5841+2ZqtVo5e/YsO3fupLKy0iM35YY0laDUtmzZMvbu3dvkce3atSM9PZ2EhATS0tLIzc1lw4YN7N+/n/MeWGo9PDycW2+9lf79+9OuXTvCwgLvVh54EQshRIu459Oh1WolJyeHlStXMnLkSHsLiL98+gTc0qpgO4/FYuH9999n5cqVnDp1yuUbeSBavHixU8clJSXx4IMPcumll9KtWzeWL1/OX//6V4/FZTQamTx5MoMGDfLYNTxNkg8hRCtyEfAu8DnwllvOWFRUxCOPPMKgQYOYNm2aX30KPXToEPPnz+fEiRMcb0GzrC2JycvLw2w222s7Ce306dO8++67LF++nL///e98++23HrvWPffcw69//Wt69OjhsWt4g//8lgghhMd1AG4AjrjtjOfOnWPVqlWcP3/eLa0MZWVlVFRUuKVL4sCBA/z73//m8OHDQVw9OgTdmuW7lpiysjJ27Njh0WsYjUbatWvH0KFDg6JuliQfQohWKBSIBCpp6U3LVtugtLTUHYHx+eefs3r1arZs2cLp06dbdK6KigqOHTtGZWWlW2LzT52AtsAhoMLHsXjOqFGjePbZZ+ss3BqoJPkQQrRCiUAm8ANQ/4rbrrBarZw+fZr169e3uNtl69at7Nixg/z8fPs0TdGY7kA3IBUor+dxBXwPlHgxJvdp27Yt/fr147LLLqNnz55+NaaoJST5EEK0QiPRU27vRo8BabmtW7cyYsSIFp/HYrFgsVhkXIXT7gR+T8O1W8qA64D1XovInXr16sXy5cuJiYkJmsQDJPkQQrRKYeiul1T0INSfqP9Ts/OsVitlZS2rHyKaIwzdhdbY4zcCl9XafwTd6vUDugidfzEajYwZM4ZLL72U6OhoIiIifB2SW0nyIYRoxS4AMoDjtDT5EP4qHJhWz/7/AF8DJ/HH5KNNmzY8+eST9OnTx9eheIQkH0KIVuwKIAVd+fSUj2MR3vUd8E/cMebH3e677z6uuOIKkpOTfR2Kx0jyIYRopQxAT8CEnjFxGDjn04iEK0Ko7j5rjiNAnvvCcYOIiAgiIyMZPnw4Y8eO9XU4HtX4mrdCCBH0ooDngOer/i8CQ0/gFiCtmc/3Xll3Z918882sXbuWa665xteheJy0fAghWrlQ9KDTMpr/KTqQRaAX3osF2gH7gDMNHJtG3UX7bH7Gu2MnOgKXAu29eE13SES3ttWVkHApl156qVej8RVp+RBCeMXhw4f5/e9/T4cOHYiKiuLiiy9my5Yt9seVUjz11FMkJSURFRVFVlYWe/bs8UJkBiCpamuNfxI7A78FXgZygQENHBcCZANf1bOtBX7p8UgdXQzcB/Ty8nVb6k7qfw+/Au73YVzeJS0fQgiPO336NMOGDeMXv/gFX3zxBZ06dWLPnj20b1/9qfXFF1/k1VdfZdGiRaSlpTFjxgxGjBj
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "input_points = np.array([[14,7]]* 8)\n",
    "previous_points_offset = np.array([\n",
    "    [-1, 0],\n",
    "    [-1, -1],\n",
    "    [0, -1],\n",
    "    [1, -1],\n",
    "    [1, 0],\n",
    "    [1, 1],\n",
    "    [0, 1],\n",
    "    [-1, 1],\n",
    "])\n",
    "previous_points = input_points + previous_points_offset\n",
    "\n",
    "input_angles = [\n",
    "    -np.arctan2(i[1]-p[1],\n",
    "                                            i[0]-p[0]) * 180 / np.pi\n",
    "                for i,p in zip(input_points, previous_points)]\n",
    "print(input_angles)\n",
    "# input_angles = list(range(0,360, 45))\n",
    "input_maps = [imgmap] * 8\n",
    "\n",
    "cropped_maps = ImageMap.get_cropped_maps_from_scene_map_batch(input_maps, input_points, [50, 10, 50, 90], input_angles)\n",
    "print_maps(cropped_maps, input_angles, input_points, previous_points)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}