3. Landmark Detection and Tracking.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Project 3:  Implement SLAM \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. 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. We will be tasked, among other things, with defining a function, `slam`, which takes in six parameters as input and returns the vector `mu`. \n",
    "> `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",
    "Our function will return the vector, `mu`, with its (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",
    "## Generating an environment\n",
    "\n",
    "In a real SLAM problem, we may be given a map that contains information about landmark locations, and in this example, we will make our own data using the `make_data` function, which generates a world grid with landmarks in it and then generates data by placing a robot in that world and moving and sensing over some numer of time steps. The `make_data` function relies on a correct implementation of robot move/sense functions, which, at this point, should be complete and in the `robot_class.py` file. The data is collected as an instantiated robot moves and senses in a world. Our SLAM function will take in this data as input. So, let's first create this data and explore how it represents the movement and sensor measurements that our robot takes.\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. `data` holds the sensors measurements and motion of our robot over time. It stores the measurements as `data[i][0]` and the motion as `data[i][1]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " \n",
      "Landmarks:  [[29, 39], [45, 24], [97, 58], [97, 74], [12, 19]]\n",
      "Robot: [x=75.46618 y=63.25851]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from helpers import make_data\n",
    "\n",
    "# our implementation of slam should work with the following inputs\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 we should refer back to when we test our 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`. We 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": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Example measurements: \n",
      " [[0, -44.85779929794232, -17.864141815621792], [1, -28.1190520293837, -33.6918722760941], [2, 24.029424543657473, 1.0124449796651094], [3, 24.55368813278552, 16.784926967774854]]\n",
      "\n",
      "\n",
      "Example motion: \n",
      " [19.3808843257573, 4.9377447029605435]\n"
     ]
    }
   ],
   "source": [
    "# print out some stats about the data\n",
    "time_step = 8\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": [
    "If we change the value of `time_step`, we should see that the list of measurements varies based on what in the world the robot sees after it moves. 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. "
   ]
  },
  {
   "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, we 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, we 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% />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initializing omega and xi\n",
    "\n",
    "The cell below contains the function `initialize_constraints` swhich returns `omega` and `xi` constraints for the starting position of the robot. Any values that we do not yet know will be initialized with the value `0`. 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 us all the information we need to construct intial constraints of the correct size and starting values.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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",
    "    ## Defining the constraint matrix, Omega, with two initial \"strength\" values\n",
    "    ## for the initial x, y location of our robot\n",
    "    dim = 2*(N + num_landmarks) # 2: because we are in a 2D world (x,y)\n",
    "    omega = np.zeros((dim ,dim ))\n",
    "    omega[0, 0] = 1 \n",
    "    omega[1, 1] = 1\n",
    "    \n",
    "    ## Defining the constraint *vector*, xi\n",
    "    ## we can assume that the robot starts out in the middle of the world with 100% confidence\n",
    "    xi = np.zeros((dim, 1))\n",
    "    xi[0] = world_size / 2.0 #initial_pos x\n",
    "    xi[1] = world_size / 2.0 #initial_pos y\n",
    "    \n",
    "    return omega, xi\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test as we go\n",
    "\n",
    "It's good practice to test out our code, as we go. Since `slam` relies on creating and updating constraint matrices, `omega` and `xi` to account for robot sensor measurements and motion, let's check that they initialize as expected for any given parameters.\n",
    "\n",
    "This code assumes that we have created one of each constraint: `omega` and `xi`. 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. We'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": 4,
   "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": 5,
   "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, initial_xi = initialize_constraints(N_test, num_landmarks_test, small_world)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fa2ccd96a58>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fa2ccacab38>"
      ]
     },
     "metadata": {},
     "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), cmap='Blues', annot=True, linewidths=.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fa2ca739dd8>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fa2ca739390>"
      ]
     },
     "metadata": {},
     "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), cmap='Oranges', annot=True, linewidths=.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## SLAM inputs \n",
    "\n",
    "In addition to `data`, our 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 the 2D 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 we 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` we'll do a similar addition process only using the actual value of a motion or measurement. So for a vector index `xi[row][0]` we will end up adding/subtracting one measurement or motion divided by their respective `noise`.\n",
    "\n",
    "### Implementing Graph SLAM\n",
    "\n",
    "With a 2D omega and xi structure as shown above (in earlier cells), we'll have to be mindful about how we update the values in the constraint matrices to account for motion and measurement constraints in the x and y directions. 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",
    "We may also choose to return the values of `omega` and `xi` in order to visualize their final state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "## 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",
    "    omega, xi = initialize_constraints(N, num_landmarks, world_size) #\n",
    "    for i, (cur_measure, cur_motion) in enumerate(data): #At ith timestep: measurements are data[i][0] and the motion is data[i][1].\n",
    "        for landmark_index, landmark_x, landmark_y in cur_measure: \n",
    "            # x update\n",
    "            omega[2*i, 2*i] += 1 / measurement_noise\n",
    "            omega[2*(N + landmark_index), 2*(N + landmark_index)] += 1 / measurement_noise\n",
    "            omega[2*i, 2*(N + landmark_index)] -= 1 / measurement_noise\n",
    "            omega[2*(N + landmark_index), 2*i ] -= 1 / measurement_noise\n",
    "\n",
    "            #y update\n",
    "            omega[2*i + 1, 2*i + 1] += 1 / measurement_noise\n",
    "            omega[2*(N + landmark_index) + 1, 2*(N + landmark_index) + 1] += 1 / measurement_noise\n",
    "            omega[2*i + 1, 2*(N + landmark_index) + 1] -= 1 / measurement_noise\n",
    "            omega[2*(N + landmark_index) + 1, 2*i + 1] -= 1 / measurement_noise\n",
    "            \n",
    "            \n",
    "            \n",
    "            xi[2*i] -= landmark_x / measurement_noise\n",
    "            xi[2*(N + landmark_index)] += landmark_x / measurement_noise\n",
    "            \n",
    "            xi[2*i + 1] -= landmark_y / measurement_noise\n",
    "            xi[2*(N + landmark_index) + 1] += landmark_y / measurement_noise\n",
    "\n",
    "        motion_x, motion_y = cur_motion\n",
    "        omega[2*i:2*i + 4, 2*i:2*i + 4] += (1/motion_noise)*np.array([[1, 0, -1, 0],\n",
    "                                                                      [0, 1, 0, -1],\n",
    "                                                                      [-1, 0, 1, 0],\n",
    "                                                                      [0, -1, 0, 1]]) \n",
    "\n",
    "        xi[2*i:2*i + 4] += (1/motion_noise)*np.array([[- motion_x],\n",
    "                                                      [- motion_y],\n",
    "                                                      [  motion_x],\n",
    "                                                      [  motion_y]])\n",
    "\n",
    "    mu = np.linalg.inv(np.matrix(omega))*xi ## the best estimate of poses and landmark positions\n",
    "    \n",
    "    return mu # return `mu`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Helper functions\n",
    "\n",
    "To check that our implementation of SLAM works for various inputs, two helper functions will help display the estimated pose and landmark locations that our 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": 9,
   "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": 10,
   "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",
    "The `data` that is generated is random, but we did specify the number, `N`, or time steps that the robot was expected to move and the `num_landmarks` in the world. Our robot should also start with an estimated pose in the very center of a square world, whose size is defined by `world_size`.\n",
    "\n",
    "With these values in mind, we 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 our robot has taken. The very first pose should be the center of this 2D 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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Estimated Poses:\n",
      "[50.000, 50.000]\n",
      "[61.718, 33.626]\n",
      "[72.413, 16.463]\n",
      "[53.886, 23.640]\n",
      "[35.830, 32.268]\n",
      "[16.964, 42.464]\n",
      "[35.009, 47.770]\n",
      "[54.019, 53.115]\n",
      "[73.560, 57.428]\n",
      "[93.323, 62.225]\n",
      "[90.138, 82.637]\n",
      "[71.703, 93.043]\n",
      "[71.843, 75.280]\n",
      "[72.694, 54.989]\n",
      "[74.093, 36.220]\n",
      "[75.631, 15.861]\n",
      "[95.651, 8.366]\n",
      "[88.349, 25.882]\n",
      "[82.561, 44.459]\n",
      "[75.163, 63.041]\n",
      "\n",
      "\n",
      "Estimated Landmarks:\n",
      "[29.921, 39.663]\n",
      "[45.733, 23.791]\n",
      "[96.726, 58.246]\n",
      "[97.247, 73.769]\n",
      "[12.059, 18.483]\n"
     ]
    }
   ],
   "source": [
    "mu = slam(data, N, num_landmarks, world_size, motion_noise, measurement_noise)\n",
    "\n",
    "if(mu is not None):\n",
    "    # let's 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": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "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 we have coded with `slam`: the final position of the robot and the positon of landmarks.\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": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Last pose:  (75.16337582226448, 63.04054665334762)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fa2ca8f4f60>"
      ]
     },
     "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": [
    "### Question: How far away is your final pose (as estimated by `slam`) compared to the *true* final pose? Why do you think these poses are different?\n",
    "\n",
    "You can find the true value of the final pose in one of the first cells where `make_data` was called. You may also want to look at the true landmark locations and compare them to those that were estimated by `slam`. Ask yourself: what do you think would happen if we moved and sensed more (increased N)? Or if we had lower/higher noise parameters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer**: True and predicted last pose locations are fairly close:\n",
    "True last pose: (x=75.46618 y=63.25851)\n",
    "Predicted pose: (75.16337582226448, 63.04054665334762)\n",
    "\n",
    "Landmarks:  \n",
    "[29, 39], [45, 24], [97, 58], [97, 74], [12, 19]]\n",
    "\n",
    "Estimated Landmarks:  \n",
    "[29.921, 39.663], [45.733, 23.791], [96.726, 58.246], [97.247, 73.769], [12.059, 18.483]\n",
    "\n",
    "***Other test cases:***  \n",
    "\n",
    "**Test Case 1:**  \n",
    "True Landmarks:  \n",
    "[[82.679, 13.435], [70.417, 74.203], [36.688, 61.431], [18.705, 66.136], [20.437, 16.983]]\n",
    "\n",
    "Estimated Landmarks:  \n",
    "[[82.956, 13.539], [70.495, 74.141], [36.740, 61.281], [18.698, 66.060], [20.635, 16.875]]\n",
    "\n",
    "**Test Case 2:**  \n",
    "True Landmarks:  \n",
    "[[76.777, 42.415], [85.109, 76.850], [13.687, 95.386], [59.488, 39.149], [69.283, 93.654]]\n",
    "\n",
    "Estimated Landmarks:  \n",
    "[[76.779, 42.887], [85.065, 77.438], [13.548, 95.652], [59.449, 39.595], [69.263, 94.240]]\n",
    "\n",
    "Precision of predictions is obviously influenced by the values of motion_noise and measurement_noise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing\n",
    "\n",
    "To confirm that our slam code works, we'll run it on some test data and cases. Two such cases are shown in the cells below. The cell output should be close-to or exactly identical to the given results. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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",
    "### test case 1 - compare the cell 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": 14,
   "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",
    "### test case 2 - compare the cell output 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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}