4. Online GraphSLAM.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Online SLAM\n",
    "\n",
    "\n",
    "## Overview\n",
    "\n",
    "Online SLAM is an advanced version SLAM that only considers the most recent pose. Please refer the Sebastian Thrun youtube video about \"Online SLAM\", in which this precise topic is taken up: https://www.youtube.com/watch?v=jaeNlxhQL1I. \n",
    "Other changes compared to the notebook 4:\n",
    "1. OnlineSlam is now implemented as a class\n",
    "1. The data loop happens outside of the class.\n",
    "1. The x and y `xi` vectors are separated. `omega` is the same for both.\n",
    "\n",
    "I will also be attempting to make a short video of the movements of the robot. For plotting purposes I have to use a modified version of \"make_data\" because the robot's ground truth position was not being saved anywhere."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create the world\n",
    "\n",
    "In this world, the number of landmarks increases to ten, the robot doesn't move as far in each step and can't sense as far; therefore the number of time steps increases in order to be able to cover most of the world space."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from helpers import check_for_data\n",
    "\n",
    "\n",
    "# world parameters\n",
    "num_landmarks = 10  # number of landmarks\n",
    "N = 100  # time steps\n",
    "world_size = 100.0  # size of world (square)\n",
    "\n",
    "# robot parameters\n",
    "measurement_range = 30.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 = 10.0  # distance by which robot (intends to) move each iteratation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " \n",
      "Landmarks:  [[24, 94], [40, 84], [16, 76], [83, 2], [96, 99], [9, 20], [69, 9], [49, 6], [14, 64], [16, 77]]\n",
      "Robot: [x=88.97206 y=66.18842]\n"
     ]
    }
   ],
   "source": [
    "from robot_class import Robot\n",
    "import random\n",
    "from math import *\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",
    "    N,\n",
    "    num_landmarks,\n",
    "    world_size,\n",
    "    measurement_range,\n",
    "    motion_noise,\n",
    "    measurement_noise,\n",
    "    distance,\n",
    "):\n",
    "    pass\n",
    "\n",
    "    # check that data has been made\n",
    "    try:\n",
    "        check_for_data(\n",
    "            num_landmarks,\n",
    "            world_size,\n",
    "            measurement_range,\n",
    "            motion_noise,\n",
    "            measurement_noise,\n",
    "        )\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",
    "            # UPDATE: ADD GROUND TRUTH POSITION FOR PLOTTING PURPOSES\n",
    "            #\n",
    "            data.append([Z, [dx, dy], [r.x, r.y]])\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",
    "    return data, r.landmarks\n",
    "\n",
    "\n",
    "# make_data instantiates a robot, AND generates random landmarks for a given world size and number of landmarks\n",
    "data, gt_landmarks = make_data(\n",
    "    N,\n",
    "    num_landmarks,\n",
    "    world_size,\n",
    "    measurement_range,\n",
    "    motion_noise,\n",
    "    measurement_noise,\n",
    "    distance,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Example measurements: \n",
      " [[3, 4.919525124193677, 7.579509097531289], [6, 8.809249082641, 0.8166498859320654], [7, 29.229192817860266, 1.7931631153854792]]\n",
      "\n",
      "\n",
      "Example motion: \n",
      " [8.63923250363775, 5.036234878169306]\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": [
    "## OnlineSLAM class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class OnlineGraphSlam(object):\n",
    "    def __init__(self, num_landmarks, world_size, motion_noise, measurement_noise):\n",
    "        self.size = 1 + num_landmarks\n",
    "\n",
    "        self.omega = np.zeros((self.size, self.size))  # same for x and y\n",
    "        self.omega[0, 0] = 1  # initial location constraint\n",
    "\n",
    "        self.xi_x = np.zeros((self.size))\n",
    "        self.xi_y = np.zeros((self.size))\n",
    "        self.xi_x[0] = self.xi_y[0] = world_size / 2  # init location constraint\n",
    "\n",
    "        # weights for omega/xi\n",
    "        self.Wms = 1.0 / measurement_noise\n",
    "        self.Wmo = 1.0 / motion_noise\n",
    "\n",
    "        self.verbose = False\n",
    "\n",
    "        np.set_printoptions(precision=2, suppress=True, linewidth=128)\n",
    "\n",
    "    def update_ms(self, measurements):\n",
    "        for m in measurements:\n",
    "            lm_j, lm_dx, lm_dy = m[0], m[1], m[2]\n",
    "            lm_j = 1 + lm_j\n",
    "\n",
    "            self.omega[0, 0] += self.Wms  # 0.x <-> 0.x\n",
    "            self.omega[0, lm_j] -= self.Wms  # 0.x <-> lm_j.x\n",
    "            self.omega[lm_j, 0] -= self.Wms  # lm_j.x <-> 0.x\n",
    "            self.omega[lm_j, lm_j] += self.Wms  # lm_j.x <-> lm_j.x\n",
    "\n",
    "            self.xi_x[0] -= lm_dx * self.Wms\n",
    "            self.xi_y[0] -= lm_dy * self.Wms\n",
    "            self.xi_x[lm_j] += lm_dx * self.Wms\n",
    "            self.xi_y[lm_j] += lm_dy * self.Wms\n",
    "\n",
    "    def update_mo(self, motion):\n",
    "        \"\"\"\n",
    "        This suddenly got complicated.\n",
    "        -- see https://www.youtube.com/watch?v=jaeNlxhQL1I\n",
    "        1. \"Expand\" omega and xi's by 1 in rows and cols representing new pose\n",
    "        2. Perform motion update\n",
    "        3. Fold old pose information into the new omega and xi's\n",
    "        4. Shrink omega and xi's back to their original sizes by eliminating old pose.\n",
    "        \"\"\"\n",
    "        if self.verbose:\n",
    "            print(\"----------------- MOTION UPDATE: \")\n",
    "            print(\"({0:.3f},{1:.3f})\".format(motion[0], motion[1]))\n",
    "\n",
    "        last = self.size\n",
    "        new_omega = np.zeros((last + 1, last + 1))\n",
    "        new_omega[2 : last + 1, 2 : last + 1] = self.omega[1:last, 1:last].copy()\n",
    "        new_omega[0, 2 : last + 1] = self.omega[0, 1:last].copy()  # first row moves up\n",
    "        new_omega[2 : last + 1, 0] = self.omega[\n",
    "            1:last, 0\n",
    "        ].copy()  # first col moves left\n",
    "        new_omega[0, 0] = self.omega[0, 0]  # upper left corner\n",
    "\n",
    "        if self.verbose:\n",
    "            print(\"----------------- Copied self to new\")\n",
    "            print(\"self.omega: \")\n",
    "            print(self.omega)\n",
    "            print(\"new_omega: \")\n",
    "            print(new_omega)\n",
    "\n",
    "        # zeroed row and col 1 now ready for new pose, perform update\n",
    "        new_omega[0, 0] += self.Wmo  # t.x\n",
    "        new_omega[1, 1] += self.Wmo  # t+1.x\n",
    "        new_omega[0, 1] -= self.Wmo  # t.x <-> t+1.x\n",
    "        new_omega[1, 0] -= self.Wmo  # t+1.x <-> t.x\n",
    "\n",
    "        # same for xi:\n",
    "        new_xi_x = np.zeros((last + 1))\n",
    "        new_xi_y = np.zeros((last + 1))\n",
    "        new_xi_x[2 : last + 1] = self.xi_x[1:last].copy()\n",
    "        new_xi_y[2 : last + 1] = self.xi_y[1:last].copy()\n",
    "        new_xi_x[0] = self.xi_x[0]\n",
    "        new_xi_y[0] = self.xi_y[0]\n",
    "\n",
    "        if self.verbose:\n",
    "            print(\"----------------- created new xi's\")\n",
    "            print(\"self.xi_x: \", self.xi_x)\n",
    "            print(\"new_xi_x : \", new_xi_x)\n",
    "            print(\"self.xi_y: \", self.xi_y)\n",
    "            print(\"new_xi_y : \", new_xi_y)\n",
    "\n",
    "        new_xi_x[0] -= self.Wmo * motion[0]\n",
    "        new_xi_x[1] += self.Wmo * motion[0]\n",
    "\n",
    "        new_xi_y[0] -= self.Wmo * motion[1]\n",
    "        new_xi_y[1] += self.Wmo * motion[1]\n",
    "\n",
    "        if self.verbose:\n",
    "            print(\"----------------- After motion update\")\n",
    "            print(\"new_omega:\")\n",
    "            print(new_omega)\n",
    "            print(\"new_xi_x: \", new_xi_x)\n",
    "            print(\"new_xi_y: \", new_xi_y)\n",
    "\n",
    "        # Shrinking omega and xi's back\n",
    "        self.omega = new_omega[1 : last + 1, 1 : last + 1].copy()\n",
    "        self.xi_x = new_xi_x[1 : last + 1].copy()\n",
    "        self.xi_y = new_xi_y[1 : last + 1].copy()\n",
    "\n",
    "        # Now form A, B, and C from old pose info\n",
    "        A = new_omega[0, 1 : last + 1].copy().reshape(1, -1)  # row vector\n",
    "        B = new_omega[0, 0]\n",
    "        C_x = new_xi_x[0]\n",
    "        C_y = new_xi_y[0]\n",
    "\n",
    "        if self.verbose:\n",
    "            print(\"----------------- New back to self, A, B, C's\")\n",
    "            print(\"from new:\")\n",
    "            print(new_omega)\n",
    "            print(\"to self:\")\n",
    "            print(self.omega)\n",
    "            print(\"A: \")\n",
    "            print(A)\n",
    "            print(\"B: \", B)\n",
    "            print(\"new_xi_x : \", new_xi_x)\n",
    "            print(\"self.xi_x: \", self.xi_x)\n",
    "            print(\"C_x : \", C_x)\n",
    "            print(\"new_xi_y : \", new_xi_y)\n",
    "            print(\"self.xi_y: \", self.xi_y)\n",
    "            print(\"C_y : \", C_y)\n",
    "\n",
    "        AtBinv = A.T / B\n",
    "        AtBinvA = np.dot(AtBinv, A)\n",
    "        AtBinvC_x = C_x * AtBinv\n",
    "        AtBinvC_y = C_y * AtBinv\n",
    "\n",
    "        if self.verbose:\n",
    "            print(\"-----------------\")\n",
    "            print(\"AtBinv:\")\n",
    "            print(AtBinv)\n",
    "            print(\"AtBinvA: \")\n",
    "            print(AtBinvA)\n",
    "            print(\"AtBinvC_x: \")\n",
    "            print(AtBinvC_x)\n",
    "            print(\"AtBinvC_y: \")\n",
    "            print(AtBinvC_y)\n",
    "\n",
    "        # Folding old pose info back into omega/xi\n",
    "        self.omega -= AtBinvA\n",
    "        self.xi_x -= np.squeeze(AtBinvC_x)\n",
    "        self.xi_y -= np.squeeze(AtBinvC_y)\n",
    "\n",
    "        if self.verbose:\n",
    "            print(\"----------------- After folding\")\n",
    "            print(\"omega:\")\n",
    "            print(self.omega)\n",
    "            print(\"xi_x: \", self.xi_x)\n",
    "            print(\"xi_y: \", self.xi_y)\n",
    "\n",
    "    def __call__(self, measurements, motion):\n",
    "\n",
    "        self.update_ms(measurements)\n",
    "        self.update_mo(motion)\n",
    "\n",
    "    def get_mu(self):\n",
    "        # Compute the best estimate of current pose and landmarks at each time step\n",
    "        # using the formula, omega_inverse * Xi\n",
    "        try:\n",
    "            omega_inv = np.linalg.inv(self.omega)\n",
    "        except np.linalg.LinAlgError as err:\n",
    "            return None\n",
    "\n",
    "        mu_x, mu_y = np.dot(omega_inv, self.xi_x), np.dot(omega_inv, self.xi_y)\n",
    "        mu = np.concatenate((mu_x.reshape(-1, 1), mu_y.reshape(-1, 1)), axis=1)\n",
    "\n",
    "        if self.verbose:\n",
    "            print(\"----------------- Calc mu\")\n",
    "            print(\"omega:\")\n",
    "            print(self.omega)\n",
    "            print(\"omega_inv:\")\n",
    "            print(omega_inv)\n",
    "            print(\"xi_x: \", self.xi_x)\n",
    "            print(\"xi_y: \", self.xi_y)\n",
    "            print(\"mu_x: \", mu_x)\n",
    "            print(\"mu_y: \", mu_y)\n",
    "\n",
    "        return mu\n",
    "\n",
    "    def get_omega_xi(self):\n",
    "        xi = np.concatenate(\n",
    "            (self.xi_x.reshape(-1, 1), self.xi_y.reshape(-1, 1)), axis=1\n",
    "        )\n",
    "        return self.omega, xi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "online_slam = OnlineSlam(num_landmarks, world_size, motion_noise, measurement_noise)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Helper functions\n",
    "\n",
    "To check that the implementation of SLAM works for various inputs, I have provided two helper functions that will help display the estimated pose and landmark locations that slam 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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a helper function that returns the last pose and a list of landmarks for ease of printing\n",
    "def get_pose_landmarks(mu):\n",
    "    pose = mu[0]\n",
    "    landmarks = mu[1:]\n",
    "    return pose, landmarks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_all(lastpose, landmarks):\n",
    "    print(\"\\n\")\n",
    "    print(\"Estimated Last Pose:\")\n",
    "    print(lastpose)\n",
    "    print(\"\\n\")\n",
    "    print(\"Estimated Landmarks:\")\n",
    "    for i in range(len(landmarks)):\n",
    "        print(landmarks[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib.patches import ConnectionPatch\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# Have to modify display_world for this notebook\n",
    "# from helpers import display_world\n",
    "\n",
    "\n",
    "def display_world(\n",
    "    world_size,\n",
    "    gtpose,\n",
    "    gtlms,  # ground truth positions\n",
    "    measpose=None,\n",
    "    measlms=None,  # measured positions\n",
    "    measurements=None,\n",
    "    save_file=False,\n",
    "):\n",
    "\n",
    "    global plt\n",
    "    global count\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",
    "    # import matplotlib.pyplot as plt\n",
    "    fig = plt.figure()\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(\n",
    "        gtpose[0], gtpose[1], \"o\", ha=\"center\", va=\"center\", color=\"purple\", fontsize=30\n",
    "    )\n",
    "\n",
    "    if measpose is not None:\n",
    "        ax.text(\n",
    "            measpose[0],\n",
    "            measpose[1],\n",
    "            \"o\",\n",
    "            ha=\"center\",\n",
    "            va=\"center\",\n",
    "            color=\"r\",\n",
    "            fontsize=30,\n",
    "        )\n",
    "\n",
    "    circle = plt.Circle(gtpose, measurement_range, color=\"r\", alpha=0.1)\n",
    "\n",
    "    ax.add_artist(circle)\n",
    "\n",
    "    # Draw ground truth landmarks if they exists\n",
    "    if gtlms is not None:\n",
    "        for pos in gtlms:\n",
    "            ax.text(\n",
    "                pos[0],\n",
    "                pos[1],\n",
    "                \"x\",\n",
    "                ha=\"center\",\n",
    "                va=\"center\",\n",
    "                color=\"purple\",\n",
    "                fontsize=20,\n",
    "            )\n",
    "\n",
    "    # Draw landmark estimates if they exists\n",
    "    if measlms is not None:\n",
    "        for pos in measlms:\n",
    "            ax.text(\n",
    "                pos[0], pos[1], \"x\", ha=\"center\", va=\"center\", color=\"red\", fontsize=20\n",
    "            )\n",
    "\n",
    "    # Draw measurements as lines radiating from the ground truth position\n",
    "    if measurements is not None:\n",
    "        for m in measurements:\n",
    "            lm_j, lm_dx, lm_dy = m[0], m[1], m[2]\n",
    "            if measlms is not None:\n",
    "                pos = measlms[lm_j]\n",
    "            else:\n",
    "                pos = np.array(gtpose) + np.array([lm_dx, lm_dy])\n",
    "            con = ConnectionPatch(gtpose, pos, \"data\", color=\"r\")\n",
    "            ax.add_artist(con)\n",
    "\n",
    "    # Display final result\n",
    "    if save_file:\n",
    "        fig.savefig(\"image{0:02d}.png\".format(count), bbox_inches=\"tight\")\n",
    "        count = count + 1\n",
    "        plt.close(fig)\n",
    "    else:\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run Online SLAM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Estimated Last Pose:\n",
      "[73.05 52.86]\n",
      "\n",
      "\n",
      "Estimated Landmarks:\n",
      "[67.87 85.75]\n",
      "[69.06 76.16]\n",
      "[65.46 69.4 ]\n",
      "[60.74 59.76]\n",
      "[79.97 86.9 ]\n",
      "[65.  50.7]\n",
      "[72.62 53.63]\n",
      "[66.54 55.45]\n",
      "[65.01 61.77]\n",
      "[66.04 69.86]\n"
     ]
    }
   ],
   "source": [
    "# define figure size\n",
    "plt.rcParams[\"figure.figsize\"] = (20, 20)\n",
    "\n",
    "count = 0\n",
    "\n",
    "online_slam = OnlineSlam(num_landmarks, world_size, motion_noise, measurement_noise)\n",
    "\n",
    "gtpose = [world_size / 2, world_size / 2]\n",
    "\n",
    "# Save initial position\n",
    "display_world(int(world_size), gtpose, gt_landmarks, save_file=True)\n",
    "\n",
    "# call the implementation of slam, passing in the necessary parameters\n",
    "for sample in data:\n",
    "    measurements, motion, gtpose = sample\n",
    "    online_slam(measurements, motion)\n",
    "    mu = online_slam.get_mu()\n",
    "    if mu is not None:\n",
    "        measpose, measlms = get_pose_landmarks(mu)\n",
    "        display_world(\n",
    "            int(world_size),\n",
    "            gtpose,\n",
    "            gt_landmarks,\n",
    "            measpose,\n",
    "            measlms,\n",
    "            measurements,\n",
    "            save_file=True,\n",
    "        )\n",
    "    else:\n",
    "        display_world(\n",
    "            int(world_size),\n",
    "            gtpose,\n",
    "            gt_landmarks,\n",
    "            measurements=measurements,\n",
    "            save_file=True,\n",
    "        )\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",
    "    lastpose, landmarks = get_pose_landmarks(mu)\n",
    "    print_all(lastpose, landmarks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "updating: image00.png (160 bytes security) (deflated 26%)\n",
      "updating: image01.png (160 bytes security) (deflated 37%)\n",
      "updating: image02.png (160 bytes security) (deflated 40%)\n",
      "updating: image03.png (160 bytes security) (deflated 37%)\n",
      "updating: image04.png (160 bytes security) (deflated 33%)\n",
      "updating: image05.png (160 bytes security) (deflated 25%)\n",
      "updating: image06.png (160 bytes security) (deflated 20%)\n",
      "updating: image07.png (160 bytes security) (deflated 23%)\n",
      "updating: image08.png (160 bytes security) (deflated 25%)\n",
      "updating: image09.png (160 bytes security) (deflated 25%)\n",
      "updating: image10.png (160 bytes security) (deflated 18%)\n",
      "updating: image11.png (160 bytes security) (deflated 20%)\n",
      "updating: image12.png (160 bytes security) (deflated 23%)\n",
      "updating: image13.png (160 bytes security) (deflated 27%)\n",
      "updating: image14.png (160 bytes security) (deflated 25%)\n",
      "updating: image15.png (160 bytes security) (deflated 25%)\n",
      "updating: image16.png (160 bytes security) (deflated 28%)\n",
      "updating: image17.png (160 bytes security) (deflated 30%)\n",
      "updating: image18.png (160 bytes security) (deflated 35%)\n",
      "updating: image19.png (160 bytes security) (deflated 33%)\n",
      "updating: image20.png (160 bytes security) (deflated 28%)\n",
      "updating: image21.png (160 bytes security) (deflated 24%)\n",
      "updating: image22.png (160 bytes security) (deflated 21%)\n",
      "updating: image23.png (160 bytes security) (deflated 19%)\n",
      "updating: image24.png (160 bytes security) (deflated 21%)\n",
      "updating: image25.png (160 bytes security) (deflated 26%)\n",
      "updating: image26.png (160 bytes security) (deflated 22%)\n",
      "updating: image27.png (160 bytes security) (deflated 26%)\n",
      "updating: image28.png (160 bytes security) (deflated 31%)\n",
      "updating: image29.png (160 bytes security) (deflated 37%)\n",
      "updating: image30.png (160 bytes security) (deflated 34%)\n",
      "updating: image31.png (160 bytes security) (deflated 34%)\n",
      "updating: image32.png (160 bytes security) (deflated 35%)\n",
      "updating: image33.png (160 bytes security) (deflated 33%)\n",
      "updating: image34.png (160 bytes security) (deflated 34%)\n",
      "updating: image35.png (160 bytes security) (deflated 29%)\n",
      "updating: image36.png (160 bytes security) (deflated 25%)\n",
      "updating: image37.png (160 bytes security) (deflated 26%)\n",
      "updating: image38.png (160 bytes security) (deflated 21%)\n",
      "updating: image39.png (160 bytes security) (deflated 19%)\n",
      "updating: image40.png (160 bytes security) (deflated 19%)\n",
      "updating: image41.png (160 bytes security) (deflated 19%)\n",
      "updating: image42.png (160 bytes security) (deflated 20%)\n",
      "updating: image43.png (160 bytes security) (deflated 18%)\n",
      "updating: image44.png (160 bytes security) (deflated 20%)\n",
      "updating: image45.png (160 bytes security) (deflated 18%)\n",
      "updating: image46.png (160 bytes security) (deflated 20%)\n",
      "updating: image47.png (160 bytes security) (deflated 19%)\n",
      "updating: image48.png (160 bytes security) (deflated 19%)\n",
      "updating: image49.png (160 bytes security) (deflated 19%)\n",
      "updating: image50.png (160 bytes security) (deflated 19%)\n",
      "updating: image51.png (160 bytes security) (deflated 22%)\n",
      "updating: image52.png (160 bytes security) (deflated 20%)\n",
      "updating: image53.png (160 bytes security) (deflated 21%)\n",
      "updating: image54.png (160 bytes security) (deflated 20%)\n",
      "updating: image55.png (160 bytes security) (deflated 26%)\n",
      "updating: image56.png (160 bytes security) (deflated 26%)\n",
      "updating: image57.png (160 bytes security) (deflated 25%)\n",
      "updating: image58.png (160 bytes security) (deflated 20%)\n",
      "updating: image59.png (160 bytes security) (deflated 18%)\n",
      "updating: image60.png (160 bytes security) (deflated 18%)\n",
      "updating: image61.png (160 bytes security) (deflated 19%)\n",
      "updating: image62.png (160 bytes security) (deflated 21%)\n",
      "updating: image63.png (160 bytes security) (deflated 22%)\n",
      "updating: image64.png (160 bytes security) (deflated 25%)\n",
      "updating: image65.png (160 bytes security) (deflated 30%)\n",
      "updating: image66.png (160 bytes security) (deflated 33%)\n",
      "updating: image67.png (160 bytes security) (deflated 35%)\n",
      "updating: image68.png (160 bytes security) (deflated 32%)\n",
      "updating: image69.png (160 bytes security) (deflated 31%)\n",
      "updating: image70.png (160 bytes security) (deflated 31%)\n",
      "updating: image71.png (160 bytes security) (deflated 26%)\n",
      "updating: image72.png (160 bytes security) (deflated 23%)\n",
      "updating: image73.png (160 bytes security) (deflated 23%)\n",
      "updating: image74.png (160 bytes security) (deflated 18%)\n",
      "updating: image75.png (160 bytes security) (deflated 17%)\n",
      "updating: image76.png (160 bytes security) (deflated 19%)\n",
      "updating: image77.png (160 bytes security) (deflated 17%)\n",
      "updating: image78.png (160 bytes security) (deflated 21%)\n",
      "updating: image79.png (160 bytes security) (deflated 20%)\n",
      "updating: image80.png (160 bytes security) (deflated 21%)\n",
      "updating: image81.png (160 bytes security) (deflated 21%)\n",
      "updating: image82.png (160 bytes security) (deflated 26%)\n",
      "updating: image83.png (160 bytes security) (deflated 26%)\n",
      "updating: image84.png (160 bytes security) (deflated 26%)\n",
      "updating: image85.png (160 bytes security) (deflated 25%)\n",
      "updating: image86.png (160 bytes security) (deflated 20%)\n",
      "updating: image87.png (160 bytes security) (deflated 19%)\n",
      "updating: image88.png (160 bytes security) (deflated 19%)\n",
      "updating: image89.png (160 bytes security) (deflated 19%)\n",
      "updating: image90.png (160 bytes security) (deflated 24%)\n",
      "updating: image91.png (160 bytes security) (deflated 24%)\n",
      "updating: image92.png (160 bytes security) (deflated 26%)\n",
      "updating: image93.png (160 bytes security) (deflated 30%)\n",
      "updating: image94.png (160 bytes security) (deflated 32%)\n",
      "updating: image95.png (160 bytes security) (deflated 35%)\n",
      "updating: image96.png (160 bytes security) (deflated 34%)\n",
      "updating: image97.png (160 bytes security) (deflated 36%)\n",
      "updating: image98.png (160 bytes security) (deflated 31%)\n",
      "updating: image99.png (160 bytes security) (deflated 28%)\n"
     ]
    }
   ],
   "source": [
    "!zip images.zip image*.png\n",
    "!rm image*.png"
   ]
  },
  {
   "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 we have coded with `slam`: the final position of the robot and the position of landmarks, created from only motion and measurement data!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Last pose:  [73.05 52.86]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x1440 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# define figure size\n",
    "plt.rcParams[\"figure.figsize\"] = (20, 20)\n",
    "\n",
    "# check if poses has been created\n",
    "if \"lastpose\" in locals():\n",
    "    # print out the last pose\n",
    "    print(\"Last pose: \", lastpose)\n",
    "    # display the last position of the robot *and* the landmark positions\n",
    "    display_world(int(world_size), lastpose, landmarks, save_file=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualize Omega and Xi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import data viz resources\n",
    "import matplotlib.pyplot as plt\n",
    "from pandas import DataFrame\n",
    "import seaborn as sns\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x2a4628c3b88>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x504 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# define figure size\n",
    "plt.rcParams[\"figure.figsize\"] = (12, 7)\n",
    "\n",
    "omega, xi = online_slam.get_omega_xi()\n",
    "\n",
    "# display omega\n",
    "sns.heatmap(DataFrame(omega), cmap=\"Blues\", annot=True, linewidths=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x2a46211fac8>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x504 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# define  figure size\n",
    "plt.rcParams[\"figure.figsize\"] = (3, 7)\n",
    "\n",
    "# display xi\n",
    "sns.heatmap(DataFrame(xi), cmap=\"Oranges\", annot=True, linewidths=0.5)"
   ]
  }
 ],
 "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.7.4"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}