moving_and_sensing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "### Uncertainty\n",
    "Robot motion and sensors have some uncertainty associated with them. For example, imagine a car driving up hill and down hill; the speedometer reading will likely overestimate the speed of the car going up hill and underestimate the speed of the car going down hill because it cannot perfectly account for gravity. Similarly, we cannot perfectly predict the *motion* of a robot. A robot is likely to slightly overshoot or undershoot a target location.\n",
    "\n",
    "---\n",
    "\n",
    "You can see that the robot class initializes the robot's position and adds measures of uncertainty for motion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import some resources\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "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",
    "    def sense(self):\n",
    "        ''' This function does not take in any parameters, instead it references internal variables\n",
    "            (such as self.landmarks) to measure the distance between the robot and any landmarks\n",
    "            that the robot can see (that are within its measurement range).\n",
    "            This function returns a list of landmark indices, and the measured distances (dx, dy)\n",
    "            between the robot's position and said landmarks.\n",
    "            This function should account for measurement_noise and measurement_range.\n",
    "            One item in the returned list should be in the form: [landmark_index, dx, dy].\n",
    "            '''\n",
    "           \n",
    "        measurements = []\n",
    "        \n",
    "        ## TODO: For each landmark\n",
    "        ## 1. compute dx and dy, the distances between the robot and the landmark\n",
    "        ## 2. account for measurement noise by adding a noise component to dx and dy\n",
    "        \n",
    "        ## TODO: return the final, complete list of measurements\n",
    "        for i, landmark in enumerate(self.landmarks):\n",
    "            dx = landmark[0] - self.x + self.rand() * self.measurement_noise\n",
    "            dy = landmark[1] - self.y + self.rand() * self.measurement_noise\n",
    "            # checking if measurement in range\n",
    "            if abs(dx) <= self.measurement_range and abs(dy) <= self.measurement_range:\n",
    "                measurements.append([i,dx,dy])\n",
    "        return measurements\n",
    "\n",
    "    \n",
    "    # --------\n",
    "    # make_landmarks: \n",
    "    # make random landmarks located in the world\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",
   "metadata": {},
   "source": [
    "## Defining a world and a robot\n",
    "\n",
    "Instantiate a robot object. As you can see in `__init__` above, the robot class takes in a number of parameters including a world size and some values that indicate the sensing and movement capabilities of the robot.\n",
    "\n",
    "In the next example, we define a small 10x10 square world, a measurement range that is half that of the world and small values for motion and measurement noise. These values will typically be about 10 times larger, but we just want to demonstrate this behavior on a small scale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Robot: [x=5.00000 y=5.00000]\n"
     ]
    }
   ],
   "source": [
    "#Fiddle around with these values\n",
    "world_size         = 10.0    # size of world (square)\n",
    "measurement_range  = 5.0     # range at which we can sense landmarks\n",
    "motion_noise       = 0.2      # noise in robot motion\n",
    "measurement_noise  = 0.2      # noise in the measurements\n",
    "\n",
    "# instantiate a robot, r\n",
    "r = robot(world_size, measurement_range, motion_noise, measurement_noise)\n",
    "\n",
    "# print out the location of r\n",
    "print(r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualizing the World\n",
    "\n",
    "In the given example, we can see/print out that the robot is in the middle of the 10x10 world at (x, y) = (5.0, 5.0).\n",
    "\n",
    "In the next cell a helper visualization function is provided: `display_world`, that will display a grid world in a plot and draw a red `o` at the location of our robot, `r`. The details of how this function wors can be found in the `helpers.py` file in the home directory.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Robot: [x=5.00000 y=5.00000]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# import helper function\n",
    "from helpers import display_world\n",
    "\n",
    "# define figure size\n",
    "plt.rcParams[\"figure.figsize\"] = (5,5)\n",
    "\n",
    "# call display_world and display the robot in it's grid world\n",
    "print(r)\n",
    "display_world(int(world_size), [r.x, r.y])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Movement\n",
    "\n",
    "Let's call the robot's `move` function. We'll ask it to move some distance `(dx, dy)` and we'll see that this motion is not perfect by the placement of our robot `o` and by the printed out position of `r`. \n",
    "\n",
    "Try changing the values of `dx` and `dy` and/or running this cell multiple times; see how the robot moves and how the uncertainty in robot motion accumulates over multiple movements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Robot: [x=5.94420 y=6.98515]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# choose values of dx and dy (negative works, too)\n",
    "dx = 1\n",
    "dy = 2\n",
    "r.move(dx, dy)\n",
    "\n",
    "# print out the exact location\n",
    "print(r)\n",
    "\n",
    "# display the world after movement, not that this is the same call as before\n",
    "# the robot tracks its own movement\n",
    "display_world(int(world_size), [r.x, r.y])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Landmarks\n",
    "\n",
    "Next, let's create landmarks, which are measurable features in the map. You can think of landmarks as things like notable buildings, or something smaller such as a tree, rock, or other feature.\n",
    "\n",
    "The robot class has a function `make_landmarks` which randomly generates locations for the number of specified landmarks. Try changing `num_landmarks` or running this cell multiple times to see where these landmarks appear. We have to pass these locations as a third argument to the `display_world` function and the list of landmark locations is accessed similar to how we find the robot position `r.landmarks`. \n",
    "\n",
    "Each landmark is displayed as a purple `x` in the grid world, and we also print out the exact `[x, y]` locations of these landmarks at the end of this cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Robot: [x=5.94420 y=6.98515]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Landmark locations [x,y]:  [[3, 10], [0, 1], [6, 1]]\n"
     ]
    }
   ],
   "source": [
    "# create any number of landmarks\n",
    "num_landmarks = 3\n",
    "r.make_landmarks(num_landmarks)\n",
    "\n",
    "# print out our robot's exact location\n",
    "print(r)\n",
    "\n",
    "# display the world including these landmarks\n",
    "display_world(int(world_size), [r.x, r.y], r.landmarks)\n",
    "\n",
    "# print the locations of the landmarks\n",
    "print('Landmark locations [x,y]: ', r.landmarks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sense\n",
    "\n",
    "Once we have some landmarks to sense, we need to be able to tell our robot to *try* to sense how far they are away from it.\n",
    "The `sense` function uses only internal class parameters and returns a list of the the measured/sensed x and y distances to the landmarks it senses within the specified `measurement_range`. \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0, -3.010854856102781, 2.904602012303169]]\n"
     ]
    }
   ],
   "source": [
    "# try to sense any surrounding landmarks\n",
    "measurements = r.sense()\n",
    "\n",
    "# this will print out an empty list if `sense` has not been implemented\n",
    "print(measurements)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Data\n",
    "\n",
    "#### Putting it all together\n",
    "\n",
    "To perform SLAM, we'll collect a series of robot sensor measurements and motions, in that order, over a defined period of time. Then we'll use only this data to re-construct the map of the world with the robot and landmar locations. \n",
    "\n",
    "In the next notebook, you'll see this list of movements and measurements listed in a structure called `data`. This is an array that holds sensor measurements and movements in a specific order, which will be useful to call upon when you have to extract this data and form constraint matrices and vectors.\n",
    "\n",
    "`data` is constructed over a series of time steps as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[[0, -3.010854856102781, 2.904602012303169]], [1, 2]]]\n"
     ]
    }
   ],
   "source": [
    "data = []\n",
    "\n",
    "# after a robot first senses, then moves (one time step)\n",
    "# that data is appended like so:\n",
    "data.append([measurements, [dx, dy]])\n",
    "\n",
    "# for our example movement and measurement\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Measurements:  [[0, -3.010854856102781, 2.904602012303169]]\n",
      "Motion:  [1, 2]\n"
     ]
    }
   ],
   "source": [
    "# in this example, we have only created one time step (0)\n",
    "time_step = 0\n",
    "\n",
    "# so you can access robot measurements:\n",
    "print('Measurements: ', data[time_step][0])\n",
    "\n",
    "# and its motion for a given time step:\n",
    "print('Motion: ', data[time_step][1])"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}