Custom_SLAM_Landmark_Detection_Tracking.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Custom SLAM Implementation\n",
    "\n",
    "---\n",
    "\n",
    "## Project Overview\n",
    "\n",
    "In this project, we'll implement SLAM for robot that moves and senses in a 2 dimensional, grid world!\n",
    "\n",
    "SLAM gives us a way to both localize a robot and build up a map of its environment as a robot moves and senses in real-time. The core is the function, `slam` takes in six parameters as input and returns the vector `mu`. `mu` contains the (x,y) coordinate locations of the robot as it moves, and the positions of landmarks that it senses in the world\n",
    "\n",
    "You can implement helper functions as you see fit, but your function must return `mu`. The vector, `mu`, should have (x, y) coordinates interlaced, for example, if there were 2 poses and 2 landmarks, `mu` will look like the following, where `P` is the robot position and `L` the landmark position:\n",
    "```\n",
    "mu =  matrix([[Px0],\n",
    "              [Py0],\n",
    "              [Px1],\n",
    "              [Py1],\n",
    "              [Lx0],\n",
    "              [Ly0],\n",
    "              [Lx1],\n",
    "              [Ly1]])\n",
    "```\n",
    "\n",
    "You can see that `mu` holds the poses first `(x0, y0), (x1, y1), ...,` then the landmark locations at the end of the matrix; we consider a `nx1` matrix to be a vector.\n",
    "\n",
    "## To generate an environment\n",
    "\n",
    "In a real SLAM problem, you may be given a map that contains information about landmark locations.The data is collected as an instantiated robot moves and senses in a world. The SLAM function will take in this data as input. The data can come from the point cloud senbsed by LIDAR.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create the world\n",
    "\n",
    "Use the code below to generate a world of a specified size with randomly generated landmark locations. You can change these parameters and see how your implementation of SLAM responds! \n",
    "\n",
    "`data` holds the sensors measurements and motion of your robot over time. It stores the measurements as `data[i][0]` and the motion as `data[i][1]`.\n",
    "\n",
    "#### Helper functions\n",
    "\n",
    "You can see the robot move/sense cycle in the `robot` class\n",
    "\n",
    "The `helpers.py` file, contains the data generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 285,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " \n",
      "Landmarks:  [[46, 39], [47, 48], [34, 30], [34, 44], [80, 22]]\n",
      "Robot: [x=75.77127 y=41.76748]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from helpers import make_data\n",
    "\n",
    "# your implementation of slam should work with the following inputs\n",
    "# feel free to change these input values and see how it responds!\n",
    "\n",
    "# world parameters\n",
    "num_landmarks      = 5        # number of landmarks\n",
    "N                  = 20       # time steps\n",
    "world_size         = 100.0    # size of world (square)\n",
    "\n",
    "# robot parameters\n",
    "measurement_range  = 50.0     # range at which we can sense landmarks\n",
    "motion_noise       = 2.0      # noise in robot motion\n",
    "measurement_noise  = 2.0      # noise in the measurements\n",
    "distance           = 20.0     # distance by which robot (intends to) move each iteratation \n",
    "\n",
    "\n",
    "# make_data instantiates a robot, AND generates random landmarks for a given world size and number of landmarks\n",
    "data = make_data(N, num_landmarks, world_size, measurement_range, motion_noise, measurement_noise, distance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A note on `make_data`\n",
    "\n",
    "The function above, `make_data`, takes in so many world and robot motion/sensor parameters because it is responsible for:\n",
    "1. Instantiating a robot (using the robot class)\n",
    "2. Creating a grid world with landmarks in it\n",
    "\n",
    "**This function also prints out the true location of landmarks and the *final* robot location, which you should refer back to when you test your implementation of SLAM.**\n",
    "\n",
    "The `data` this returns is an array that holds information about **robot sensor measurements** and **robot motion** `(dx, dy)` that is collected over a number of time steps, `N`. You will have to use *only* these readings about motion and measurements to track a robot over time and find the determine the location of the landmarks using SLAM. We only print out the true landmark locations for comparison, later.\n",
    "\n",
    "\n",
    "In `data` the measurement and motion data can be accessed from the first and second index in the columns of the data array. See the following code for an example, where `i` is the time step:\n",
    "```\n",
    "measurement = data[i][0]\n",
    "motion = data[i][1]\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 286,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Example measurements: \n",
      " [[0, -2.5999772475370366, -11.341737096922019], [1, -2.5492738206336245, -3.4680929858835317], [2, -17.998764419531803, -18.422814837895277], [3, -16.03548246418916, -4.153298799924289], [4, 29.037065744381053, -26.259416576279754]]\n",
      "\n",
      "\n",
      "Example motion: \n",
      " [2.531159403366524, 19.839184259307366]\n"
     ]
    }
   ],
   "source": [
    "# print out some stats about the data\n",
    "time_step = 0\n",
    "\n",
    "print('Example measurements: \\n', data[time_step][0])\n",
    "print('\\n')\n",
    "print('Example motion: \\n', data[time_step][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try changing the value of `time_step`, you should see that the list of measurements varies based on what in the world the robot sees after it moves. As you know from the first notebook, the robot can only sense so far and with a certain amount of accuracy in the measure of distance between its location and the location of landmarks. The motion of the robot always is a vector with two values: one for x and one for y displacement. This structure will be useful to keep in mind as you traverse this data in your implementation of slam."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize Constraints\n",
    "\n",
    "One of the most challenging tasks here will be to create and modify the constraint matrix and vector: omega and xi. In the second notebook, you saw an example of how omega and xi could hold all the values the define the relationships between robot poses `xi` and landmark positions `Li` in a 1D world, as seen below, where omega is the blue matrix and xi is the pink vector.\n",
    "\n",
    "<img src='images/motion_constraint.png' width=50% height=50% />\n",
    "\n",
    "\n",
    "In *this* project, you are tasked with implementing constraints for a 2D world. We are referring to robot poses as `Px, Py` and landmark positions as `Lx, Ly`, and one way to approach this challenge is to add *both* x and y locations in the constraint matrices.\n",
    "\n",
    "<img src='images/constraints2D.png' width=50% height=50% />\n",
    "\n",
    "You may also choose to create two of each omega and xi (one for x and one for y positions)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### : Function that initializes omega and xi\n",
    "\n",
    "Complete the function `initialize_constraints` so that it returns `omega` and `xi` constraints for the starting position of the robot. Any values that we do not yet know should be initialized with the value `0`. You may assume that our robot starts out in exactly the middle of the world with 100% confidence (no motion or measurement noise at this point). The inputs `N` time steps, `num_landmarks`, and `world_size` should give you all the information you need to construct intial constraints of the correct size and starting values.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_constraints(N, num_landmarks, world_size):\n",
    "    ''' This function takes in a number of time steps N, number of landmarks, and a world_size,\n",
    "        and returns initialized constraint matrices, omega and xi.'''\n",
    "    \n",
    "    ## Recommended: Define and store the size (rows/cols) of the constraint matrix in a variable\n",
    "    dim = N + num_landmarks\n",
    "    \n",
    "    ## TODO: Define the constraint matrix, Omega, with two initial \"strength\" values\n",
    "    ## for the initial x, y location of our robot\n",
    "    \n",
    "    omega_1 = np.zeros((dim,dim))\n",
    "    xi_1 = np.zeros((dim))\n",
    "    \n",
    "    # setting initial position\n",
    "    omega_1[0][0] = 1\n",
    "    xi_1[0] = world_size/2\n",
    "    \n",
    "    omega_2 = np.zeros((dim,dim))\n",
    "    xi_2 = np.zeros((dim))\n",
    "    \n",
    "    # setting initial position\n",
    "    omega_2[0][0] = 1\n",
    "    xi_2[0] = world_size/2\n",
    "    \n",
    "    return omega_1, xi_1, omega_2, xi_2\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "Below, you'll find some test code that allows you to visualize the results of your function `initialize_constraints`. We are using the [seaborn](https://seaborn.pydata.org/) library for visualization.\n",
    "\n",
    "**Please change the test values of N, landmarks, and world_size and see the results**. Be careful not to use these values as input into your final smal function.\n",
    "\n",
    "This code assumes that you have created one of each constraint: `omega` and `xi`, but you can change and add to this code, accordingly. The constraints should vary in size with the number of time steps and landmarks as these values affect the number of poses a robot will take `(Px0,Py0,...Pxn,Pyn)` and landmark locations `(Lx0,Ly0,...Lxn,Lyn)` whose relationships should be tracked in the constraint matrices. Recall that `omega` holds the weights of each variable and `xi` holds the value of the sum of these variables, as seen in Notebook 2. You'll need the `world_size` to determine the starting pose of the robot in the world and fill in the initial values for `xi`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import data viz resources\n",
    "import matplotlib.pyplot as plt\n",
    "from pandas import DataFrame\n",
    "import seaborn as sns\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define a small N and world_size (small for ease of visualization)\n",
    "N_test = 5\n",
    "num_landmarks_test = 2\n",
    "small_world = 10\n",
    "\n",
    "# initialize the constraints\n",
    "initial_omega_1, initial_xi_1, initial_omega_2, initial_xi_2 = initialize_constraints(N_test, num_landmarks_test, small_world)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f75cbd20080>"
      ]
     },
     "execution_count": 290,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f75cbef0d30>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# define figure size\n",
    "plt.rcParams[\"figure.figsize\"] = (10,7)\n",
    "\n",
    "# display omega\n",
    "sns.heatmap(DataFrame(initial_omega_1), cmap='Blues', annot=True, linewidths=.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f75cbcd24e0>"
      ]
     },
     "execution_count": 291,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f75cc5aeb70>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# define  figure size\n",
    "plt.rcParams[\"figure.figsize\"] = (1,7)\n",
    "\n",
    "# display xi\n",
    "sns.heatmap(DataFrame(initial_xi_1), cmap='Oranges', annot=True, linewidths=.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## SLAM inputs \n",
    "\n",
    "In addition to `data`, your slam function will also take in:\n",
    "* N -   The number of time steps that a robot will be moving and sensing\n",
    "* num_landmarks - The number of landmarks in the world\n",
    "* world_size - The size (w/h) of your world\n",
    "* motion_noise - The noise associated with motion; the update confidence for motion should be `1.0/motion_noise`\n",
    "* measurement_noise - The noise associated with measurement/sensing; the update weight for measurement should be `1.0/measurement_noise`\n",
    "\n",
    "#### A note on noise\n",
    "\n",
    "Recall that `omega` holds the relative \"strengths\" or weights for each position variable, and you can update these weights by accessing the correct index in omega `omega[row][col]` and *adding/subtracting* `1.0/noise` where `noise` is measurement or motion noise. `Xi` holds actual position values, and so to update `xi` you'll do a similar addition process only using the actual value of a motion or measurement. So for a vector index `xi[row][0]` you will end up adding/subtracting one measurement or motion divided by their respective `noise`.\n",
    "\n",
    "## Graph SLAM Implementation\n",
    "\n",
    "With a 2D omega and xi structure as shown above (in earlier cells), you'll have to be mindful about how you update the values in these constraint matrices to account for motion and measurement constraints in the x and y directions. Recall that the solution to these matrices (which holds all values for robot poses `P` and landmark locations `L`) is the vector, `mu`, which can be computed at the end of the construction of omega and xi as the inverse of omega times xi: $\\mu = \\Omega^{-1}\\xi$\n",
    "\n",
    "**You may also choose to return the values of `omega` and `xi` if you want to visualize their final state!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 3 6]\n",
      "[[2 2]\n",
      " [5 4]\n",
      " [5 9]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "  \n",
    "a = np.array([[1 ,2 ],[3 ,4 ],[5 ,6 ]]) \n",
    "print(a[[0 ,1 ,2 ],[0 ,0 ,1]]) \n",
    "\n",
    "a[[0 ,1 ,2 ],[0 ,0 ,1]] = a[[0 ,1 ,2 ],[0 ,0 ,1]] + [1, 2, 3]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 293,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Optimized implementation of Graph SLAM. Minimum Lines.\n",
    "\n",
    "## slam takes in 6 arguments and returns mu, \n",
    "## mu is the entire path traversed by a robot (all x,y poses) *and* all landmarks locations\n",
    "def slam(data, N, num_landmarks, world_size, motion_noise, measurement_noise):\n",
    "    \n",
    "    coefficients = [1, -1, -1, 1]\n",
    "    \n",
    "    # initialize the constraints\n",
    "    initial_omega_1, initial_xi_1, initial_omega_2, initial_xi_2 = initialize_constraints(N, num_landmarks, world_size)\n",
    "    \n",
    "    ## get all the motion and measurement data as you iterate\n",
    "    for i in range(len(data)):\n",
    "        \n",
    "        landmarks = data[i][0]  # measurement\n",
    "        motion = data[i][1]  # motion\n",
    "        \n",
    "        # setting measurement constraints\n",
    "        for landmark in landmarks:\n",
    "            \n",
    "            # calculate indices in the same order as coefficients (to meaningfully add)\n",
    "            index1 = [i, i, N+landmark[0], N+landmark[0]]\n",
    "            index2 = [i, N+landmark[0], i, N+landmark[0]]\n",
    "            \n",
    "            # dx update\n",
    "            initial_omega_1[index1, index2] = initial_omega_1[index1, index2] + np.divide(coefficients, measurement_noise)\n",
    "            initial_xi_1[[i, N+landmark[0]]] = initial_xi_1[[i, N+landmark[0]]] + np.divide([-landmark[1], landmark[1]], measurement_noise)\n",
    "            \n",
    "            # dy update\n",
    "            initial_omega_2[index1, index2] = initial_omega_2[index1, index2] + np.divide(coefficients, measurement_noise)\n",
    "            initial_xi_2[[i, N+landmark[0]]] = initial_xi_2[[i, N+landmark[0]]] + np.divide([-landmark[2], landmark[2]], measurement_noise)\n",
    "        \n",
    "        index1 = [i, i, i+1, i+1]\n",
    "        index2 = [i, i+1, i, i+1]\n",
    "        \n",
    "        # dx update\n",
    "        initial_omega_1[index1, index2] = initial_omega_1[index1, index2] + np.divide(coefficients, motion_noise)\n",
    "        initial_xi_1[[i, i+1]] = initial_xi_1[[i, i+1]] + np.divide([-motion[0], motion[0]], motion_noise)\n",
    "        \n",
    "        # dy update\n",
    "        initial_omega_2[index1, index2] = initial_omega_2[index1, index2] + np.divide(coefficients, motion_noise)\n",
    "        initial_xi_2[[i, i+1]] = initial_xi_2[[i, i+1]] + np.divide([-motion[1], motion[1]], motion_noise)\n",
    "        \n",
    "    ## TODO: update the constraint matrix/vector to account for all measurements, measurement noise,\n",
    "    ## motion and motion noise. Compute best estimate of poses and landmark positions using the formula, omega_inverse * Xi\n",
    "    mu_1 = np.linalg.inv(np.matrix(initial_omega_1)) * np.expand_dims(initial_xi_1, 0).transpose()\n",
    "    mu_2 = np.linalg.inv(np.matrix(initial_omega_2)) * np.expand_dims(initial_xi_2, 0).transpose()\n",
    "    \n",
    "    mu = []\n",
    "    for i in range(len(mu_1)):\n",
    "        mu.extend((mu_1[i], mu_2[i]))\n",
    "    \n",
    "    return mu # return 2d `mu`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Helper functions\n",
    "\n",
    "To check that your implementation of SLAM works for various inputs, we have provided two helper functions that will help display the estimated pose and landmark locations that your function has produced. First, given a result `mu` and number of time steps, `N`, we define a function that extracts the poses and landmarks locations and returns those as their own, separate lists. \n",
    "\n",
    "Then, we define a function that nicely print out these lists; both of these we will call, in the next step.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 294,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a helper function that creates a list of poses and of landmarks for ease of printing\n",
    "# this only works for the suggested constraint architecture of interlaced x,y poses\n",
    "def get_poses_landmarks(mu, N):\n",
    "    # create a list of poses\n",
    "    poses = []\n",
    "    for i in range(N):\n",
    "        poses.append((mu[2*i].item(), mu[2*i+1].item()))\n",
    "\n",
    "    # create a list of landmarks\n",
    "    landmarks = []\n",
    "    for i in range(num_landmarks):\n",
    "        landmarks.append((mu[2*(N+i)].item(), mu[2*(N+i)+1].item()))\n",
    "\n",
    "    # return completed lists\n",
    "    return poses, landmarks\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_all(poses, landmarks):\n",
    "    print('\\n')\n",
    "    print('Estimated Poses:')\n",
    "    for i in range(len(poses)):\n",
    "        print('['+', '.join('%.3f'%p for p in poses[i])+']')\n",
    "    print('\\n')\n",
    "    print('Estimated Landmarks:')\n",
    "    for i in range(len(landmarks)):\n",
    "        print('['+', '.join('%.3f'%l for l in landmarks[i])+']')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run SLAM\n",
    "\n",
    "Once you've completed your implementation of `slam`, see what `mu` it returns for different world sizes and different landmarks!\n",
    "\n",
    "### What to Expect\n",
    "\n",
    "The `data` that is generated is random, but you did specify the number, `N`, or time steps that the robot was expected to move and the `num_landmarks` in the world (which your implementation of `slam` should see and estimate a position for. Your robot should also start with an estimated pose in the very center of your square world, whose size is defined by `world_size`.\n",
    "\n",
    "With these values in mind, you should expect to see a result that displays two lists:\n",
    "1. **Estimated poses**, a list of (x, y) pairs that is exactly `N` in length since this is how many motions your robot has taken. The very first pose should be the center of your world, i.e. `[50.000, 50.000]` for a world that is 100.0 in square size.\n",
    "2. **Estimated landmarks**, a list of landmark positions (x, y) that is exactly `num_landmarks` in length. \n",
    "\n",
    "#### Landmark Locations\n",
    "\n",
    "If you refer back to the printout of *exact* landmark locations when this data was created, you should see values that are very similar to those coordinates, but not quite (since `slam` must account for noise in motion and measurement)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 296,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Estimated Poses:\n",
      "[50.000, 50.000]\n",
      "[52.480, 70.055]\n",
      "[56.108, 90.923]\n",
      "[35.630, 94.832]\n",
      "[16.401, 99.498]\n",
      "[35.537, 97.548]\n",
      "[54.325, 96.304]\n",
      "[73.259, 93.547]\n",
      "[93.515, 93.291]\n",
      "[82.962, 76.024]\n",
      "[72.818, 59.175]\n",
      "[62.115, 41.686]\n",
      "[50.447, 23.174]\n",
      "[40.059, 5.881]\n",
      "[21.148, 5.680]\n",
      "[1.185, 6.857]\n",
      "[20.096, 14.759]\n",
      "[37.264, 23.434]\n",
      "[55.876, 33.656]\n",
      "[73.653, 42.820]\n",
      "\n",
      "\n",
      "Estimated Landmarks:\n",
      "[45.901, 39.276]\n",
      "[46.580, 47.959]\n",
      "[33.748, 30.970]\n",
      "[33.779, 44.856]\n",
      "[79.896, 23.079]\n"
     ]
    }
   ],
   "source": [
    "# call your implementation of slam, passing in the necessary parameters\n",
    "mu = slam(data, N, num_landmarks, world_size, motion_noise, measurement_noise)\n",
    "\n",
    "\n",
    "# print(mu)\n",
    "# print out the resulting landmarks and poses\n",
    "if(mu is not None):\n",
    "    # get the lists of poses and landmarks\n",
    "    # and print them out\n",
    "    poses, landmarks = get_poses_landmarks(mu, N)\n",
    "    print_all(poses, landmarks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualize the constructed world\n",
    "\n",
    "Finally, using the `display_world` code from the `helpers.py` file (which was also used in the first notebook), we can actually visualize what you have coded with `slam`: the final position of the robot and the positon of landmarks, created from only motion and measurement data!\n",
    "\n",
    "**Note that these should be very similar to the printed *true* landmark locations and final pose from our call to `make_data` early in this notebook.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 297,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Last pose:  (73.65291181422072, 42.82015482215206)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f75cbbad048>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# import the helper function\n",
    "from helpers import display_world\n",
    "\n",
    "# Display the final world!\n",
    "\n",
    "# define figure size\n",
    "plt.rcParams[\"figure.figsize\"] = (20,20)\n",
    "\n",
    "# check if poses has been created\n",
    "if 'poses' in locals():\n",
    "    # print out the last pose\n",
    "    print('Last pose: ', poses[-1])\n",
    "    # display the last position of the robot *and* the landmark positions\n",
    "    display_world(int(world_size), poses[-1], landmarks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test Cases\n",
    "\n",
    "The output should be **close-to or exactly** identical to the given results. If there are minor discrepancies it could be a matter of floating point accuracy or in the calculation of the inverse matrix.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 298,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Estimated Poses:\n",
      "[50.000, 50.000]\n",
      "[37.973, 33.652]\n",
      "[26.185, 18.155]\n",
      "[13.745, 2.116]\n",
      "[28.097, 16.783]\n",
      "[42.384, 30.902]\n",
      "[55.831, 44.497]\n",
      "[70.857, 59.699]\n",
      "[85.697, 75.543]\n",
      "[74.011, 92.434]\n",
      "[53.544, 96.454]\n",
      "[34.525, 100.080]\n",
      "[48.623, 83.953]\n",
      "[60.197, 68.107]\n",
      "[73.778, 52.935]\n",
      "[87.132, 38.538]\n",
      "[80.303, 20.508]\n",
      "[72.798, 2.945]\n",
      "[55.245, 13.255]\n",
      "[37.416, 22.317]\n",
      "\n",
      "\n",
      "Estimated Landmarks:\n",
      "[82.956, 13.539]\n",
      "[70.495, 74.141]\n",
      "[36.740, 61.281]\n",
      "[18.698, 66.060]\n",
      "[20.635, 16.875]\n"
     ]
    }
   ],
   "source": [
    "# Here is the data and estimated outputs for test case 1\n",
    "\n",
    "test_data1 = [[[[1, 19.457599255548065, 23.8387362100849], [2, -13.195807561967236, 11.708840328458608], [3, -30.0954905279171, 15.387879242505843]], [-12.2607279422326, -15.801093326936487]], [[[2, -0.4659930049620491, 28.088559771215664], [4, -17.866382374890936, -16.384904503932]], [-12.2607279422326, -15.801093326936487]], [[[4, -6.202512900833806, -1.823403210274639]], [-12.2607279422326, -15.801093326936487]], [[[4, 7.412136480918645, 15.388585962142429]], [14.008259661173426, 14.274756084260822]], [[[4, -7.526138813444998, -0.4563942429717849]], [14.008259661173426, 14.274756084260822]], [[[2, -6.299793150150058, 29.047830407717623], [4, -21.93551130411791, -13.21956810989039]], [14.008259661173426, 14.274756084260822]], [[[1, 15.796300959032276, 30.65769689694247], [2, -18.64370821983482, 17.380022987031367]], [14.008259661173426, 14.274756084260822]], [[[1, 0.40311325410337906, 14.169429532679855], [2, -35.069349468466235, 2.4945558982439957]], [14.008259661173426, 14.274756084260822]], [[[1, -16.71340983241936, -2.777000269543834]], [-11.006096015782283, 16.699276945166858]], [[[1, -3.611096830835776, -17.954019226763958]], [-19.693482634035977, 3.488085684573048]], [[[1, 18.398273354362416, -22.705102332550947]], [-19.693482634035977, 3.488085684573048]], [[[2, 2.789312482883833, -39.73720193121324]], [12.849049222879723, -15.326510824972983]], [[[1, 21.26897046581808, -10.121029799040915], [2, -11.917698965880655, -23.17711662602097], [3, -31.81167947898398, -16.7985673023331]], [12.849049222879723, -15.326510824972983]], [[[1, 10.48157743234859, 5.692957082575485], [2, -22.31488473554935, -5.389184118551409], [3, -40.81803984305378, -2.4703329790238118]], [12.849049222879723, -15.326510824972983]], [[[0, 10.591050242096598, -39.2051798967113], [1, -3.5675572049297553, 22.849456408289125], [2, -38.39251065320351, 7.288990306029511]], [12.849049222879723, -15.326510824972983]], [[[0, -3.6225556479370766, -25.58006865235512]], [-7.8874682868419965, -18.379005523261092]], [[[0, 1.9784503557879374, -6.5025974151499]], [-7.8874682868419965, -18.379005523261092]], [[[0, 10.050665232782423, 11.026385307998742]], [-17.82919359778298, 9.062000642947142]], [[[0, 26.526838150174818, -0.22563393232425621], [4, -33.70303936886652, 2.880339841013677]], [-17.82919359778298, 9.062000642947142]]]\n",
    "\n",
    "##  Test Case 1\n",
    "##\n",
    "# Estimated Pose(s):\n",
    "#     [50.000, 50.000]\n",
    "#     [37.858, 33.921]\n",
    "#     [25.905, 18.268]\n",
    "#     [13.524, 2.224]\n",
    "#     [27.912, 16.886]\n",
    "#     [42.250, 30.994]\n",
    "#     [55.992, 44.886]\n",
    "#     [70.749, 59.867]\n",
    "#     [85.371, 75.230]\n",
    "#     [73.831, 92.354]\n",
    "#     [53.406, 96.465]\n",
    "#     [34.370, 100.134]\n",
    "#     [48.346, 83.952]\n",
    "#     [60.494, 68.338]\n",
    "#     [73.648, 53.082]\n",
    "#     [86.733, 38.197]\n",
    "#     [79.983, 20.324]\n",
    "#     [72.515, 2.837]\n",
    "#     [54.993, 13.221]\n",
    "#     [37.164, 22.283]\n",
    "\n",
    "\n",
    "# Estimated Landmarks:\n",
    "#     [82.679, 13.435]\n",
    "#     [70.417, 74.203]\n",
    "#     [36.688, 61.431]\n",
    "#     [18.705, 66.136]\n",
    "#     [20.437, 16.983]\n",
    "\n",
    "\n",
    "### Uncomment the following three lines for test case 1 and compare the output to the values above ###\n",
    "\n",
    "mu_1 = slam(test_data1, 20, 5, 100.0, 2.0, 2.0)\n",
    "poses, landmarks = get_poses_landmarks(mu_1, 20)\n",
    "print_all(poses, landmarks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 299,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Estimated Poses:\n",
      "[50.000, 50.000]\n",
      "[69.181, 45.665]\n",
      "[87.743, 39.703]\n",
      "[76.270, 56.311]\n",
      "[64.317, 72.176]\n",
      "[52.257, 88.154]\n",
      "[44.059, 69.401]\n",
      "[37.002, 49.918]\n",
      "[30.924, 30.955]\n",
      "[23.508, 11.419]\n",
      "[34.180, 27.133]\n",
      "[44.155, 43.846]\n",
      "[54.806, 60.920]\n",
      "[65.698, 78.546]\n",
      "[77.468, 95.626]\n",
      "[96.802, 98.821]\n",
      "[75.957, 99.971]\n",
      "[70.200, 81.181]\n",
      "[64.054, 61.723]\n",
      "[58.107, 42.628]\n",
      "\n",
      "\n",
      "Estimated Landmarks:\n",
      "[76.779, 42.887]\n",
      "[85.065, 77.438]\n",
      "[13.548, 95.652]\n",
      "[59.449, 39.595]\n",
      "[69.263, 94.240]\n"
     ]
    }
   ],
   "source": [
    "# Here is the data and estimated outputs for test case 2\n",
    "\n",
    "test_data2 = [[[[0, 26.543274387283322, -6.262538160312672], [3, 9.937396825799755, -9.128540360867689]], [18.92765331253674, -6.460955043986683]], [[[0, 7.706544739722961, -3.758467215445748], [1, 17.03954411948937, 31.705489938553438], [3, -11.61731288777497, -6.64964096716416]], [18.92765331253674, -6.460955043986683]], [[[0, -12.35130507136378, 2.585119104239249], [1, -2.563534536165313, 38.22159657838369], [3, -26.961236804740935, -0.4802312626141525]], [-11.167066095509824, 16.592065417497455]], [[[0, 1.4138633151721272, -13.912454837810632], [1, 8.087721200818589, 20.51845934354381], [3, -17.091723454402302, -16.521500551709707], [4, -7.414211721400232, 38.09191602674439]], [-11.167066095509824, 16.592065417497455]], [[[0, 12.886743222179561, -28.703968411636318], [1, 21.660953298391387, 3.4912891084614914], [3, -6.401401414569506, -32.321583037341625], [4, 5.034079343639034, 23.102207946092893]], [-11.167066095509824, 16.592065417497455]], [[[1, 31.126317672358578, -10.036784369535214], [2, -38.70878528420893, 7.4987265861424595], [4, 17.977218575473767, 6.150889254289742]], [-6.595520680493778, -18.88118393939265]], [[[1, 41.82460922922086, 7.847527392202475], [3, 15.711709540417502, -30.34633659912818]], [-6.595520680493778, -18.88118393939265]], [[[0, 40.18454208294434, -6.710999804403755], [3, 23.019508919299156, -10.12110867290604]], [-6.595520680493778, -18.88118393939265]], [[[3, 27.18579315312821, 8.067219022708391]], [-6.595520680493778, -18.88118393939265]], [[], [11.492663265706092, 16.36822198838621]], [[[3, 24.57154567653098, 13.461499960708197]], [11.492663265706092, 16.36822198838621]], [[[0, 31.61945290413707, 0.4272295085799329], [3, 16.97392299158991, -5.274596836133088]], [11.492663265706092, 16.36822198838621]], [[[0, 22.407381798735177, -18.03500068379259], [1, 29.642444125196995, 17.3794951934614], [3, 4.7969752441371645, -21.07505361639969], [4, 14.726069092569372, 32.75999422300078]], [11.492663265706092, 16.36822198838621]], [[[0, 10.705527984670137, -34.589764174299596], [1, 18.58772336795603, -0.20109708164787765], [3, -4.839806195049413, -39.92208742305105], [4, 4.18824810165454, 14.146847823548889]], [11.492663265706092, 16.36822198838621]], [[[1, 5.878492140223764, -19.955352450942357], [4, -7.059505455306587, -0.9740849280550585]], [19.628527845173146, 3.83678180657467]], [[[1, -11.150789592446378, -22.736641053247872], [4, -28.832815721158255, -3.9462962046291388]], [-19.841703647091965, 2.5113335861604362]], [[[1, 8.64427397916182, -20.286336970889053], [4, -5.036917727942285, -6.311739993868336]], [-5.946642674882207, -19.09548221169787]], [[[0, 7.151866679283043, -39.56103232616369], [1, 16.01535401373368, -3.780995345194027], [4, -3.04801331832137, 13.697362774960865]], [-5.946642674882207, -19.09548221169787]], [[[0, 12.872879480504395, -19.707592098123207], [1, 22.236710716903136, 16.331770792606406], [3, -4.841206109583004, -21.24604435851242], [4, 4.27111163223552, 32.25309748614184]], [-5.946642674882207, -19.09548221169787]]] \n",
    "\n",
    "\n",
    "##  Test Case 2\n",
    "##\n",
    "# Estimated Pose(s):\n",
    "#     [50.000, 50.000]\n",
    "#     [69.035, 45.061]\n",
    "#     [87.655, 38.971]\n",
    "#     [76.084, 55.541]\n",
    "#     [64.283, 71.684]\n",
    "#     [52.396, 87.887]\n",
    "#     [44.674, 68.948]\n",
    "#     [37.532, 49.680]\n",
    "#     [31.392, 30.893]\n",
    "#     [24.796, 12.012]\n",
    "#     [33.641, 26.440]\n",
    "#     [43.858, 43.560]\n",
    "#     [54.735, 60.659]\n",
    "#     [65.884, 77.791]\n",
    "#     [77.413, 94.554]\n",
    "#     [96.740, 98.020]\n",
    "#     [76.149, 99.586]\n",
    "#     [70.211, 80.580]\n",
    "#     [64.130, 61.270]\n",
    "#     [58.183, 42.175]\n",
    "\n",
    "\n",
    "# Estimated Landmarks:\n",
    "#     [76.777, 42.415]\n",
    "#     [85.109, 76.850]\n",
    "#     [13.687, 95.386]\n",
    "#     [59.488, 39.149]\n",
    "#     [69.283, 93.654]\n",
    "\n",
    "\n",
    "### Uncomment the following three lines for test case 2 and compare to the values above ###\n",
    "\n",
    "mu_2 = slam(test_data2, 20, 5, 100.0, 2.0, 2.0)\n",
    "poses, landmarks = get_poses_landmarks(mu_2, 20)\n",
    "print_all(poses, landmarks)\n"
   ]
  },
  {
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}