Landmark_Detection_and_Tracking.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "# import some resources\n",
        "import random\n",
        "import numpy as np\n",
        "from math import *\n",
        "import seaborn as sns\n",
        "from pandas import DataFrame\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n"
      ],
      "metadata": {
        "id": "S6_pJvMJdNR4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Robot.py**"
      ],
      "metadata": {
        "id": "PTP6n2EpdhBT"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "id": "hJ0R5EQbYb9x"
      },
      "outputs": [],
      "source": [
        "# the robot class\n",
        "class robot:\n",
        "\n",
        "    # --------\n",
        "    # init: \n",
        "    #   creates a robot with the specified parameters and initializes \n",
        "    #   the location (self.x, self.y) to the center of the world\n",
        "    #\n",
        "    def __init__(self, world_size = 100.0, measurement_range = 30.0,\n",
        "                 motion_noise = 1.0, measurement_noise = 1.0):\n",
        "        self.measurement_noise = 0.0\n",
        "        self.world_size = world_size\n",
        "        self.measurement_range = measurement_range\n",
        "        self.x = world_size / 2.0\n",
        "        self.y = world_size / 2.0\n",
        "        self.motion_noise = motion_noise\n",
        "        self.measurement_noise = measurement_noise\n",
        "        self.landmarks = []\n",
        "        self.num_landmarks = 0\n",
        "\n",
        "\n",
        "    # returns a positive, random float\n",
        "    def rand(self):\n",
        "        return random.random() * 2.0 - 1.0\n",
        "\n",
        "\n",
        "    # --------\n",
        "    # move: attempts to move robot by dx, dy. If outside world\n",
        "    #       boundary, then the move does nothing and instead returns failure\n",
        "    #\n",
        "    def move(self, dx, dy):\n",
        "\n",
        "        x = self.x + dx + self.rand() * self.motion_noise\n",
        "        y = self.y + dy + self.rand() * self.motion_noise\n",
        "\n",
        "        if x < 0.0 or x > self.world_size or y < 0.0 or y > self.world_size:\n",
        "            return False\n",
        "        else:\n",
        "            self.x = x\n",
        "            self.y = y\n",
        "            return True\n",
        "    \n",
        "\n",
        "    # --------\n",
        "    # sense: returns x- and y- distances to landmarks within visibility range\n",
        "    #        because not all landmarks may be in this range, the list of measurements\n",
        "    #        is of variable length. Set measurement_range to -1 if you want all\n",
        "    #        landmarks to be visible at all times\n",
        "    #\n",
        "    \n",
        "    ## TODO: complete the sense function\n",
        "    def sense(self):\n",
        "        measurements = []\n",
        "        # more readable, Python doesn't support #define :(\n",
        "        X=0\n",
        "        Y=1\n",
        "        for idx, landmark in enumerate(self.landmarks):\n",
        "          dx = landmark[X] - self.x + self.rand() * self.measurement_noise\n",
        "          dy = landmark[Y] - self.y + self.rand() * self.measurement_noise\n",
        "          \n",
        "          if (abs(dx) <= self.measurement_range) and (abs(dy) <= self.measurement_range):\n",
        "            measurements.append([idx,dx,dy])\n",
        "\n",
        "        return measurements\n",
        "\n",
        "\n",
        "    def make_landmarks(self, num_landmarks):\n",
        "        self.landmarks = []\n",
        "        for i in range(num_landmarks):\n",
        "            self.landmarks.append([round(random.random() * self.world_size),\n",
        "                                   round(random.random() * self.world_size)])\n",
        "        self.num_landmarks = num_landmarks\n",
        "    \n",
        "    \n",
        "    # called when print(robot) is called; prints the robot's location\n",
        "    def __repr__(self):\n",
        "        return 'Robot: [x=%.5f y=%.5f]'  % (self.x, self.y)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Helper.py**"
      ],
      "metadata": {
        "id": "eK8-vOa9ftmx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# --------\n",
        "# this helper function displays the world that a robot is in\n",
        "# it assumes the world is a square grid of some given size\n",
        "# and that landmarks is a list of landmark positions(an optional argument)\n",
        "def display_world(world_size, position, landmarks=None):\n",
        "    \n",
        "    # using seaborn, set background grid to gray\n",
        "    sns.set_style(\"dark\")\n",
        "\n",
        "    # Plot grid of values\n",
        "    world_grid = np.zeros((world_size+1, world_size+1))\n",
        "\n",
        "    # Set minor axes in between the labels\n",
        "    ax=plt.gca()\n",
        "    cols = world_size+1\n",
        "    rows = world_size+1\n",
        "\n",
        "    ax.set_xticks([x for x in range(1,cols)],minor=True )\n",
        "    ax.set_yticks([y for y in range(1,rows)],minor=True)\n",
        "    \n",
        "    # Plot grid on minor axes in gray (width = 1)\n",
        "    plt.grid(which='minor',ls='-',lw=1, color='white')\n",
        "    \n",
        "    # Plot grid on major axes in larger width\n",
        "    plt.grid(which='major',ls='-',lw=2, color='white')\n",
        "    \n",
        "    # Create an 'o' character that represents the robot\n",
        "    # ha = horizontal alignment, va = vertical\n",
        "    ax.text(position[0], position[1], 'o', ha='center', va='center', color='r', fontsize=30)\n",
        "    \n",
        "    # Draw landmarks if they exists\n",
        "    if(landmarks is not None):\n",
        "        # loop through all path indices and draw a dot (unless it's at the car's location)\n",
        "        for pos in landmarks:\n",
        "            if(pos != position):\n",
        "                ax.text(pos[0], pos[1], 'x', ha='center', va='center', color='purple', fontsize=20)\n",
        "    \n",
        "    # Display final result\n",
        "    plt.show()\n",
        "\n",
        "    \n",
        "# --------\n",
        "# this routine makes the robot data\n",
        "# the data is a list of measurements and movements: [measurements, [dx, dy]]\n",
        "# collected over a specified number of time steps, N\n",
        "#\n",
        "def make_data(N, num_landmarks, world_size, measurement_range, motion_noise, \n",
        "              measurement_noise, distance):\n",
        "\n",
        "    # check that data has been made\n",
        "    try:\n",
        "        check_for_data(num_landmarks, world_size, measurement_range, motion_noise, measurement_noise)\n",
        "    except ValueError:\n",
        "        print('Error: You must implement the sense function in robot_class.py.')\n",
        "        return []\n",
        "    \n",
        "    complete = False\n",
        "    \n",
        "    r = robot(world_size, measurement_range, motion_noise, measurement_noise)\n",
        "    r.make_landmarks(num_landmarks)\n",
        "\n",
        "    while not complete:\n",
        "\n",
        "        data = []\n",
        "\n",
        "        seen = [False for row in range(num_landmarks)]\n",
        "    \n",
        "        # guess an initial motion\n",
        "        orientation = random.random() * 2.0 * pi\n",
        "        dx = cos(orientation) * distance\n",
        "        dy = sin(orientation) * distance\n",
        "            \n",
        "        for k in range(N-1):\n",
        "    \n",
        "            # collect sensor measurements in a list, Z\n",
        "            Z = r.sense()\n",
        "\n",
        "            # check off all landmarks that were observed \n",
        "            for i in range(len(Z)):\n",
        "                seen[Z[i][0]] = True\n",
        "    \n",
        "            # move\n",
        "            while not r.move(dx, dy):\n",
        "                # if we'd be leaving the robot world, pick instead a new direction\n",
        "                orientation = random.random() * 2.0 * pi\n",
        "                dx = cos(orientation) * distance\n",
        "                dy = sin(orientation) * distance\n",
        "\n",
        "            # collect/memorize all sensor and motion data\n",
        "            data.append([Z, [dx, dy]])\n",
        "\n",
        "        # we are done when all landmarks were observed; otherwise re-run\n",
        "        complete = (sum(seen) == num_landmarks)\n",
        "\n",
        "    print(' ')\n",
        "    print('Landmarks: ', r.landmarks)\n",
        "    print(r)\n",
        "\n",
        "\n",
        "    return data\n",
        "\n",
        "\n",
        "def check_for_data(num_landmarks, world_size, measurement_range, motion_noise, measurement_noise):\n",
        "    # make robot and landmarks\n",
        "    r = robot(world_size, measurement_range, motion_noise, measurement_noise)\n",
        "    r.make_landmarks(num_landmarks)\n",
        "    \n",
        "    \n",
        "    # check that sense has been implemented/data has been made\n",
        "    test_Z = r.sense()\n",
        "    if(test_Z is None):\n",
        "        raise ValueError"
      ],
      "metadata": {
        "id": "ElB-TqEVftDA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Making Data**"
      ],
      "metadata": {
        "id": "CIIahvWOeGmn"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0hiogj1TVJk9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d1e3e1c5-b4b3-47e2-fdc3-20fb6209f5de"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            " \n",
            "Landmarks:  [[74, 77], [14, 91], [86, 42], [34, 14], [89, 68]]\n",
            "Robot: [x=47.32018 y=30.54015]\n"
          ]
        }
      ],
      "source": [
        "# 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",
      "source": [
        "**Printing Step 0**"
      ],
      "metadata": {
        "id": "DtjAKpHqer0O"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ACNYGFPQVJk_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5542226a-95df-4a92-c098-2970c13ecc61"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Example measurements: \n",
            " [[0, 24.740949892549516, 25.22356313769078], [1, -37.199206157022324, 42.15598479446484], [2, 37.84512695880899, -7.833093933595998], [3, -17.2381529692158, -35.80637491710973], [4, 38.089523127727404, 16.49058470698857]]\n",
            "\n",
            "\n",
            "Example motion: \n",
            " [19.197873105354592, -5.607287065123634]\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": "code",
      "execution_count": null,
      "metadata": {
        "id": "vl7Zry7_VJlC"
      },
      "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",
        "    X=0\n",
        "    Y=1\n",
        "    init_pos = [world_size/2, world_size/2]\n",
        "    # multiplying by 2 since each pos/landmark has x,y values \n",
        "    size = N*2 + num_landmarks*2\n",
        "    \n",
        "    omega = np.zeros((size,size))\n",
        "    pos = 0\n",
        "    omega[pos+X][pos+X] = 1\n",
        "    omega[pos+Y][pos+Y] = 1\n",
        "    \n",
        "    xi = np.zeros((size,1))\n",
        "    xi[pos+X] = init_pos[X]\n",
        "    xi[pos+Y] = init_pos[Y]\n",
        "    \n",
        "    return omega, xi\n",
        "    "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tQIVTF68VJlC"
      },
      "source": [
        "### Test as you go\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CUrgzKixVJlD"
      },
      "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": null,
      "metadata": {
        "id": "TsRVqNWsVJlD",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 450
        },
        "outputId": "b7f20e90-adb0-49bd-80d0-484c9354c056"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7fcc66400cd0>"
            ]
          },
          "metadata": {},
          "execution_count": 23
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x504 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "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": null,
      "metadata": {
        "id": "EjoqO6aXVJlE",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 446
        },
        "outputId": "19d6aeed-bdef-458c-a10b-2bdf72b20af2"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7fcc661b8790>"
            ]
          },
          "metadata": {},
          "execution_count": 24
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 72x504 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "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": {
        "id": "Sz_7a_ORVJlE"
      },
      "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": null,
      "metadata": {
        "id": "zu3XkFGcVJlE"
      },
      "outputs": [],
      "source": [
        "## TODO: Complete the code to implement SLAM\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",
        "  # helping variable (like #difine in C++)  \n",
        "  X=0\n",
        "  Y=1\n",
        "  LM = 2*N\n",
        "  noise_measurement = 1/measurement_noise\n",
        "  noise_motion = 1/motion_noise \n",
        "\n",
        "  omega,xi = initialize_constraints(N,num_landmarks,world_size)\n",
        "\n",
        "    \n",
        "  for pos, item in enumerate(data):\n",
        "    pos *= 2\n",
        "    next = pos + 2\n",
        "    measurements = item[0]\n",
        "    motions = item[1]\n",
        "    for measurement in measurements:\n",
        "      lm_idx = LM + 2*measurement[0]\n",
        "      \n",
        "      omega[pos+X][pos+X] += noise_measurement\n",
        "      omega[pos+Y][pos+Y] += noise_measurement\n",
        "      omega[lm_idx+X][lm_idx+X] += noise_measurement\n",
        "      omega[lm_idx+Y][lm_idx+Y] += noise_measurement\n",
        "      \n",
        "      omega[pos+X][lm_idx+X] += -noise_measurement\n",
        "      omega[pos+Y][lm_idx+Y] += -noise_measurement\n",
        "      omega[lm_idx+X][pos+X] += -noise_measurement\n",
        "      omega[lm_idx+Y][pos+Y] += -noise_measurement\n",
        "      \n",
        "      \n",
        "      xi[pos+X] += -measurement[1+X] * noise_measurement\n",
        "      xi[pos+Y] += -measurement[1+Y] * noise_measurement\n",
        "      xi[lm_idx+X] += measurement[1+X] * noise_measurement\n",
        "      xi[lm_idx+Y] += measurement[1+Y] * noise_measurement\n",
        "\n",
        "    omega[pos+X][pos+X] += noise_motion \n",
        "    omega[pos+Y][pos+Y] += noise_motion \n",
        "    omega[next+X][next+X] += noise_motion \n",
        "    omega[next+Y][next+Y] += noise_motion \n",
        "\n",
        "    \n",
        "    omega[pos+X][next+X] += -noise_motion \n",
        "    omega[pos+Y][next+Y] += -noise_motion \n",
        "    omega[next+X][pos+X] += -noise_motion \n",
        "    omega[next+Y][pos+Y] += -noise_motion\n",
        "    \n",
        "    xi[pos+X] += -motions[X] * noise_motion\n",
        "    xi[pos+Y] += -motions[Y] * noise_motion\n",
        "    xi[next+X] += motions[X] * noise_motion\n",
        "    xi[next+Y] += motions[Y] * noise_motion\n",
        "\n",
        "  omega_inv = np.linalg.inv(np.matrix(omega))\n",
        "  mu = omega_inv * xi\n",
        "    \n",
        "  return mu \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ofIV04Z_VJlF"
      },
      "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": null,
      "metadata": {
        "id": "YU9gnC-QVJlF"
      },
      "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": null,
      "metadata": {
        "id": "wtTDnFTDVJlF"
      },
      "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": {
        "id": "x9MhLLRUVJlG"
      },
      "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": null,
      "metadata": {
        "id": "GBMzpEf9VJlG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9fa4a4e7-8028-4cae-bb59-6724d05c6093"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "\n",
            "Estimated Poses:\n",
            "[50.000, 50.000]\n",
            "[70.035, 43.184]\n",
            "[89.594, 37.488]\n",
            "[69.565, 44.964]\n",
            "[49.710, 53.056]\n",
            "[29.323, 61.052]\n",
            "[9.989, 67.156]\n",
            "[29.001, 64.024]\n",
            "[50.206, 61.503]\n",
            "[69.582, 58.033]\n",
            "[89.131, 54.042]\n",
            "[97.292, 36.040]\n",
            "[79.322, 43.259]\n",
            "[62.283, 51.793]\n",
            "[44.997, 61.115]\n",
            "[28.218, 68.794]\n",
            "[10.306, 77.560]\n",
            "[22.566, 61.048]\n",
            "[33.194, 44.563]\n",
            "[45.996, 29.197]\n",
            "\n",
            "\n",
            "Estimated Landmarks:\n",
            "[73.679, 76.943]\n",
            "[12.853, 90.454]\n",
            "[85.831, 41.737]\n",
            "[33.929, 14.148]\n",
            "[89.108, 68.159]\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",
        "# 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": {
        "id": "LOUcAZqaVJlG"
      },
      "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": null,
      "metadata": {
        "id": "4Rv2mr-6VJlG",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "9c01054c-a2c2-4c04-be0a-ba6cb3028e95"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Last pose:  (45.99577888570815, 29.196947344890077)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x1440 with 1 Axes>"
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "# 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": {
        "id": "tL5fwTkPVJlH"
      },
      "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": {
        "id": "-aKvJ79qVJlH"
      },
      "source": [
        "**Answer**: (Write your answer here.)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-Mtiq49vVJlH"
      },
      "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": null,
      "metadata": {
        "id": "9uEX3MX1VJlH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "51a11757-93ad-4942-e6fc-02b0130f9e11"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "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": null,
      "metadata": {
        "id": "t9bYthH6VJlI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ba43fc11-7a2f-4b2f-9898-9388a195cc7d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "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"
      ]
    }
  ],
  "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"
    },
    "colab": {
      "name": "Landmark Detection and Tracking.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "tQIVTF68VJlC"
      ]
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}