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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "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": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "../DATASETS/hof3/map-undistorted-H.png True\n"
     ]
    }
   ],
   "source": [
    "image_path = Path(\"../DATASETS/hof3/map-undistorted-H.png\")\n",
    "print(image_path, image_path.exists())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1440, 2560, 3)\n",
      "(72, 128, 3)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f7cd1700340>"
      ]
     },
     "execution_count": 16,
     "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\")\n",
    "# img = cv2.imread(image_path)\n",
    "\n",
    "\n",
    "\n",
    "plt.imshow(img)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "img = imgmap.as_image()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f7cd1736ad0>"
      ]
     },
     "execution_count": 19,
     "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "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": 21,
   "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": 22,
   "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": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7f7cab312bf0>"
      ]
     },
     "execution_count": 23,
     "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": 24,
   "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": 24,
     "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": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((71, 2), 71)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "points[1:].shape, len(angles)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "# torch.tensor(imgmap.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "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": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "self._last_padding=(142, 255)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ruben/suspicion/trap/.venv/lib/python3.10/site-packages/trajectron/environment/map.py:122: 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": 29,
   "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": 30,
   "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": "iVBORw0KGgoAAAANSUhEUgAAAh8AAAENCAYAAACvqwfcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAABcZElEQVR4nO3dd3iTZds/8G9296ZJW7qAQssulEKLKKP+qggPKCggKOIEQcX6oKIMUaSOV+VBQcAHEZT9KioIIhbBQSm0DJktlNK9R5KuzOv3B29vCW2hLUnuJD0/x3Edeo/c95k0CWeuKWCMMRBCCCGEWImQ7wAIIYQQ0rlQ8kEIIYQQq6LkgxBCCCFWRckHIYQQQqyKkg9CCCGEWBUlH4QQQgixKko+CCGEEGJVlHwQQgghxKrEfAdwM6PRiKKiIri7u0MgEPAdDiGdEmMMarUagYGBEArpNwohxLxsLvkoKipCcHAw32EQQgDk5+eja9eufIdBCHEwNpd8uLu7A7j+pefh4XHLc3U6HU6dOoW8vDz06tULffr0sblfaVVVVUhPT4dKpQJwvWbnxx9/xJ49e3iOjJDba/o8EkKIOdlc8tHU1OLh4XHb5AMAEhIS7vieTcvbMMa4+9+qyYcxhrYuiePm5oaQkBBu22g0Ii8vD/v27YPBYLiDqAmxPGr6JIRYgsDWFpZTqVTw9PSEUqlsU/JhDnq9HgcPHsTJkycxaNAg3HvvvRCLW8/LTp8+jV9++QU6na5D99PpdNDpdLh06RL27duHxsbGjoZOiEVZ83NICOk8bK7mgw96vR579+7FunXr8Nxzz2HUqFG3TD5OnTqF5cuXo76+vt33EgqFWLRoEd566y189913+O233yj5IIQQ0qlQ8vF/jEYjDAYDrl69ip9++gkKhQLR0dEQCAQ4ffo0ysvLuXNPnToFrVbboWYTo9HI1XiUlJRgzJgxKC8vx6lTp7h+IYQQQogjo+TjJocPH8aJEycQHx+Pzz77DBKJBP/zP/+D33//nTunsbERGo2mQ9dnjOGHH37AwYMHkZiYiOTkZBQVFWHOnDm4cOGCuZ4GIYQQYrM6ZfJRV1eH4uJiCAQCBAQEmIyQaWxsRGNjI4qLi3H58mWIxWIUFRWhoqLCbPevr69HfX09KioqUFlZiYaGBgQHB5vUpFRWVpr1noQQQoit6JTJx/nz57Fs2TKIxWIsXboUvXv3bnbOpUuXkJSUBIFAgKtXr1okjuPHj2POnDkIDg7Gc889x82nwBjDxo0bsX79ehiNRovcmxBCCOGLwyYfRqMRjY2NLfbLKC0txalTpyCRSFBWVoaQkJBmI1dqa2vx999/WzTG6upqVFdXQ6PRQKFQIDIyEsD15KNLly4WvTchhBDCF4dNPsrLy7F27VpkZ2c3O1ZcXIyamhoIhUJ88skn8PPzQ3p6Og9RXldUVIQVK1bA29ub23f27Nk2zyVCCCGE2BO7nufjVqFfuXIFjz32GNLS0swdIiGdBs3zQQixBLuu+dBqtfj1119x8eJFbl+3bt2QmJjIY1SEEEIIuRW7Tj4aGxuxY8cObN++ndt33333Yfjw4TxGRQghhJBbsfnkgzGG7OxsZGdnN2tmqa+vR0FBgUln0ZKSEhw6dAgNDQ2oqamxcrSEEEIIuR27SD5+/PFHfPzxx82GnRqNRiiVSpN9f//9N+bPnw/GGCUfhBBCiA2y2eTj6tWrcHd3B2MMeXl5KC4ubtOcFxqNBmVlZVaIkBBCCCEdYbPJx7PPPsst7lZQUECTbRFCCCEOwmaTjxMnTvAdAiGEEEIsQHj7UwghhBBCzIeSD0IIIYRYFSUfhBBCCLEqSj4IIYQQYlWUfBBCCCHEqij5IIQQQohVUfJBCCGEEKui5IMQQgghVkXJByGEEEKsipIPQgghhFgVJR+EEEIIsSpKPgghhBBiVZR8EEIIIcSqKPkghBBCiFVR8kEIIYQQq6LkgxBCCCFWRckHIYQQQqyKkg9CCCGEWBUlH4QQQgixKko+CCGEEGJV7Uo+DAYDFi9ejPDwcDg7O6N79+545513wBjjzmGMYcmSJQgICICzszMSEhJw+fJlswdObE9YWBimTZuG8ePHw8vLi+9wCCGE2Chxe05+//338fnnn2PTpk3o06cP0tPTMWvWLHh6euLFF18EAHzwwQdYtWoVNm3ahPDwcCxevBiJiYm4cOECnJycLPIkiG0YPHgwPvjgA+Tn5yM7Oxs1NTV8h0QIIcQGtSv5OHr0KCZMmIAHHngAwPVfutu2bcPx48cBXK/1WLlyJRYtWoQJEyYAADZv3gy5XI7vv/8eU6dONXP4xJaIxWK4ubnBz88P/fr1g0wmw7Vr11BdXc13aIQQQmxIu5pd4uPjkZKSgqysLADAmTNn8Oeff+L+++8HAOTk5KCkpAQJCQncYzw9PTF06FCkpqaaMWxiy4KDg5GcnIzPP/8csbGxfIdDCCHExrSr5uP111+HSqVCZGQkRCIRDAYD3n33XUyfPh0AUFJSAgCQy+Umj5PL5dyxm2k0Gmg0Gm5bpVK16wkQ26HRaFBRUQEPDw+4urrC19cXfn5+6NKli8k5arXapJ8QIYSQzqVdycfOnTuxZcsWbN26FX369MHp06cxf/58BAYGYubMmR0KIDk5GcuWLevQY4ltOX78OF544QVIJBIAgEwmw1133YVHHnmEO+fYsWP47LPPoFar+QqTEEIIz9qVfCxYsACvv/4613ejX79+yM3NRXJyMmbOnAmFQgEAKC0tRUBAAPe40tJSDBw4sMVrLly4EElJSdy2SqVCcHBwe58HsQFFRUUoKiritr29vTF58mSMHTsWQqEQAoEARqMRTk5OqKurg9Fo5DFaQgghfGlXn4/6+noIhaYPEYlE3D8i4eHhUCgUSElJ4Y6rVCqkpaUhLi6uxWvKZDJ4eHiYFOIYGhoasGPHDixduhSHDh0CYwxRUVFYuHAhXnjhBQQGBvIdIiGEEB60q+Zj/PjxePfddxESEoI+ffrg1KlT+Pjjj/Hkk08CAAQCAebPn4/ly5cjIiKCG2obGBiIiRMnWiJ+YsMaGxuxe/du/PjjjxCLxRg1ahR69uyJiIgIXLx4EX/88YdJTQkhhJDOoV3Jx6efforFixfj+eefR1lZGQIDA/Hcc89hyZIl3Dmvvvoq6urq8Oyzz6KmpgZ33XUXfv7553bP8TFu3DicOXMG+fn57XocsT1GoxHnzp3Djh07uJoztVqNIUOGICIigjvv4sWLOHv2LHVGJR1iNBpRVFQEd3d3CAQCvsMhpNNhjEGtViMwMLBZK0lLJ9sUpVLJALAzZ86wCRMmMABUHKDIZDLm6enJlZiYGPbHH3+w6upqVl1dzaqqqthbb73FRCIR77FS+acolUq+vxLaLD8/n/fXiwoVKmD5+fm3/by2q+bDmry9vREREYEBAwagtLS01aG6xD7cPKS6qqoK+fn58PDwQHBwMLy8vBAaGooBAwaguroa+fn50Ov1PEZM7I27uzsAcO8rYh/Ky8tRVlaGF198Eenp6Wa55pQpU7Bu3TqqAbOypgEjTZ/FW7HZ5MPV1RUvvPACHnvsMaxbtw5r166l0REOpLCwEIsXL0aXLl2waNEijB07Fg888ABiYmLw+++/Y8mSJaisrOQ7TGJHmv6hoY7r9uW3337DL7/8YtYfmFKpFB4eHpR88KQtr7vNJh9isRghISHo2rVrs0nLiP3TaDTIzs5GWVkZCgsLUV1dDZFIhMDAQCgUCvj4+ECn06Gurg4Gg4HvcAkhFlJQUICMjAyaYLKTsdnkg3QODQ0N2LBhAw4ePMjtCwgIwOLFi1FTU4NPP/2UVkUmxIHl5eUhLS3NItdmjFHth42yi+RDIBBAKBSajIJgNCLCIej1ehw/fpxbnFAgEGDs2LF44403UFtbi61bt+LKlSsmj6G/PSHkVnQ6HdRqNZycnCCVSvkOh7TA5pMPgUCAESNG4M033+T6fFRUVGD37t3UCdXBxMfHY/To0ejVqxfc3NwgkUgwa9Ys3Hvvvdw5aWlp+PXXX6n/DyGkVQaDAfX19RCLxZR
      "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": "iVBORw0KGgoAAAANSUhEUgAAAh8AAAENCAYAAACvqwfcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAABexUlEQVR4nO3deXxTVfo/8E/2pFu6LyndgC7sFAqlLQJKnX5FQKQiCI64IgooyziI80MHXHADEQRZhkFUEEVFQWUcLKIgpdBCoWxtodB9pW3SNds9vz+wGUpb6JLkJu3zfr3Oi/bem5snIUmfnHvOcwSMMQZCCCGEECsR8h0AIYQQQnoWSj4IIYQQYlWUfBBCCCHEqij5IIQQQohVUfJBCCGEEKui5IMQQgghVkXJByGEEEKsipIPQgghhFiVmO8AbsVxHIqKiuDs7AyBQMB3OIT0SIwx1NTUQKVSQSik7yiEEPOyueSjqKgIAQEBfIdBCAGQn5+PXr168R0GIaSbsbnkw9nZGcCNDz0XFxeL3Mevv/6KuXPnQiKRYPPmzYiLi7PI/bSG4zh8//332L9/P6KiovDYY4/BYDDg5MmTKCkpwY4dO3Dy5EmrxUPI7TS9HwkhxJxsLvloutTi4uJiseTD0dERYrEYYrEYjo6OFruf1hiNRuTk5OC7776DUCjEnDlz4O7ujsDAQFRXV+Po0aNITU0FLblDbAFd+iSEWILNJR/WEBISgvnz50MkEln9Eo9AIMCYMWNgNBoxYMAAKBQK0z6ZTIYpU6agd+/e+OOPP/D7779TEkIIIaTbEdjaqrYajQZKpRJqtdpiPRKMMXAcBwAQCoVW/XbHGDPdv0AgaHb/Tds5jsPbb7+NFStWwGg0Wi02Qm5lyfchIaTn6pE9HwKBACKRyGzna2xsxJkzZ1BaWmra1qtXLwwaNAh1dXU4ffo0ampqOnROxhjuv/9+U89HbW0tTp06BbVabba4CSGEED70yOTD3DQaDT788EMcPHjQtC0xMRHvvvsucnNzsXz5cmRmZrb7fAKBAHPmzMHmzZtNSdLly5fx/PPPIz093dzhE0IIIVZFyQduzEApKytDdXV1m8cIBAJ4eXnBzc0NarUaZWVlpks3FRUVKCwsREVFhen4wsJCZGVlITc3FyUlJc32tUdFRQWuX78OpVIJX19f+Pj4oG/fvqirq0NpaSk0Gk2nHishhBDCtx455uNWWq0WH3zwAb755ps2j5FIJFiwYAFmzJiB/fv34/3330dDQwMAQK/X49q1a80uibi7uyMoKAharRY5OTlobGzsUEx+fn7w9/fHmDFj8I9//AMKhQJXr15FeXk53n33Xfz000+de7CEdACN+SCEWILN93wwxqDT6aDT6SAWiyGXy5sN0NRqtdDr9ZBKpZBKpTAajWhsbOzQLBGtVovLly8jNTW1zWMkEgny8vJQW1uLgoICpKWlob6+vs3jKysrUVlZ2f4Heovi4mIUFxfDy8sLarUaMpkM4eHhCAwMhL+/P5ycnEzPCyGEEGJP7CL5OHDgAL777jtERkbiqaeegpOTEwCgoaEBO3bsQHJyMu6//3489NBDOHfuHLZt29ahgZlGo/G2iUfTMV9//TXOnz+Py5cvW+2PfkZGBpYuXYqQkBA8++yzCAgIwGOPPYbRo0fjwIED2LNnD82IIYQQYldsNvlompLKGMOZM2fw2WefQa1WY9asWXB0dARw43LH0aNHsWvXLvj6+mLq1KkoLCzEnj17ms08MQeO45CamnrHJMXcCgoKsGfPHoSHhyMxMREhISGIi4tDXFwcysrK8M0331DyQQghxK7YbPKxfv16yOVyMMZw7NgxMMaQnZ2NjRs3wsHBAcCNyyUXL14EAJw8eRIffPABsrKyUFdXx2foFlFZWYldu3bh+PHjGD9+PPr37893SIQQQkin2OyAU7FYbBrbYTQaTUW5RCJRszEfRqMRjDEIhUIIhULTtu5IJBLBxcUF69atw6xZs7B69Wq88sor0Ov1fIdGuikacEoIsQSb7fkwGAwttjHGWt0OwFQZtDszGo1oaGjAmTNn4OnpCa1Wi/j4eJSVleHcuXPQarV8h0gIIYTckZDvAEjHaLVabN26FU8++STUajU2bdqExYsXQ6lU8h0aIYQQ0i422/NBWscYg1qthlqtRmVlJRoaGqDVamkBOkIIIXaDkg87duDAAZw/fx5qtfq21VkJIYQQW0LJhx0rKipCUVER32EQQgghHUJjPgghhBBiVZR8EEIIIcSqKPkghBBCiFVR8kEIIYQQq6LkgxBCCCFWRckHIYQQQqyKkg9CCCGEWBUlH4QQQgixKko+CCGEEGJVlHwQQgghxKoo+SCEEEKIVVHyQQghhBCrouSDEEIIIVZFyQchhBBCrIqSD0IIIYRYFSUfhBBCCLEqSj4IIYQQYlWUfBBCCCHEqij5IIQQQohVUfJBCCGEEKvqUPJhNBqxfPlyhISEQKFQoE+fPnj99dfBGDMdwxjDq6++Cj8/PygUCsTHxyM7O9vsgRNCCCHEPnUo+XjnnXfw8ccf46OPPsLFixfxzjvv4N1338X69etNx7z77rtYt24dNm3ahJSUFDg6OiIhIQGNjY1mD54QQggh9kfAbu62uIOJEyfCx8cH27ZtM21LTEyEQqHA559/DsYYVCoVlixZgr/97W8AALVaDR8fH3zyySeYMWPGHe9Do9FAqVQiMjISIpGo2b7q6mpcvXoVRqOxvSETQrpArVbDxcWF7zAIId2MuCMHx8bGYsuWLcjKykJYWBjOnDmDo0ePYs2aNQCAq1evoqSkBPHx8abbKJVKREdHIzk5uV3JR5MtW7bAycmp2bZffvkFy5cvR3V1dUfCJoQQQogN6VDy8fLLL0Oj0SAiIgIikQhGoxFvvvkmZs2aBQAoKSkBAPj4+DS7nY+Pj2nfrbRaLbRarel3jUYDAAgLC2vxjSsnJwfe3t4QCASoqamBwWDoSPiEEEIIsQEdGvPx1VdfYefOndi1axdOnTqFHTt24P3338eOHTs6HcCqVaugVCpNLSAgoM1jIyMj8eGHH+L1119HUFBQp++TEEIIIfzpUPLx0ksv4eWXX8aMGTMwaNAg/PWvf8WiRYuwatUqAICvry8AoLS0tNntSktLTftutWzZMqjValPLz89v8/59fX1x7733YsyYMXQdmhBCCLFTHbrsUl9fD6Gweb4iEonAcRwAICQkBL6+vkhKSsLQoUMB3LiMkpKSgueee67Vc8pkMshksnbd/4ULF7B3717k5eWhqKioI6ETQgghxEZ0KPmYNGkS3nzzTQQGBmLAgAE4ffo01qxZgyeffBIAIBAIsHDhQrzxxhsIDQ1FSEgIli9fDpVKhSlTpnQ52OzsbHz44YeoqKjo8rkIIYQQwo8OJR/r16/H8uXL8fzzz6OsrAwqlQrPPvssXn31VdMxf//731FXV4c5c+aguroao0ePxn/+8x/I5fIuB+vv748HHngARUVFOH78OKqqqrp8TkJI98BxHIqKiuDs7AyBQMB3OIT0OIwx1NTUQKVStbhKcqsO1fmwhqY6H63VF9Dr9aivr8fFixcxd+5cnDlzhqcoCekZ7KnOR0FBwW0HrBNCrCM/Px+9evW67TEd6vngm0QigVKphJeXF/r16weO45Cfn091PwghcHZ2BnDjg89eEiYClJeXo6ysDC+88AJSU1PNcs7p06dj8+bN1ANmZRqNBgEBAab34u3YVfLRxN/fH6+//jrKy8vxxhtv4KeffuI7JEIIz5r+0Li4uFDyYUd+/fVX/Pe//22zFlRnSKVSuLi4UPLBk/Y873aZfMjlcvTt2xfe3t7w9/eHm5sbGhsb0dDQwHdo5CYCgQAODg6QSqVoaGig9X0IIS0UFBQgLS3NVGCS9AwdqvNhaxQKBZ566ils2rQJU6dOveMAF2JdDg4OmDNnDjZt2oTJkyfTtxBCSAt5eXlISUmxSPJhY0MayU3s+q+1RCJBdHQ0pk2bhsGDB0MkEtEfOBsilUoRExODhx56CAMHDqT/H0KIVej1etTU1ECv1/MdCmmDXScfN4u
      "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):\n",
    "    for i, (m, angle) in enumerate(zip(cropped_maps, angles)):\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",
    "        p = imgmap.to_map_points(np.array([input_points[i]]))\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(p[0][0], p[0][1],d[0], d[1], color='r')\n",
    "        ax2.scatter(p[0][0], p[0][1], marker='x')\n",
    "\n",
    "        ax2.invert_yaxis()\n",
    "        plt.show()\n",
    "print_maps(cropped_maps, input_angles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test with only rotation, from a fixed point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "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": "iVBORw0KGgoAAAANSUhEUgAAAh8AAAENCAYAAACvqwfcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAABZg0lEQVR4nO3deXhT1dY/8G/mpk2bDtCmLekAFEopLaVlKDNSRQQFRQVE34oIFwUB61XECygIolevclWQ4VUQBRn0MopMZfohZWihzJQCpQMl6ZikY5Im+/cHt3mtDHZIcpJ0fZ7nPA85OcM6IcPqPnuvzWOMMRBCCCGE2Amf6wAIIYQQ0rpQ8kEIIYQQu6LkgxBCCCF2RckHIYQQQuyKkg9CCCGE2BUlH4QQQgixK0o+CCGEEGJXlHwQQgghxK6EXAfwZ2azGYWFhfD09ASPx+M6HEJaJcYYKioqEBQUBD6f/kYhhFiXwyUfhYWFUCqVXIdBCAGQn5+Pdu3acR0GIcTFOFzy4enpadXjicViTJgwAf3790fHjh3RrVs3CASCB25/8OBB/PTTT1CpVDh9+jRqamqsGg8hzsTan0dCCAEcMPmw9q0WsViM/v3745VXXrGsY4zhQVPa3LlzB9u3b4der7dqHIQ4I7r1SQixBYdLPqzFx8cHo0aNQlhYGGJjYxs8d+vWLezcuRMVFRX37Hfq1CmYTCZ7hUkIIYS0Oi6bfPj6+mLy5Mno3bv3PX+93bx5E5999hkKCwvv2c9sNj+wVYQQQgghLedyyYe/vz+6d++OsLAw+Pn5Wfp3MMaQk5ODy5cv4+zZs6iqqqIWjlZMqVQiOjoaQuHdj4Ber0dmZiaKioo4jowQQlyfyyUfMTEx+OKLL6BQKO7pLLd//34sXLgQVVVV973lQlqPAQMG4KOPPoK7uzsAoLi4GDNnzsSBAwc4jowQQlyfyyQfvr6+aNOmDdq3bw9/f3/4+voCuHsbRa1WQ6vV4tatWyguLobRaOQ4WsIVf39/+Pj4ICwsDG3btrUkHzweD+3bt0enTp1QUlKCsrIyjiMlhBDX5TLJx4gRI/D666/D19cXcrncsl6v1+N///d/sWPHDqjVatTV1XEYJeGSUCjEhAkTMH78eLRp0wYSicTynFwux1tvvYWJEydi+fLl+OGHHziMlBBCXJvTJx8SiQQikQihoaFISEiw3MM3m82ora1FRUUFsrOzkZ6eznGkhCs8Hg9ubm5wc3NDhw4dkJCQcE8nZJFIhE6dOqGurg6hoaGQyWQwGo005JoQQmzAqZMPqVSK5ORkJCYmomvXrg3KQBcXF2PFihXIysrCqVOnOIyScM3b2xuTJ09Gt27d0KNHj4duy+fzMXr0aERERCAtLQ3ff/89FZojhBArc+rkQyQSoX///pgwYYJlXf0wWZ1Oh99++w0nT57kKjziINzd3fHoo48iKSnpL7fl8/mIj49HfHw8BAIBNmzYQMkHIYRYmVMmH76+vnjiiScQEhKCLl26NHguJycHe/fuRV5eHu7cucNRhMQRBAcHY/jw4VAqlQgNDW3y/l26dMH06dORl5eH3bt3UydUQgixEqdMPgICAjB9+nT06NHjnnlasrKysHjxYqjVaqrj0cqFh4fjnXfeQVhY2EPn83mQ7t27o1u3bjhz5gwyMjIo+SCEECtxquTD398f0dHR6NChA3x9fSESiQD8XwGx7OxsnD59GlVVVTSqpRVTKpWIjIxEbGwsPD09Le+TpuLz+eDz+fD19UX//v0RGBiIixcvUiEyQghpIadKPnr06IHPPvsM/v7+8Pb2bvDcb7/9ho8//hhVVVXQ6XTcBEgcwuDBg7FgwQJ4eXk1GHbdXGFhYVi8eDGKiorw97//HXv27LFClIQQ0no5RfLh7e0NHx8fhIaGIigoCB4eHlCr1Q2GQdb38aBbLa0Tj8eDn58fvLy8LO+TP9bxAO62kJWWlkKr1cLLywt+fn4NRkg9iEgkQtu2bSEUChEaGorw8HCUl5dDo9HY6GoIIcS1OXzywePx8PTTT+OVV15BmzZtIJPJUFBQgIULFyIrK8uyXWFhISUerZhIJMLLL7+Mp59+GgEBAfe91VJXV4f169dj8+bNGDFiBN58801IpdJGn0Mmk2HWrFl48cUX8d1332Ht2rU0CSEhhDSDQycfYrEYIpEI4eHhSExMBGMMRqMRZWVlyMzMRGZmJtchEo7xeDyIxWK4u7ujU6dOSExMvKeAWD3GGG7fvo2zZ88iJiYGZrO5SecSiUSIjIyEyWTCoUOH4O7uDqPRCIPBYI1LIYSQVsNhkw+pVIqXXnoJCQkJiIuLA5/PR2ZmJtatW4eCggLk5+dzHSJxAL6+vpg4cSK6dOmCPn36PDDxAACBQICnn34aERER6NSpE8RicbPOyefzMXz4cCgUCqSnp+PHH39EdXV1cy+BEEJaHYdNPiQSCZKSkvDcc89ZmrZv3bqFdevW0ZBHYuHp6Yknn3wSAwcO/MttBQIBEhMTkZiY2GD9H2+dPCx5+eM2CQkJSEhIgLe3N7Zs2ULJByGENIHDJh/Jycno2LEjGGM4ffo0Tp06hXPnzqG2tpbr0IgDaNeuHR599FGEhIQgKCio2cdRqVTYt28fjEYjhg4dirCwsCbt37FjR0yePBn5+fnYt28fSktLmx0LIYS0Fg6bfPzjH/+Ar68vGGPYv38/Fi9eDKPRSPU7CAAgIiICc+fORXBwcLPreAB3R0l98sknqKioQFBQUJOTj5iYGERFReHSpUu4ePEiJR+EENIIDpt88Pl8XLlyBWq1GtevX0dtbS2NLCBo164dOnTogLi4OHh6et4znLapZDIZ4uLiUFNTAx8fn4duazQacfXqVZSUlCA8PByhoaEQCAQQCATw9vZGr169IJfLce3aNSpERgghD8FjDvaLrtPpIJfLkZubiyVLluDXX3+FTqeDVqvlOjTiAF555RXMmTMHnp6e8PPzg1DYsvxZr9ejtLQUZrMZfn5+Dx16W15ejnfeeQcHDhzAzJkzMWPGDEudEIPBgNLSUpSWluK9997Dzp07WxSXo6iviUIIIdbksC0fBQUFyMvLo1EtBDweDz4+PpDJZAgJCUFISEizR6r8mUQiaVGfkXpisRiBgYHw8PBASEgIlEolJc2EEPIADtvy0adPH9y4cQPFxcVch0Q45ubmhjfeeAPDhw+33HZpTGVSa7vfbZc/j46pq6tDVlYW1Go11q9fj7Vr1za5nogjoZYPQogtOGzLx4kTJ7gOgTgAkUgEqVSKqKgoDBkyhPNYunXr9tBthEIhunbtii5duuDUqVOQSCTUUZoQQv7EYZMPQtq0aYPk5GRERESgV69eXIfTJDweD0lJSfDy8sK5c+ewYcMGVFZWch0WIYQ4BEo+iMPy9vbGs88+i969e3MdSpPxeDzEx8cjPj4eO3fuxNatWyn5IISQ/6LkgzgcpVKJgQMHIjQ0FP7+/o2qOuqI6uMODQ3FSy+9hPz8fBw6dAglJSUcR0YIIdyi5IM4nKioKHz44YdQKBRWG9XCpejoaCxatAhZWVm4ceMGJR+EkFaPkg/iMIKDgxEaGopu3bpBLpffU3ODMYbCwkLk5ubCy8sLERERLS4yZg8CgQBSqRQ+Pj6Ii4uDWCymkVyEkFbN/uMVCXmAESNGYM2aNUhJSXng8M59+/bhlVdewSeffILy8nI7R9gygYGB+OCDD7Bq1Sr069eP63AIIYQz1PJBOMXj8SytHEqlEu3bt39o1dK6ujrU1NRAr9c7Xbl9sViMdu3awdvbG0qlEoGBgaisrERFRQXXoRFCiF05bJEx0jq4u7vjjTfewCOPPIKwsDB07NjxgQXEGGPIy8vDtWvX4OPjg+joaLi5udk54parq6vDlStXUFhYiF9++QXfffcdTCYT12HdFxUZI4TYArV8EM4IhUJIpVLExsbiscce+8vteTweQkNDERoaaofobEcoFKJbt26Ijo7G5cuXIRaLYTAYHDYBIYQQa6Pkg3DC398fL7zwAtq3b4/u3btzHQ5nBgwYgMWLF+Py5cvYtGkT3YIhhLQKlHw
      "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([[15,7]]* 8)\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)"
   ]
  },
  {
   "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
}