A tutorial on path optimization for self-driving cars.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Introduction - Cubic spiral path optimization\n",
    "\n",
    "*Disclaimer: Although I am an engineer in the self-driving space, this work was done between jobs. I do not claim that any company I have worked for uses the techniques described in this post, and everything described within is public knowledge. I have done my best to avoid technical errors, but please reach out if you spot any mistakes!*\n",
    "\n",
    "\n",
    "I wrote this notebook to help me understand the path segment generation described in McNaughton 2011 [1] (though it was originally described in [2]). This paper presents a real-time motion planner with several ideas that have been influential in the self-driving space. A key part of the described approach is to be able to generate smooth segments between points in a \"state lattice\". These segments can be connected to each other to form a full path for the vehicle to follow. These paths are later augmented with a velocity profile and re-planned at 10 Hz.\n",
    "\n",
    "<div>\n",
    "<img src=\"https://raw.githubusercontent.com/markmliu/path_opt/main/img/path_generation.png\"/ width=500>\n",
    "</div>\n",
    "<center><i>Generating smooth paths from initial pose to different future poses</i></center>\n",
    "\n",
    "\n",
    "In this notebook, we follow the paper and parameterize these path segments as \"cubic polynomial spirals\" and use optimization to find the correct parameters of the spiral. You may enjoy reading this if you are interested in planning for autonomous vehicles but find reading the relevant papers too technical - I try to go through this approach without requiring much more background than vector calculus.  I'll switch between plain english, code, and excerpts from the paper to facilitate ease of understanding. Most of the diagrams/equations are from the paper itself. On the coding side, I used `sympy` to do symbolic math and numpy for numerical math. This was my first time using `sympy`, so apologies for the clumsy code.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Definitions\n",
    "\n",
    "I will give some \"working\" definitions for concepts that are necessary for the rest of the post (more rigorous definitions can be found in the paper).\n",
    "\n",
    "### Pose\n",
    "We can think of a \"pose\" as an augmented position of our vehicle. We say augmented because we may also care about other information, such as our heading ($\\theta$), the direction of travel and curvature ($\\kappa$), the derivative of heading. For our purposes, a pose is represented as the tuple ($x,y, \\theta, \\kappa$)\n",
    "\n",
    "\n",
    "### Travel\n",
    "Travel ($s$) with respect to two points on a curve refers to distance you would travel to get between them going along the curve (as opposed to the euclidian distance between them). \n",
    "\n",
    "\n",
    "### Cubic polynomial spiral\n",
    "A cubic spiral is a curve whose curvature ($\\kappa$) is a cubic polynomial function of travel ($s$). If this definition isn't intuitively clear to you, it may help to imagine plotting the curve by taking very small steps along the current heading, recalculating the curvature at the new travel, updating the heading and repeating (in fact, we will do this later in the post to visualize the spirals we are generating). Here's the formal definition:\n",
    "\n",
    "$ \\kappa(s) = \\kappa_{0} + \\kappa_1 s + \\kappa_2 s^2 + \\kappa_3 s^3$\n",
    "\n",
    "A couple of important notes here:\n",
    "1. There are actually five parameters for the cubic spiral - each $\\kappa_i$ as well as an implicit $s_G$ which represents the \"final\" travel where the curve ends. If we didn't have an $s_G$ the curve would never end and we could not connect it to an endpoint. \n",
    "\n",
    "2. There is exactly one cubic polynomial spiral which will connect any two poses as defined here. This is important because we know that once we find *a* solution, we have found *the* solution.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's hop into code for a bit - I'm going to encode the cubic spiral definition above by definining curvature in terms of the $\\kappa_{0..3}$ (that we'll rename to $a,b,c,d$) and $s$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import *\n",
    "import numpy\n",
    "\n",
    "# a,b,c,d are the coefficients of the cubic polynomial, s is the variable that represents travel along the spiral.\n",
    "a,b,c,d, s = symbols(\"a b c d s\")\n",
    "kappa = a + b*s + c*s**2 + d*s**3\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Optimization of the parameters\n",
    "\n",
    "So here's our problem setup: We have two poses and we need to connect them with some cubic spiral, but we need to find the parameters $\\kappa_{0..3}$ which correctly connect the two. Formulated as an optimization problem, we need to *minimize the error between the intended poses and the actual poses*. By shifting and rotating our coordinate system, we can assume that the position and heading of our starting pose are 0, but not the curvature. However, note that the curvature at the initial pose is exactly equal to $\\kappa_0$ so we only need to think about minimizing the error in the end pose. More formally, our optimization function looks something like this:\n",
    "\n",
    "$$\n",
    "\\min d(q_p, q_G)\n",
    "$$\n",
    "\n",
    "where $q_p$is the end pose implied by our chosen parameters, $q_G$ is the desired end pose, and $d$ is some distance function between poses (say L2 norm). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reparameterization for numerical stability\n",
    "\n",
    "Now, at a high level we are going to use numerical optimization to solve for $a,b,c,d$. But the paper notes that when using optimization, you really want to have the variables you're solving for be close in order of magnitude (otherwise, your optimization can fail due to numerical instability). As written, there's no reason that $a,b,c,d$ would be similar orders of magnitude. For example, $a$ could be 0.01 while $b$ could be 1000. So instead of trying to solve directly for them, we use a neat trick - we reparameterize the problem. We introduce four new variables $p_0,..,p_3$ and set them equal to the curvature at $s=0, 1/3* s_G, 2/3*s_G, s_G$ (four evenly spaced points between the starting and final travel, inclusive).\n",
    "\n",
    "Because the curvature is bounded by the steering limits of the vehicle, this should, in practice, keep our $p0,..,p3$ relatively close together. Once we've solved for $p0,..,p3$, we can substitute back and find the values for $a,b,c,d$, according to the paper:\n",
    "\n",
    "<div>\n",
    "<img src=\"https://raw.githubusercontent.com/markmliu/path_opt/main/img/reparam_1.png\" width=500>\n",
    "<img src=\"https://raw.githubusercontent.com/markmliu/path_opt/main/img/reparam_2.png\" width=500>\n",
    "</div>\n",
    "\n",
    "But we don't have to take their word for it! Let's check the math using `sympy` below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "p0, p1, p2, p3, sG = symbols(\"p0 p1 p2 p3 sG\")\n",
    "\n",
    "# Sympy \"solve\" assumes the expressions passed in are equal to 0, so for example eq1 means\n",
    "# kappa(0) = p0 and eq1 means kappa(s_G/3) = p1\n",
    "eq1 = kappa.subs(s,0) - p0\n",
    "eq2 = kappa.subs(s, sG/3) - p1\n",
    "eq3 = kappa.subs(s, 2*sG/3) - p2\n",
    "eq4 = kappa.subs(s, sG) - p3\n",
    "sol = solve([eq1, eq2, eq3, eq4], {a, b, c, d})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{a: p0,\n",
       " b: (-11*p0 + 18*p1 - 9*p2 + 2*p3)/(2*sG),\n",
       " c: (18*p0 - 45*p1 + 36*p2 - 9*p3)/(2*sG**2),\n",
       " d: (-9*p0 + 27*p1 - 27*p2 + 9*p3)/(2*sG**3)}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sol # these should match up with the formulas derived in the paper (3.26-3.29)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So we can confirm the expressions given in the paper, and this gives us a way to convert solutions for $p_0,..,p_3$ back into solutions for $a,b,c,d$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = sol[a]\n",
    "b = sol[b]\n",
    "c = sol[c]\n",
    "d = sol[d]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Shooting method for optimization\n",
    "\n",
    "Okay, so let's remember our goal: Given an end pose, we need to find the parameters $p_0,.,p3$ which will connect our cubic spline to it. As we mentioned before, the paper uses the \"shooting method\" to find the right parameters. So what's that?\n",
    "\n",
    "At a high level, the shooting method works by:\n",
    "\n",
    "1. Using your best guess parameters, \"shoot\" and see where your trajectory lands.\n",
    "2. Compare your landing point with where you intended to be.\n",
    "3. Update your guessed parameters to reduce the landing error (will elaborate more on this later)\n",
    "4. Return to step 1 until \"convergence\"\n",
    "\n",
    "In order to do this, we need to be able to do two things:\n",
    "\n",
    "**1. Determine where a trajectory will land, given the parameters (for step 1 above)**\n",
    "\n",
    "**2. Relate the error in final pose to the error in chosen parameters (for step 3 above)**\n",
    "\n",
    "Let's focus on the first one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Computing the end configuration from given parameters\n",
    "\n",
    "Now let's look at how we can use the $p_i$ parameters to compute the configuration (and not just the curvature) at any travel (including the final travel, $s_G$. The paper notes that we can assume our starting point is at $[0,0,0, \\kappa_I]$, and provides some equations that give us the different components of our pose (as a function of our parameters and $s$):\n",
    "\n",
    "<div>\n",
    "<img src=\"https://raw.githubusercontent.com/markmliu/path_opt/main/img/pose_as_fn_of_s.png\" width=500>\n",
    "</div>\n",
    "\n",
    "That's a lot of symbols - let's start with the easy ones. The equation for curvature $\\kappa(s)$ is exactly the same as the definiton of the cubic spiral, and the heading $\\theta(s)$ can be computed as the integral (using simple polynomial integral terms). Let's save these in `sympy` now as well.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# if a,b,c,d are known, easy to compute theta(s) or kappa(s)\n",
    "theta = a*s + b*s**2/2 + c*s**3/3 + d*s**4/4\n",
    "kappa = a + b*s + c*s**2 + d*s**3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll note that $\\theta$ is a function of $a,b,c,d$, which can themselves be thought of in terms of $p0,..,p1$ (recall our earlier reparameterization)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle p_{0} s + \\frac{s^{4} \\left(- 9 p_{0} + 27 p_{1} - 27 p_{2} + 9 p_{3}\\right)}{8 sG^{3}} + \\frac{s^{3} \\cdot \\left(18 p_{0} - 45 p_{1} + 36 p_{2} - 9 p_{3}\\right)}{6 sG^{2}} + \\frac{s^{2} \\left(- 11 p_{0} + 18 p_{1} - 9 p_{2} + 2 p_{3}\\right)}{4 sG}$"
      ],
      "text/plain": [
       "p0*s + s**4*(-9*p0 + 27*p1 - 27*p2 + 9*p3)/(8*sG**3) + s**3*(18*p0 - 45*p1 + 36*p2 - 9*p3)/(6*sG**2) + s**2*(-11*p0 + 18*p1 - 9*p2 + 2*p3)/(4*sG)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "theta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also note that with `sympy`, we can easily take the analytical derivative of $\\theta$ with respect to any of the different params (i.e $s_G$ or $p_1$) - this will be useful later\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{3 s^{4} \\left(- 9 p_{0} + 27 p_{1} - 27 p_{2} + 9 p_{3}\\right)}{8 sG^{4}} - \\frac{s^{3} \\cdot \\left(18 p_{0} - 45 p_{1} + 36 p_{2} - 9 p_{3}\\right)}{3 sG^{3}} - \\frac{s^{2} \\left(- 11 p_{0} + 18 p_{1} - 9 p_{2} + 2 p_{3}\\right)}{4 sG^{2}}$"
      ],
      "text/plain": [
       "-3*s**4*(-9*p0 + 27*p1 - 27*p2 + 9*p3)/(8*sG**4) - s**3*(18*p0 - 45*p1 + 36*p2 - 9*p3)/(3*sG**3) - s**2*(-11*p0 + 18*p1 - 9*p2 + 2*p3)/(4*sG**2)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(theta, sG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now what about $x(s)$ and $y(s)$? While $\\kappa(s)$ and $\\theta(s)$ were relatively straightforward polynominals, $x$ and $y$ contain definite integrals in them. Can we use `sympy` to analytically compute these integrals as well?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try it for yourself if you want!\n",
    "# x = integrate(cos(theta),(s,0,s)) will crash sympy..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unfortunately, trying to compute the integral as written will actually cause `sympy` to crash. There is a good reason for this - the paper notes that these integrals are special case of the generalized Fresnel integrals and have no closed form solution. Instead, they note that these integrals can be approximated with the \"composite Simpson's rule\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div>\n",
    "<img src=\"https://raw.githubusercontent.com/markmliu/path_opt/main/img/composite_simpson.png\" width=500>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's encode this composite simpson's rule in python, so we can call it instead of taking an integral for $x,y$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# returns the symbolic derivative of the composite simpson intergral of f (from 0 to sG)\n",
    "# n is the number of parts to break it into, must be even.\n",
    "def composite_simpson(f, sG, n=8):\n",
    "    \"\"\"returns the symbolic derivative of the composite simpson intergral of f (from 0 to sG).\n",
    "       \n",
    "       n is the number of parts to break it into, must be even.\"\"\"\n",
    "    h = (sG)/n\n",
    "    \n",
    "    exp = f.subs(s,0)\n",
    "    for j in range(1, int(n/2)):\n",
    "        exp += 2 * f.subs(s,2*j*sG/n)\n",
    "        \n",
    "    for j in range(1, int(n/2)+1):\n",
    "        exp += 4 * (f.subs(s,(2*j-1)*sG/n))\n",
    "    \n",
    "    exp += f.subs(s,sG)\n",
    "        \n",
    "    exp *= (h/3.0)    \n",
    "    return exp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay, now we can write down $x_{s_G}$ and $y_{s_G}$ in the form specified in (3.42) using composite simpson method instead, which can actually be computed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "x_sG = composite_simpson(cos(theta), sG)\n",
    "y_sG = composite_simpson(sin(theta), sG)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.0416666666666667 sG \\left(4 \\cos{\\left(\\frac{p_{0} sG}{8} + \\frac{sG \\left(- 11 p_{0} + 18 p_{1} - 9 p_{2} + 2 p_{3}\\right)}{256} + \\frac{sG \\left(- 9 p_{0} + 27 p_{1} - 27 p_{2} + 9 p_{3}\\right)}{32768} + \\frac{sG \\left(18 p_{0} - 45 p_{1} + 36 p_{2} - 9 p_{3}\\right)}{3072} \\right)} + 2 \\cos{\\left(\\frac{p_{0} sG}{4} + \\frac{sG \\left(- 11 p_{0} + 18 p_{1} - 9 p_{2} + 2 p_{3}\\right)}{64} + \\frac{sG \\left(- 9 p_{0} + 27 p_{1} - 27 p_{2} + 9 p_{3}\\right)}{2048} + \\frac{sG \\left(18 p_{0} - 45 p_{1} + 36 p_{2} - 9 p_{3}\\right)}{384} \\right)} + 4 \\cos{\\left(\\frac{3 p_{0} sG}{8} + \\frac{9 sG \\left(- 11 p_{0} + 18 p_{1} - 9 p_{2} + 2 p_{3}\\right)}{256} + \\frac{81 sG \\left(- 9 p_{0} + 27 p_{1} - 27 p_{2} + 9 p_{3}\\right)}{32768} + \\frac{9 sG \\left(18 p_{0} - 45 p_{1} + 36 p_{2} - 9 p_{3}\\right)}{1024} \\right)} + 2 \\cos{\\left(\\frac{p_{0} sG}{2} + \\frac{sG \\left(- 11 p_{0} + 18 p_{1} - 9 p_{2} + 2 p_{3}\\right)}{16} + \\frac{sG \\left(- 9 p_{0} + 27 p_{1} - 27 p_{2} + 9 p_{3}\\right)}{128} + \\frac{sG \\left(18 p_{0} - 45 p_{1} + 36 p_{2} - 9 p_{3}\\right)}{48} \\right)} + 4 \\cos{\\left(\\frac{5 p_{0} sG}{8} + \\frac{25 sG \\left(- 11 p_{0} + 18 p_{1} - 9 p_{2} + 2 p_{3}\\right)}{256} + \\frac{625 sG \\left(- 9 p_{0} + 27 p_{1} - 27 p_{2} + 9 p_{3}\\right)}{32768} + \\frac{125 sG \\left(18 p_{0} - 45 p_{1} + 36 p_{2} - 9 p_{3}\\right)}{3072} \\right)} + 2 \\cos{\\left(\\frac{3 p_{0} sG}{4} + \\frac{9 sG \\left(- 11 p_{0} + 18 p_{1} - 9 p_{2} + 2 p_{3}\\right)}{64} + \\frac{81 sG \\left(- 9 p_{0} + 27 p_{1} - 27 p_{2} + 9 p_{3}\\right)}{2048} + \\frac{9 sG \\left(18 p_{0} - 45 p_{1} + 36 p_{2} - 9 p_{3}\\right)}{128} \\right)} + 4 \\cos{\\left(\\frac{7 p_{0} sG}{8} + \\frac{49 sG \\left(- 11 p_{0} + 18 p_{1} - 9 p_{2} + 2 p_{3}\\right)}{256} + \\frac{2401 sG \\left(- 9 p_{0} + 27 p_{1} - 27 p_{2} + 9 p_{3}\\right)}{32768} + \\frac{343 sG \\left(18 p_{0} - 45 p_{1} + 36 p_{2} - 9 p_{3}\\right)}{3072} \\right)} + \\cos{\\left(p_{0} sG + \\frac{sG \\left(- 11 p_{0} + 18 p_{1} - 9 p_{2} + 2 p_{3}\\right)}{4} + \\frac{sG \\left(- 9 p_{0} + 27 p_{1} - 27 p_{2} + 9 p_{3}\\right)}{8} + \\frac{sG \\left(18 p_{0} - 45 p_{1} + 36 p_{2} - 9 p_{3}\\right)}{6} \\right)} + 1\\right)$"
      ],
      "text/plain": [
       "0.0416666666666667*sG*(4*cos(p0*sG/8 + sG*(-11*p0 + 18*p1 - 9*p2 + 2*p3)/256 + sG*(-9*p0 + 27*p1 - 27*p2 + 9*p3)/32768 + sG*(18*p0 - 45*p1 + 36*p2 - 9*p3)/3072) + 2*cos(p0*sG/4 + sG*(-11*p0 + 18*p1 - 9*p2 + 2*p3)/64 + sG*(-9*p0 + 27*p1 - 27*p2 + 9*p3)/2048 + sG*(18*p0 - 45*p1 + 36*p2 - 9*p3)/384) + 4*cos(3*p0*sG/8 + 9*sG*(-11*p0 + 18*p1 - 9*p2 + 2*p3)/256 + 81*sG*(-9*p0 + 27*p1 - 27*p2 + 9*p3)/32768 + 9*sG*(18*p0 - 45*p1 + 36*p2 - 9*p3)/1024) + 2*cos(p0*sG/2 + sG*(-11*p0 + 18*p1 - 9*p2 + 2*p3)/16 + sG*(-9*p0 + 27*p1 - 27*p2 + 9*p3)/128 + sG*(18*p0 - 45*p1 + 36*p2 - 9*p3)/48) + 4*cos(5*p0*sG/8 + 25*sG*(-11*p0 + 18*p1 - 9*p2 + 2*p3)/256 + 625*sG*(-9*p0 + 27*p1 - 27*p2 + 9*p3)/32768 + 125*sG*(18*p0 - 45*p1 + 36*p2 - 9*p3)/3072) + 2*cos(3*p0*sG/4 + 9*sG*(-11*p0 + 18*p1 - 9*p2 + 2*p3)/64 + 81*sG*(-9*p0 + 27*p1 - 27*p2 + 9*p3)/2048 + 9*sG*(18*p0 - 45*p1 + 36*p2 - 9*p3)/128) + 4*cos(7*p0*sG/8 + 49*sG*(-11*p0 + 18*p1 - 9*p2 + 2*p3)/256 + 2401*sG*(-9*p0 + 27*p1 - 27*p2 + 9*p3)/32768 + 343*sG*(18*p0 - 45*p1 + 36*p2 - 9*p3)/3072) + cos(p0*sG + sG*(-11*p0 + 18*p1 - 9*p2 + 2*p3)/4 + sG*(-9*p0 + 27*p1 - 27*p2 + 9*p3)/8 + sG*(18*p0 - 45*p1 + 36*p2 - 9*p3)/6) + 1)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_sG"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember, composite simpson's works by replacing the integral with a sum over $n$ components, so this looks about right."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now if we've done everything correctly, we should be able to visualize our trajectory ending point (and any arbitrary point along our trajectory!) given a set of parameters. \n",
    "\n",
    "Let's double-check our math/code by visually plotting a trajectory for some set of parameters.\n",
    "I'll choose some parameters which:\n",
    " - should be 20 meters long\n",
    " - starts with 0 curvature and linearly increases to 0.3 by $s_G$.\n",
    " \n",
    "Below is some code for plotting the trajectory. I'm just doing a few simple things:\n",
    " - Using `sympy`'s \"eval\" function which plugs in concrete values for different parameters\n",
    " - Using `matplotlib` to plot the evaluation for 100 values of $s$ between 0 and $s_G$.\n",
    " - I plot three things: The curve itself, the heading as a function of travel and the curvature as a function of travel.\n",
    " \n",
    "These should serve as a decent sanity check for us."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lets say we have some initial guess\n",
    "p0_g = 0\n",
    "p1_g = 0.1\n",
    "p2_g = 0.2\n",
    "p3_g = 0.3\n",
    "sG_g = 20\n",
    "\n",
    "p_g = (p0_g, p1_g, p2_g, p3_g, sG_g)\n",
    "\n",
    "def eval_guess(p_g, s_eval=None):\n",
    "    p0_g = p_g[0]\n",
    "    p1_g = p_g[1]\n",
    "    p2_g = p_g[2]\n",
    "    p3_g = p_g[3]\n",
    "    sG_g = p_g[4]\n",
    "    if s_eval == None:\n",
    "        s_eval = sG_g\n",
    "    # note that i set s and sG to s_eval for x,y but sG to sG_g for theta.\n",
    "    # this is not technically correct - this is because i use sG as the argument in composite simpson when it should \n",
    "    # really be s_eval. has to do with the way I'm re-using variable names in sympy\n",
    "    # and i don't understand the correct way to do it.\n",
    "    x_sG_g = x_sG.subs([(p0, p0_g), (p1, p1_g), (p2, p2_g), (p3, p3_g), (sG, s_eval)])\n",
    "    y_sG_g = y_sG.subs([(p0, p0_g), (p1, p1_g), (p2, p2_g), (p3, p3_g), (sG, s_eval)])\n",
    "    theta_sG_g = theta.subs([(p0, p0_g), (p1, p1_g), (p2, p2_g), (p3, p3_g), (s, s_eval), (sG, sG_g)])\n",
    "    ka_g = kappa.subs([(p0, p0_g), (p1, p1_g), (p2, p2_g), (p3, p3_g), (s, s_eval), (sG, sG_g)])\n",
    "    return x_sG_g, y_sG_g, theta_sG_g, ka_g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# code to plot the trajectory for a set of parameters\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "%matplotlib inline\n",
    "\n",
    "def plot(p_g, iteration=None, q_goal=None):\n",
    "    xs = []\n",
    "    ys = []\n",
    "    ths = []\n",
    "    kas = []\n",
    "    sG_g = float(p_g[4])\n",
    "    print(type(sG_g))\n",
    "    ss = np.linspace(0, sG_g, 100)\n",
    "    for s in ss:\n",
    "        x,y,th,ka = eval_guess(p_g, s)\n",
    "        xs.append(x)\n",
    "        ys.append(y)\n",
    "        ths.append(th)\n",
    "        kas.append(ka)\n",
    "    \n",
    "    \n",
    "    fig, (ax1, ax2, ax3) = plt.subplots(1, 3)\n",
    "    iteration_str = \"iteration: \" + str(iteration) if iteration else \"\"\n",
    "    fig.suptitle(iteration_str)\n",
    "\n",
    "    ax1.set_title('x,y pts')\n",
    "    ax1.plot(xs,ys, 'o')\n",
    "    ax1.set(xlabel='X', ylabel='Y')\n",
    "    if q_goal:\n",
    "        ax1.plot(q_goal[0],q_goal[1],'r+') # plot goal x,y\n",
    "    \n",
    "    ax2.set_title('heading over travel')\n",
    "    ax2.plot(ss, ths, 'o')\n",
    "    ax2.set(xlabel='s', ylabel='theta')\n",
    "    if q_goal:\n",
    "        ax2.axhline(q_goal[2],color='r')\n",
    "\n",
    "    ax3.set_title('curvature over travel')\n",
    "    ax3.plot(ss, kas, 'o')\n",
    "    ax3.set(xlabel='s', ylabel='kappa')\n",
    "    if q_goal:\n",
    "        ax3.axhline(q_goal[3], color='r')\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot(p_g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This looks about right - the curvature is continuous, matches the specified values at different travels and the x,y, heading look continuous. Yay!\n",
    "\n",
    "Next let's look at how we \"correct\" the initial parameters to get closer to our target pose."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Relating our output error to parameter error\n",
    "\n",
    "So let's say we've started with some initial guess for the parameters, and they give us a trajectory that lands not quite on our target pose. Next, we need to relate the error in our output to an error to our input. It's time to introduce the Jacobian.\n",
    "\n",
    "## Jacobian\n",
    "We can think of the Jacobian as the vector calculus analogue to the derivative. A derivative tells us how to relate a change in the output of a function to the change in input. For a vector function, the inputs and outputs can both be vectors. So the Jacobian of a function is simply the matrix that specifies how the $i$th output varies with respect to the $j$th input. In our case, we want to know how the different components of the end pose ($x,y,\\theta,\\kappa$) are affected by the different input parameters ($p_0,..,p3, s_G$). \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div>\n",
    "<img src=\"https://raw.githubusercontent.com/markmliu/path_opt/main/img/jacobian.png\" width=500>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So why do we have a 3x3 matrix if there are 5 inputs and 4 outputs? $p_0$ and $p_3$ can be skipped as inputs, since they are fixed for a given end pose (recall that $p_0$ is equal to initial curvature and $p_3$ is equal to final curvature). $\\kappa$ can also be omitted as an output, since the final curvature is specified by the end pose. This leaves 3 unfixed input parameters ($p_1, p_2, s_G$) and 3 unfixed output parameters ($x,y,\\theta$). Let's encode the Jacobian into `sympy` as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Jacobian(p_g):\n",
    "    p0_g = p_g[0]\n",
    "    p1_g = p_g[1]\n",
    "    p2_g = p_g[2]\n",
    "    p3_g = p_g[3]\n",
    "    sG_g = p_g[4]\n",
    "    \n",
    "    substitutions = [(p0, p0_g), (p1, p1_g), (p2, p2_g), (p3, p3_g), (sG, sG_g), (s, sG_g)]\n",
    "    \n",
    "    J11 = diff(x_sG, p1).subs(substitutions)\n",
    "    J12 = diff(x_sG, p2).subs(substitutions)\n",
    "    J13 = diff(x_sG, sG).subs(substitutions)\n",
    "    J21 = diff(y_sG, p1).subs(substitutions)\n",
    "    J22 = diff(y_sG, p2).subs(substitutions)\n",
    "    J23 = diff(y_sG, sG).subs(substitutions)\n",
    "    J31 = diff(theta, p1).subs(substitutions)\n",
    "    J32 = diff(theta, p2).subs(substitutions)\n",
    "    J33 = diff(theta, sG).subs(substitutions)\n",
    "    J = Matrix([[J11,J12,J13], [J21,J22, J33], [J31,J32,J33]])\n",
    "    \n",
    "    return J"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's where we really got to take advantage of sympy - rather than having to numerically calculate the Jacobian anywhere we were able to take all of our derivatives symbolically, which is both faster and more accurate. Being able to do this is also incredibly useful for a real-time planner (though you most likely wouldn't be using python for that)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "J = Jacobian(p_g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 3)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape(J)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Putting it all together\n",
    "\n",
    "Okay, so we've got the two pieces we were looking for: \n",
    "\n",
    "**1. Determine where a trajectory will land, given the parameters (for step 1 above)**\n",
    "\n",
    "**2. Relate the error in final pose to the error in chosen parameters (for step 3 above)**\n",
    "\n",
    "We said that once we had these, we could use the shooting method to calculate the correct paramters. The shooting method says to update the parameters systematically until we land on the goal, but does not specify how to update them. This paper uses Newton's method to update the parameter guess. \n",
    "\n",
    "## Newton's method \n",
    "\n",
    "Newton's method iteratively find the roots (zeros) of a function using just its derivative (or Jacobian, in our case). For us, we can use it to find the root of $f=q_g - q_p$ (the difference between the goal pose and the pose from our parameters). Finding the root of that function will get the error to zero, giving us the correct parameters. So how does it work? The Wikipedia article has a great visual explanation.\n",
    "<div>\n",
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/e/e0/NewtonIteration_Ani.gif\" width=500>\n",
    "</div>\n",
    "\n",
    "Essentially, Newton's method works by starting with a guess, taking a linear approximation to the function at that guess and extrapolating to find the \"zero\" of that approximation. This becomes our next guess, and we repeat. Under certain conditions, this is guaranteed to converge to a true zero of the function. The paper describes this formally below:\n",
    "\n",
    "<div>\n",
    "<img src=\"https://raw.githubusercontent.com/markmliu/path_opt/main/img/newtons_method.png\" width=200>\n",
    "</div>\n",
    "\n",
    "Okay, let's put it all into code! I'll set up a problem with an initial and goal pose, and start off with some initial guess for the parameters. I'll use the shooting method with Newton's method to update the parameters - we'll pause and look at some of the intermediate trajectories we generated to see how the updates change our trajectory!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "final ps: Matrix([[0], [0.179749098336037], [-0.247038077524759], [0.200000000000000], [11.9181828929782]])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(9.99986981345695, 4.98669898930157, -0.00278131292041905, 0.199999999999998)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "# k_i = 0.2\n",
    "# k_goal = 1.0\n",
    "\n",
    "k_i = 0.0 \n",
    "k_goal = 0.2\n",
    "x_goal = 10.0\n",
    "y_goal = 5.0\n",
    "\n",
    "\n",
    "# initial point is (0,0,0,kappa_i)\n",
    "q_i = Matrix([0.0, 0.0, 0.0, k_i])\n",
    "# destination point is (10,20,pi/4,0.2)\n",
    "q_goal = Matrix([x_goal, y_goal, 0.0, k_goal])\n",
    "\n",
    "\n",
    "# lets say we have some initial guess (p0 must match initial curvature, p3 must match actual final curvature)\n",
    "p0_g = k_i\n",
    "p1_g = 0.0\n",
    "p2_g = 0.0\n",
    "p3_g = k_goal\n",
    "sG_g = 15.0\n",
    "\n",
    "p_g = Matrix([p0_g, p1_g, p2_g, p3_g, sG_g])\n",
    "\n",
    "intermediates = []\n",
    "\n",
    "num_iters = 10\n",
    "for i in range(0,num_iters+1):\n",
    "\n",
    "    J = Jacobian(p_g)\n",
    "    q_sG_g = Matrix(list(eval_guess(p_g)))\n",
    "    d_q = q_goal - q_sG_g\n",
    "    d_q.row_del(3) # delete the curvature, since we don't include it in the jacobian\n",
    "    \n",
    "    d_p = J.inv() * d_q \n",
    "\n",
    "    # add back 0s for p0 and p3 index (0 and 3)\n",
    "    d_p = d_p.row_insert(0, Matrix([0]))\n",
    "    d_p = d_p.row_insert(3, Matrix([0]))\n",
    "    \n",
    "    p_g += d_p\n",
    "    if i == 0 or i == 3 or i == 7: # just save some intermediates for plotting\n",
    "        intermediates.append((p_g, i))\n",
    "\n",
    "intermediates.append((p_g, num_iters))\n",
    "print(\"final ps:\", p_g)    \n",
    "eval_guess(p_g)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay let's see how we did! Let's first look at iteration 0. I've drawn a red cursor in the leftmost plot to illustrate where our curve should end in $x,y$. Similarly, I've drawn red lines in the next two plots to show where the heading should end by the final travel $s_G$, and same with the curvature."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot iteration 0\n",
    "guess, i = intermediates[0]\n",
    "plot(guess, i, q_goal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This first attempt at the trajectory is very far off. We can see that the trajectory ends at around (8,2) when the target is around (10,5). Similarly, the heading ends at -0.4 when it should be around 0.0. Note that the final curvature is correct - as we noted earlier this is fixed from the start and will always be correct. Let's look at a later iteration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "guess, i = intermediates[1]\n",
    "plot(guess, i, q_goal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, at iteration 3, we're doing better. The trajectory endpoint is around (10,6) and the final heading is closer as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "guess, i = intermediates[2]\n",
    "plot(guess, i, q_goal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On iteration 7 we've gotten even closer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "guess, i = intermediates[3]\n",
    "plot(guess, i, q_goal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And on iteration 10 it looks dead-on. Note that I didn't really implement the convergence criteria, but you could implement it pretty easily by comparing the norm of the error with some threshold.\n",
    "\n",
    "So we've found a guess that lands us at the correct end pose! Last step is to transform this guess back into the $a,b,c,d$ parameters we originally wanted to compute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0,\n",
       " 0.245793613018951,\n",
       " 0.00393504919871011,\n",
       " 0.00393504919871011,\n",
       " 11.9181828929782)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "substitutions = [(p0, guess[0]), (p1, guess[1]), (p2, guess[2]), (p3, guess[3]), (sG, guess[4]), (s, guess[4])]\n",
    "a_final = a.subs(substitutions)\n",
    "b_final = b.subs(substitutions)\n",
    "c_final = d.subs(substitutions)\n",
    "d_final = d.subs(substitutions)\n",
    "sG_final = guess[4]\n",
    "a_final, b_final, c_final, d_final, sG_final"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conclusion\n",
    "\n",
    "We learned about how the McNaughton paper generates smooth paths between arbitrary robot poses. In doing so, we took advantage of both symbolic and numerical math (when appropriate) to get a useful, practical algorithm. One of the things I love about working in robotics is that you have to mix and match techniques from lot of different fields. For a curious mind, this provides endless opportunity to learn. I hope you enjoyed following along! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "# References\n",
    "\n",
    "[1] https://www.ri.cmu.edu/pub_files/2011/7/mcnaughton-thesis.pdf\n",
    "\n",
    "[2] https://www.cs.cmu.edu/~alonzo/pubs/papers/ijrr02TrajGen.pdf\n",
    "\n",
    "[3] https://ocw.snu.ac.kr/sites/default/files/NOTE/Lecture%2011_0.pdf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Appendix\n",
    "\n",
    "Did not implement the initial guess algorithm, but its described here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initial guess algorithm\n",
    "\n",
    "<div>\n",
    "<img src=\"https://raw.githubusercontent.com/markmliu/path_opt/main/img/initial_guess.png\" width=500>\n",
    "</div>"
   ]
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}