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, you'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. This is an active area of research in the fields of robotics and autonomous systems. Since this localization and map-building relies on the visual sensing of landmarks, this is a computer vision problem. \n",
    "\n",
    "Using what you've learned about robot motion, representations of uncertainty in motion and sensing, and localization techniques, you will be tasked 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",
    "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",
    "## Generating an environment\n",
    "\n",
    "In a real SLAM problem, you 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. Your 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. 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 will be working with the `robot` class that may look familiar from the first notebook, \n",
    "\n",
    "In fact, in the `helpers.py` file, you can read the details of how data is made with the `make_data` function. It should look very similar to the robot move/sense cycle you've seen in the first notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " \n",
      "Landmarks:  [[54, 100], [31, 50], [81, 18], [29, 77], [70, 85]]\n",
      "Robot: [x=77.82087 y=5.23933]\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": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Example measurements: \n",
      " [[0, 2.6397149741151735, 48.63971497411517], [1, -20.005880641018745, -1.0058806410187442], [2, 30.84306411849779, -32.15693588150221], [3, -20.247248886605558, 27.752751113394442], [4, 19.631893011777137, 34.63189301177714]]\n",
      "\n",
      "\n",
      "Example motion: \n",
      " [-19.4544394624717, 4.639481134892549]\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": [
    "### TODO: Write a 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",
    "\n",
    "*Depending on your approach you may choose to return one omega and one xi that hold all (x,y) positions *or* two of each (one for x values and one for y); choose whichever makes most sense to you!*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "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",
    "    rows= (N + num_landmarks) * 2 # Multiply by 2 for both (x,y) coordinates in a single omega matrix\n",
    "    cols= (N + num_landmarks) * 2\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 = np.zeros((rows, cols))  # Create an omega metrix\n",
    "    omega[0, 0]= 1                  # Assign diagonal elements (0,0) and (1,1) as 1 - to assign initial x and y values\n",
    "    omega[1, 1]= 1\n",
    "    \n",
    "    ## TODO: Define the constraint *vector*, xi\n",
    "    ## you can assume that the robot starts out in the middle of the world with 100% confidence\n",
    "    init_x = world_size / 2\n",
    "    init_y = world_size / 2\n",
    "    \n",
    "    xi = np.zeros((rows, 1))\n",
    "    xi[0, 0]= init_x\n",
    "    xi[1, 0]= init_y\n",
    "    \n",
    "    return omega, xi\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test as you go\n",
    "\n",
    "It's good practice to test out your code, as you 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",
    "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 slam 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": 69,
   "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": 70,
   "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": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f8b1b1dba90>"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f8b1b1ec828>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Creating a function to visualize matrix using a heatmap\n",
    "def visualize_heatmap(figure_size, visualize_matrix, cmap=\"Blues\"):\n",
    "    # define figure size\n",
    "    plt.rcParams[\"figure.figsize\"] = figure_size\n",
    "\n",
    "    # display matrix\n",
    "    visualize_heatmap = sns.heatmap(DataFrame(visualize_matrix), cmap=cmap, annot=True, linewidths=.5)\n",
    "    return visualize_heatmap \n",
    "\n",
    "# Visualizing heatmap of initial omega\n",
    "visualize_heatmap(figure_size=(10,7), visualize_matrix=initial_omega)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f8b1af69b38>"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f8b1b0517b8>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualizing heatmap of xi\n",
    "visualize_heatmap(figure_size=(1,7), visualize_matrix=initial_xi, cmap=\"Oranges\")"
   ]
  },
  {
   "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",
    "### TODO: Implement Graph SLAM\n",
    "\n",
    "Follow the TODO's below to help you complete this slam implementation (these TODO's are in the recommended order), then test out your implementation! \n",
    "\n",
    "#### Updating with motion and measurements\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": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "## TODO: Complete the code to implement SLAM\n",
    "\n",
    "## slam takes in 6 arguments and returns mu, omega, xi. 'mu' can be obtained using index 0. \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",
    "    ## TODO: Use your initilization to create constraint matrices, omega and xi\n",
    "    omega, xi = initialize_constraints(N, num_landmarks, world_size)\n",
    "\n",
    "    ## TODO: Iterate through each time step in the data\n",
    "    ## get all the motion and measurement data as you iterate\n",
    "    \n",
    "    for i in range(len(data)):       # Here 'i' is the time_step in the data\n",
    "        measurements= data[i][0]\n",
    "        motion= data[i][1]\n",
    "            \n",
    "    ## TODO: update the constraint matrix/vector to account for all *measurements*\n",
    "    ## this should be a series of additions that take into account the measurement noise\n",
    "        \n",
    "        for measurement in measurements:\n",
    "            # Recording values of landmark index, lx and ly values of each measured landmark respectively (in loop)\n",
    "            landmark_idx= measurement[0]\n",
    "            lx= measurement[1]\n",
    "            ly= measurement[2]\n",
    "            \n",
    "            # We have considered both the x and y co-ordinates in one omega matrix and one xi respectively.\n",
    "            \n",
    "            # Updating the weights/values of Px and Lx in omega (x- in omega) with  measurement_noise\n",
    "            # (using the grid [[1 -1][-1 1]] divided by measurement_noise)\n",
    "            omega[i*2, i*2]+= 1.0/measurement_noise\n",
    "            omega[i*2, (N+landmark_idx)*2]+= -1.0/measurement_noise\n",
    "            omega[(N+landmark_idx)*2, i*2]+= -1.0/measurement_noise\n",
    "            omega[(N+landmark_idx)*2, (N+landmark_idx)*2]+= 1.0/measurement_noise\n",
    "            \n",
    "            # Updating the position values in xi with lx value and measurement_noise\n",
    "            # (Affected by Px and Lx updates: (using lx value in the form [[-1 1]] divided by measurement_noise))\n",
    "            xi[(i*2), 0]+= -lx/measurement_noise\n",
    "            xi[(N+landmark_idx)*2, 0]+= lx/measurement_noise\n",
    "            \n",
    "            \n",
    "            # Updating the weights/values of Py and Ly in omega (y- in omega) with measurement_noise           \n",
    "            # (using the grid [[1 -1][-1 1]] divided by measurement_noise)\n",
    "            omega[i*2+1, i*2+1]+= 1.0/measurement_noise\n",
    "            omega[i*2+1, (N+landmark_idx)*2+1]+= -1.0/measurement_noise\n",
    "            omega[(N+landmark_idx)*2+1, i*2+1]+= -1.0/measurement_noise\n",
    "            omega[(N+landmark_idx)*2+1, (N+landmark_idx)*2+1]+= 1.0/measurement_noise \n",
    "            \n",
    "            # Updating the position values in xi with ly value and measurement_noise \n",
    "            # (Affected by Py and Ly updates: (using ly value in the form [[-1 1]] divided by measurement_noise))\n",
    "            xi[(i*2)+1, 0]+= -ly/measurement_noise\n",
    "            xi[(N+landmark_idx)*2+1, 0]+= ly/measurement_noise    \n",
    "            \n",
    "    ## TODO: update the constraint matrix/vector to account for all *motion* and motion noise\n",
    "            dx= motion[0]\n",
    "            dy= motion[1]\n",
    "\n",
    "            # Updating the weights/values of Px(i) and Px(i+1) in omega (x- in omega) with  motion_noise\n",
    "            # (using the grid [[1 -1][-1 1]] divided by motion_noise)\n",
    "            omega[i*2, i*2]+= 1.0/motion_noise\n",
    "            omega[i*2, (i+1)*2]+= -1.0/motion_noise\n",
    "            omega[(i+1)*2, i*2]+= -1.0/motion_noise\n",
    "            omega[(i+1)*2, (i+1)*2]+= 1.0/motion_noise\n",
    "            \n",
    "            # Updating the position values in xi with dx value and motion_noise\n",
    "            # (Affected by Px(i) and Px(i+1) updates: \n",
    "            # (using dx value in the form [[-1 1]] divided by motion_noise))\n",
    "            xi[i*2, 0]+= -dx/motion_noise\n",
    "            xi[(i+1)*2, 0]+= dx/motion_noise\n",
    "            \n",
    "\n",
    "            # Updating the weights/values of Py(i) and Py(i+1) in omega (y- in omega) with  motion_noise\n",
    "            # (using the grid [[1 -1][-1 1]] divided by motion_noise)\n",
    "            omega[i*2+1, i*2+1]+= 1.0/motion_noise\n",
    "            omega[i*2+1, (i+1)*2+1]+= -1.0/motion_noise\n",
    "            omega[(i+1)*2+1, i*2+1]+= -1.0/motion_noise\n",
    "            omega[(i+1)*2+1, (i+1)*2+1]+= 1.0/motion_noise   \n",
    "\n",
    "            # Updating the position values in xi with dy value and motion_noise\n",
    "            # (Affected by Py(i) and Py(i+1) updates: \n",
    "            # (using dy value in the form [[-1 1]] divided by motion_noise))\n",
    "            xi[i*2+1, 0]+= -dy/motion_noise\n",
    "            xi[(i+1)*2+1, 0]+= dy/motion_noise\n",
    "               \n",
    "    \n",
    "    ## TODO: After iterating through all the data\n",
    "    ## Compute the best estimate of poses and landmark positions\n",
    "    ## using the formula, omega_inverse * Xi\n",
    "\n",
    "    omega_inverse = np.linalg.pinv(np.matrix(omega))  # Using numpy inverse\n",
    "    mu = np.dot(omega_inverse, xi)\n",
    "    \n",
    "    return mu, omega, xi # Note: we will also return 'omega' and 'xi' along with 'mu' for visualization purposes"
   ]
  },
  {
   "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": 74,
   "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": 75,
   "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": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Estimated Poses:\n",
      "[50.000, 50.000]\n",
      "[30.113, 54.305]\n",
      "[10.414, 59.408]\n",
      "[26.304, 73.249]\n",
      "[41.940, 85.924]\n",
      "[58.044, 99.454]\n",
      "[78.020, 98.662]\n",
      "[98.297, 97.977]\n",
      "[79.694, 91.429]\n",
      "[60.817, 85.983]\n",
      "[41.218, 78.961]\n",
      "[22.740, 71.850]\n",
      "[3.275, 65.263]\n",
      "[20.726, 60.916]\n",
      "[39.317, 55.741]\n",
      "[58.081, 50.786]\n",
      "[77.793, 45.203]\n",
      "[97.709, 39.502]\n",
      "[87.704, 22.659]\n",
      "[76.946, 5.799]\n",
      "\n",
      "\n",
      "Estimated Landmarks:\n",
      "[54.280, 100.115]\n",
      "[31.480, 50.162]\n",
      "[80.613, 17.862]\n",
      "[28.807, 76.481]\n",
      "[69.846, 84.912]\n"
     ]
    }
   ],
   "source": [
    "# call your implementation of slam, passing in the necessary parameters\n",
    "mu, omega, xi = slam(data, N, num_landmarks, world_size, motion_noise, measurement_noise)\n",
    "\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": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m****************************************   Visualizing Final Omega   ****************************************\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f8b1b1ec978>"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f8b1b2f4908>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualizing heatmap of omega (final)\n",
    "print('\\033[1m' +\"*\"*40 +'   Visualizing Final Omega   '+\"*\"*40)\n",
    "visualize_heatmap(figure_size=(25,25), visualize_matrix= omega, cmap='BuPu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m****************************************   Visualizing Final Xi   ****************************************\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f8b1af2f588>"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f8b1b4e8d68>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualizing heatmap of xi (final)\n",
    "print('\\033[1m' +\"*\"*40 +'   Visualizing Final Xi   '+\"*\"*40)\n",
    "visualize_heatmap(figure_size=(1,25), visualize_matrix= xi, cmap=\"Oranges\")"
   ]
  },
  {
   "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": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Last pose:  (76.94588933773653, 5.7993500248119005)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f8b1a25e470>"
      ]
     },
     "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": [
    "**Solution**: \n",
    "\n",
    "**Question 1: How far away is your final pose (as estimated by slam) compared to the true final pose?**<br>**Answer:**\n",
    "<br>The table below shows the comparison between the true and estimated positions of the landmarks and that of the final pose of the robot.<br>The `true final pose` is `(78, 5)` whereas the `estimated final pose (as estimated by Graph SLAM)` is `(77, 6)`. <br><br>\n",
    "<center><b>Comparision between true and estimated positions (obtained using Graph SLAM)</b></center>\n",
    "<img src='images/comparison_btwn_true_estimated_positions_final.png' width=35% height=35% />\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 2: Why do you think these poses are different?**<br>\n",
    "(Ask yourself:<br>\n",
    "i. what do you think would happen if we moved and sensed more (increased N)? Or <br>\n",
    "ii. if we had lower/higher noise parameters.)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer (question: Why do you think these poses are different?:)**<br>\n",
    "From the above table, it is `quite evident that Graph SLAM performs exceptionally well`. `The true final pose of the robot obtained from make_data is quite close to the estimate obtained from Graph SLAM. Moreover, we also see that the estimated landmark positions are either exactly or closely near to their true counterparts.`\n",
    "\n",
    "`To answer the main question`, I must say that for `non-critical SLAM operations, the error percentage is within acceptable limits`. These `numbers fluctuate due to Bayesian inference, in which the degree of certainty updates over time, though noise can cause the robot's actual location to drift`. \n",
    "<br><br>\n",
    "**Answer (question (i): what do you think would happen if we moved and sensed more (increased N):**<br>\n",
    "`Because sensors are susceptible to noise, increasing N does not guarantee more accurate estimations`. This conclusion was reached after experimenting with a model with a large number of timesteps (N). \n",
    "<br><br>\n",
    "**Answer (question (ii): if we had lower/higher noise parameters?):** \n",
    "<br>(i) The `motion_noise` is a `noise parameter` that is used `when the robot moves` from pose to pose to account for motion noise in real-time.<br>(ii) Also, `measurement_noise` is a parameter used to `account for noise in the measurements` between pose and the landmarks *(its use and application can be deciphered from the sense function within the robot class)*. <br>(iii) These `parameters` will `either increase/decrease the precision on the estimation obtained from Graph SLAM`. The value of weights in omega and predicted xi are divided by the respective noise parameters as and when the robot motion and sensing happens.<br>\n",
    "(iv) The `constraint matrix/vector is constantly updated to account for all the motion noise and measurement noise on the basis of the action the robot performs`. <br>\n",
    "(v) `In the final omega and xi matrices, when noise is greater, the final values are smaller - implying less certainty. So, for the model to be more certain of its estimate, it is essential to have lower noise.`<br>\n",
    "(vi) `To conclude:` **In theory, lower noise equals higher accuracy, and vice versa.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing\n",
    "\n",
    "To confirm that your slam code works before submitting your project, it is suggested that you run it on some test data and cases. A few such cases have been provided for you, in the cells below. When you are ready, uncomment the test cases in the next cells (there are two test cases, total); your 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",
    "### Submit your project\n",
    "\n",
    "If you pass these tests, it is a good indication that your project will pass all the specifications in the project rubric. Follow the submission instructions to officially submit!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Estimated Poses:\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"
     ]
    }
   ],
   "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)[0]  # Note: 0 index of slam() is 'mu'\n",
    "poses, landmarks = get_poses_landmarks(mu_1, 20)\n",
    "print_all(poses, landmarks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Estimated Poses:\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"
     ]
    }
   ],
   "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)[0]  # Note: 0 index of slam() is 'mu'\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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}