EKF_v1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "-----\n",
    "\n",
    "In this assignment you will recursively estimate the position of a vehicle along a trajectory using available measurements and a motion model. \n",
    "\n",
    "The vehicle is equipped with a very simple type of LIDAR sensor, which returns range and bearing measurements corresponding to individual landmarks in the environment. The global positions of the landmarks are assumed to be known beforehand. We will also assume known data association, that is, which measurment belong to which landmark.\n",
    "\n",
    "## Motion and Measurement Models\n",
    "-----\n",
    "\n",
    "### Motion Model\n",
    "\n",
    "The vehicle motion model recieves linear and angular velocity odometry readings as inputs, and outputs the state (i.e., the 2D pose) of the vehicle:\n",
    "\n",
    "\\begin{align}\n",
    "\\mathbf{x}_{k} &= \\mathbf{x}_{k-1} + T\n",
    "\\begin{bmatrix}\n",
    "\\cos\\theta_{k-1} &0 \\\\\n",
    "\\sin\\theta_{k-1} &0 \\\\\n",
    "0 &1\n",
    "\\end{bmatrix}\n",
    "\\left(\n",
    "\\begin{bmatrix}\n",
    "v_k \\\\\n",
    "\\omega_k\n",
    "\\end{bmatrix}\n",
    "+ \\mathbf{w}_k\n",
    "\\right)\n",
    "\\, , \\, \\, \\, \\, \\, \\mathbf{w}_k = \\mathcal{N}\\left(\\mathbf{0}, \\mathbf{Q}\\right)\n",
    "\\end{align}\n",
    "\n",
    "- $\\mathbf{x}_k = \\left[ x \\, y \\, \\theta \\right]^T$ is the current 2D pose of the vehicle\n",
    "- $v_k$ and $\\omega_k$ are the linear and angular velocity odometry readings, which we use as inputs to the model\n",
    "\n",
    "The process noise $\\mathbf{w}_k$ has a (zero mean) normal distribution with a constant covariance $\\mathbf{Q}$.\n",
    "\n",
    "### Measurement Model\n",
    "\n",
    "The measurement model relates the current pose of the vehicle to the LIDAR range and bearing measurements $\\mathbf{y}^l_k = \\left[r \\, \\phi \\right]^T$.\n",
    "\n",
    "\\begin{align}\n",
    "\\mathbf{y}^l_k =\n",
    "\\begin{bmatrix}\n",
    "\\sqrt{(x_l - x_k - d\\cos\\theta_{k})^2 + (y_l - y_k - d\\sin\\theta_{k})^2} \\\\\n",
    "atan2\\left(y_l - y_k - d\\sin\\theta_{k},x_l - x_k - d\\cos\\theta_{k}\\right) - \\theta_k\n",
    "\\end{bmatrix}\n",
    "+\n",
    "\\mathbf{n}^l_k\n",
    "\\, , \\, \\, \\, \\, \\, \\mathbf{n}^l_k = \\mathcal{N}\\left(\\mathbf{0}, \\mathbf{R}\\right)\n",
    "\\end{align}\n",
    "\n",
    "- $x_l$ and $y_l$ are the ground truth coordinates of the landmark $l$\n",
    "- $x_k$ and $y_k$ and $\\theta_{k}$ represent the current pose of the vehicle\n",
    "- $d$ is the known distance between robot center and laser rangefinder (LIDAR)\n",
    "\n",
    "The landmark measurement noise $\\mathbf{n}^l_k$ has a (zero mean) normal distribution with a constant covariance $\\mathbf{R}$.\n",
    "\n",
    "## Getting Started\n",
    "-----\n",
    "\n",
    "Since the models above are nonlinear, we recommend using the extended Kalman filter (EKF) as the state estimator.\n",
    "Specifically, you will need to provide code implementing the following steps:\n",
    "- the prediction step, which uses odometry measurements and the motion model to produce a state and covariance estimate at a given timestep, and\n",
    "- the correction step, which uses the range and bearing measurements provided by the LIDAR to correct the pose and pose covariance estimates\n",
    "\n",
    "### Unpack the Data\n",
    "First, let's unpack the available data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sympy import *\n",
    "from math import cos,sin\n",
    "\n",
    "with open('data/data.pickle', 'rb') as f:\n",
    "    data = pickle.load(f)\n",
    "\n",
    "t = data['t']  # timestamps [s]\n",
    "\n",
    "x_init  = data['x_init'] # initial x position [m]\n",
    "y_init  = data['y_init'] # initial y position [m]\n",
    "th_init = data['th_init'] # initial theta position [rad]\n",
    "\n",
    "# input signal\n",
    "v  = data['v']  # translational velocity input [m/s]\n",
    "om = data['om']  # rotational velocity input [rad/s]\n",
    "\n",
    "# bearing and range measurements, LIDAR constants\n",
    "b = data['b']  # bearing to each landmarks center in the frame attached to the laser [rad]\n",
    "r = data['r']  # range measurements [m]\n",
    "l = data['l']  # x,y positions of landmarks [m]\n",
    "d = data['d']  # distance between robot center and laser rangefinder [m]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that distance from the LIDAR frame to the robot center is provided and loaded as an array into the `d` variable.\n",
    "\n",
    "### Ground Truth\n",
    "If available, it is useful to plot the ground truth position and orientation before starting the assignment.\n",
    "\n",
    "<table><tr>\n",
    "<td> <img src=\"data/gtruth.png\" alt=\"Ground Truth\" width=\"350\"/> </td>\n",
    "<td> <img src=\"data/gtruth2.png\" alt=\"Ground Truth\" width=\"350\"/> </td>\n",
    "</tr></table>\n",
    "\n",
    "Notice that the orientation values are wrapped to the $\\left[-\\pi,\\pi\\right]$ range in radians."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initializing Parameters\n",
    "\n",
    "Now that our data is loaded, we can begin getting things set up for our solver. One of the\n",
    "most important aspects of designing a filter is determining the input and measurement noise covariance matrices, as well as the initial state and covariance values. We set the values here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "v_var = 0.01  # translation velocity variance  \n",
    "om_var = 0.005  # rotational velocity variance \n",
    "r_var = 0.01  # range measurements variance\n",
    "b_var = 0.005  # bearing measurement variance\n",
    "\n",
    "Q_km = np.diag([v_var, om_var]) # input noise covariance \n",
    "cov_y = np.diag([r_var, b_var])  # measurement noise covariance \n",
    "\n",
    "x_est = np.zeros([len(v), 3])  # estimated states, x, y, and theta\n",
    "P_est = np.zeros([len(v), 3, 3])  # state covariance matrices\n",
    "\n",
    "x_est[0] = np.array([x_init, y_init, th_init]) # initial state\n",
    "P_est[0] = np.diag([1, 1, 0.1]) # initial state covariance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remember:** that it is neccessary to tune the measurement noise variances `r_var`, `b_var` in order for the filter to perform well!\n",
    "\n",
    "In order for the orientation estimates to coincide with the bearing measurements, it is also neccessary to wrap all estimated $\\theta$ values to the $(-\\pi , \\pi]$ range."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Wraps angle to (-pi,pi] range\n",
    "def wraptopi(x):\n",
    "    if x > np.pi:\n",
    "        x = x - (np.floor(x / (2 * np.pi)) + 1) * 2 * np.pi\n",
    "    elif x < -np.pi:\n",
    "        x = x + (np.floor(x / (-2 * np.pi)) + 1) * 2 * np.pi\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.1, 0. ],\n",
       "       [0. , 0.1]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cov_y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEgAAAAVCAYAAADl/ahuAAAABHNCSVQICAgIfAhkiAAAAlpJREFUWIXt2MtvTVEUBvCfEqlUUq9QJkTEIyGeaTrwGHhOTPgHJGJoIiZiwIR4jBkYiTFBDCQVkQhCJCoiTHQgTRCPUgZFUIN1yslpz+09p729Df2Sm32z9l5rfXvdtdbe+zKOUriAt2iqN5FRwFr0YW+1CuvwCwcy8pO4iS70ohsdOIKZI8F0BFGU62W8xtTsxIRBFrejFXMT4/34jkd45m92tYmAvkq+d5XZTQ1QlGsrHuAwjlcyvFhkz7lB5hpzdI6JFD1bNf3aowzX53iJiZUMn0gMbC5AZmWic6OATr1QieuRZG57WtiQWbQFP3G/gNOdyfikgE69UInr3WTcmhame1ATekSqrajg5KBoZs2iptcnDrfgXWHKtUURrs34hIeiJw3AYpFi7UM4fZOs6/9cx5xS9GuPolx7E50/SJdY//H3cQinLSLzWrALC8URuqZa1qOIoly7MSvP2CoR5asFSczHNzwtqFcPDMW1G1/ylOeJAN0p4bgj0c2N/hhCHtcGccXpzAr78Vo0riUlnM5Lxp8ldEcbeVyXiHJ8nBamA9SH2yKyizLKS0UdZ9EgLl+zcc/A/nU+sbunGuYjhLJc25LxVlo4KbPoEnaLy9KLlHwHTosAduKDOA02icb3BvtySMGPvN3UAGW5bhNZVbEHT04MPMjIl+OMSL/3YsM94s5wFDNy7HXgM6ZX3NLIogzXZnHEX6nGwSFRFquHSXSa+EVODdPOaGC/2POGahY3ikfbtWE63YmvBu8HYwlTxAv/YhGljeLx9j/8YbZMlN6C+tIYx7+J39odm8PeUogfAAAAAElFTkSuQmCC\n",
      "text/latex": [
       "$$\\left ( 3, \\quad 3\\right )$$"
      ],
      "text/plain": [
       "(3, 3)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#from sympy import diff, symbols\n",
    "from sympy import *\n",
    "init_printing(use_unicode=True)\n",
    "x, y, z =symbols('x y z')\n",
    "f= x*cos(y)\n",
    "f_dash=diff(f,y)\n",
    "f_dash\n",
    "\n",
    "P_est[0,:,:].shape\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Correction Step\n",
    "-----\n",
    "First, let's implement the measurement update function, which takes an available landmark measurement $l$ and updates the current state estimate $\\mathbf{\\check{x}}_k$.\n",
    "For each landmark measurement received at a given timestep $k$, you should implement the following steps:\n",
    "\n",
    "- Compute the measurement model Jacobians at $\\mathbf{\\check{x}}_{k}$\n",
    "\\begin{align}\n",
    "\\mathbf{y}^l_k = &\\mathbf{h}(\\mathbf{x}_{k}, \\mathbf{n}^l_k) \\\\\\\\\n",
    "\\mathbf{H}_{k} = \\frac{\\partial \\mathbf{h}}{\\partial \\mathbf{x}_{k}}\\bigg|_{\\mathbf{\\check{x}}_{k},0}& \\, , \\, \\, \\, \\,\n",
    "\\mathbf{M}_{k} = \\frac{\\partial \\mathbf{h}}{\\partial \\mathbf{n}_{k}}\\bigg|_{\\mathbf{\\check{x}}_{k},0} \\, .\n",
    "\\end{align}\n",
    "- Compute the Kalman Gain\n",
    "\\begin{align}\n",
    "\\mathbf{K}_k &= \\mathbf{\\check{P}}_k \\mathbf{H}_k^T \\left(\\mathbf{H}_k \\mathbf{\\check{P}}_k \\mathbf{H}_k^T + \\mathbf{M}_k \\mathbf{R}_k \\mathbf{M}_k^T \\right)^{-1} \n",
    "\\end{align}\n",
    "- Correct the predicted state\n",
    "\\begin{align}\n",
    "\\mathbf{\\check{y}}^l_k &= \\mathbf{h}\\left(\\mathbf{\\check{x}}_k, \\mathbf{0}\\right) \\\\\n",
    "\\mathbf{\\hat{x}}_k &= \\mathbf{\\check{x}}_k + \\mathbf{K}_k \\left(\\mathbf{y}^l_k - \\mathbf{\\check{y}}^l_k\\right)\n",
    "\\end{align}\n",
    "- Correct the covariance\n",
    "\\begin{align}\n",
    "\\mathbf{\\hat{P}}_k &= \\left(\\mathbf{I} - \\mathbf{K}_k \\mathbf{H}_k \\right)\\mathbf{\\check{P}}_k\n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def measurement_update(lk, rk, bk, P_check, x_check,k):\n",
    "    #from sympy import *\n",
    "    #xl, yl, xk, yk, theta_k = symbols('xl yl xk yk theta_k')\n",
    "    from math import atan2,sin,cos\n",
    "    xl, yl = lk\n",
    "    #print(x_check.shape)\n",
    "    xk, yk, theta_k = x_check\n",
    "    D = d[0]\n",
    "    theta_k = wraptopi(theta_k)\n",
    "    #print(x_check)\n",
    "#   print(k)\n",
    "    del_x = xl-xk-D*cos(theta_k)\n",
    "    del_y = yl-yk-D*sin(theta_k)\n",
    "     \n",
    "    y_lk = np.array([[rk],[bk]])\n",
    "    \n",
    "    # 1. Compute measurement Jacobian\n",
    "    \n",
    "    root_q = ((del_x)**2 + (del_y)**2)**0.5\n",
    "    q = (del_x)**2 + (del_y)**2\n",
    "    phi = atan2(del_y,del_x)-theta_k\n",
    "    \n",
    "    H_k = np.array([[-root_q*del_x/q, -root_q*del_y/q, D*(del_x*sin(theta_k) - del_y*cos(theta_k))/root_q],\n",
    "                    [ del_y/q, -del_x/q, -1-D*(del_y*sin(theta_k) + del_x*cos(theta_k))/1]])\n",
    "    \n",
    "#     H_k[0][0] = -root_q*del_x/q\n",
    "#     H_k[0][1] = -root_q*del_y/q\n",
    "#     H_k[0][2] = D*(del_x*sin(theta_k) - del_y*cos(theta_k))/root_q\n",
    "#     H_k[1][0] = del_y/q\n",
    "#     H_k[1][1] = -del_x/q\n",
    "#     H_k[1][2] = -1-D*(del_y*sin(theta_k) + del_x*cos(theta_k))/1\n",
    "    \n",
    "    # 2. Compute Kalman Gain\n",
    "    \n",
    "    G = np.dot(np.dot(H_k,P_check), H_k.T) + cov_y\n",
    "    G_inv = np.linalg.inv(G)\n",
    "    K_k = np.dot(np.dot(P_check, H_k.T), G_inv)\n",
    "    \n",
    "    # 3. Correct predicted state (remember to wrap the angles to [-pi,pi])\n",
    "    \n",
    "    y_lk_cap = np.array([[root_q],[wraptopi(phi)]])\n",
    "    delta = y_lk-y_lk_cap\n",
    "    x_check = x_check + (np.dot(K_k, delta)).reshape(3)\n",
    "    x_check[2]= wraptopi(x_check[2])\n",
    "    #print(x_check)\n",
    "    # 4. Correct covariance\n",
    "    \n",
    "    I = np.identity(3)\n",
    "    P_check = np.dot((I-np.dot(K_k,H_k)),P_check)\n",
    "\n",
    "    return x_check, P_check\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prediction Step\n",
    "-----\n",
    "Now, implement the main filter loop, defining the prediction step of the EKF using the motion model provided:\n",
    "\n",
    "\\begin{align}\n",
    "\\mathbf{\\check{x}}_k &= \\mathbf{f}\\left(\\mathbf{\\hat{x}}_{k-1}, \\mathbf{u}_{k-1}, \\mathbf{0} \\right) \\\\\n",
    "\\mathbf{\\check{P}}_k &= \\mathbf{F}_{k-1}\\mathbf{\\hat{P}}_{k-1}\\mathbf{F}_{k-1}^T + \\mathbf{L}_{k-1}\\mathbf{Q}_{k-1}\\mathbf{L}_{k-1}^T \\, .\n",
    "\\end{align}\n",
    "\n",
    "Where\n",
    "\n",
    "\\begin{align}\n",
    "\\mathbf{F}_{k-1} = \\frac{\\partial \\mathbf{f}}{\\partial \\mathbf{x}_{k-1}}\\bigg|_{\\mathbf{\\hat{x}}_{k-1},\\mathbf{u}_{k},0}  \\, , \\, \\, \\, \\,\n",
    "\\mathbf{L}_{k-1} = \\frac{\\partial \\mathbf{f}}{\\partial \\mathbf{w}_{k}}\\bigg|_{\\mathbf{\\hat{x}}_{k-1},\\mathbf{u}_{k},0} \\, .\n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### 5. Main Filter Loop #######################################################################\n",
    "for k in range(1, len(t)):  # start at 1 because we've set the initial prediciton\n",
    "\n",
    "    delta_t = t[k] - t[k - 1]  # time step (difference between timestamps)\n",
    "\n",
    "    # 1. Update state with odometry readings (remember to wrap the angles to [-pi,pi])\n",
    "    x_check = np.zeros(3)\n",
    "    \n",
    "    th = wraptopi(x_est[k-1,2])\n",
    "    state = delta_t*np.array([v[k]*cos(th),v[k]*sin(th),om[k]])\n",
    "    x_check = x_est[k-1] + state\n",
    "#     print(x_check)\n",
    "    # 2. Motion model jacobian with respect to last state\n",
    "    \n",
    "    F_km = np.zeros([3, 3])\n",
    "    F_km = np.array([[1,0, -v[k]*sin(th)], [0,1,v[k]*cos(th)], [0,0,1]])\n",
    "\n",
    "    # 3. Motion model jacobian with respect to noise\n",
    "    \n",
    "    L_km = np.zeros([3, 2])\n",
    "    L_km = np.array([[cos(th),0],[sin(th),0],[0,1]])\n",
    "    \n",
    "    # 4. Propagate uncertainty\n",
    "    \n",
    "    P_check = np.dot(np.dot(F_km,P_est[0]),F_km.T) + L_km @ Q_km @ L_km.T\n",
    "#     print(x_check)\n",
    "    # 5. Update state estimate using available landmark measurements\n",
    "    for i in range(len(r[k])):\n",
    "        x_check, P_check = measurement_update(l[i], r[k, i], b[k, i], P_check, x_check,k)\n",
    "    # Set final state predictions for timestep\n",
    "    x_est[k, 0] = x_check[0]\n",
    "    x_est[k, 1] = x_check[1]\n",
    "    x_est[k, 2] = wraptopi(x_check[2])\n",
    "    P_est[k, :, :] = P_check"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's plot the resulting state estimates:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "e_fig = plt.figure()\n",
    "ax = e_fig.add_subplot(111)\n",
    "ax.plot(x_est[:, 0], x_est[:, 1])\n",
    "ax.set_xlabel('x [m]')\n",
    "ax.set_ylabel('y [m]')\n",
    "ax.set_title('Estimated trajectory')\n",
    "plt.show()\n",
    "\n",
    "e_fig = plt.figure()\n",
    "ax = e_fig.add_subplot(111)\n",
    "ax.plot(t[:], x_est[:, 2])\n",
    "ax.set_xlabel('Time [s]')\n",
    "ax.set_ylabel('theta [rad]')\n",
    "ax.set_title('Estimated trajectory')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Are you satisfied wth your results? The resulting trajectory should closely resemble the ground truth, with minor \"jumps\" in the orientation estimate due to angle wrapping. If this is the case, run the code below to produce your solution file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('submission.pkl', 'wb') as f:\n",
    "    pickle.dump(x_est, f, pickle.HIGHEST_PROTOCOL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}