doc/euclidean/catmull-rom-uniform.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "nbsphinx": "hidden"
   },
   "source": [
    "This notebook is part of https://github.com/AudioSceneDescriptionFormat/splines, see also https://splines.readthedocs.io/.\n",
    "\n",
    "[back to overview](catmull-rom.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Uniform Catmull--Rom Splines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<cite data-cite-t=\"catmull1974splines\">Catmull and Rom (1974)</cite>\n",
    "presented a class of splines which can be described mathematically,\n",
    "in its most generic form,\n",
    "with what is referred to as equation (1):\n",
    "\n",
    "\\begin{equation*}\n",
    "F(s) =\n",
    "\\frac{\n",
    "\\sum x_i(s) w_i(s)\n",
    "}{\n",
    "\\sum w_i(s)\n",
    "},\n",
    "\\end{equation*}\n",
    "where the part $w_i(s)/\\sum w_i(s)$ is called *blending functions*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Since the blending functions presented above are,\n",
    "as of now, completely\n",
    "arbitrary\n",
    "we impose\n",
    "some\n",
    "constraints in order to make them easier to use. We\n",
    "shall deal only with blending functions that are zero\n",
    "outside of some given interval.\n",
    "Also we require that\n",
    "$\\sum w_i(s)$ does not vanish for any $s$.\n",
    "We shall normalize $w_i(s)$ so that\n",
    "$\\sum w_i(s) = 1$ for all $s$.\n",
    ">\n",
    "> ---<cite data-cite-t=\"catmull1974splines\">Catmull and Rom (1974)</cite>, section 3, \"Blending Functions\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The components of the equation are further constrained\n",
    "to produce an interpolating function:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Consider the following case:\n",
    "Let $x_i(s)$ be any function\n",
    "interpolating the points $p_i$ through $p_{i+k}$\n",
    "and let $w_i(s)$ be zero outside $(s_{i-1}, s_{i+k+1})$.\n",
    "The function $F(s)$ defined in equation (1)\n",
    "will thus be an interpolating function.\n",
    "Intuitively, this says that if all of the functions\n",
    "that have an effect at a point,\n",
    "pass through the point,\n",
    "then the average of the functions will pass through the point.\n",
    ">\n",
    "> ---<cite data-cite-t=\"catmull1974splines\">Catmull and Rom (1974)</cite>, section 2: \"The Model\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "\n",
    "Typo Alert\n",
    "\n",
    "The typo \"$p_i$ through $s_{i+k}$\" has been fixed in the quote above.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> A polynomial of degree $k$\n",
    "that pass[e]s through $k+1$ points will be used as $x(s)$.\n",
    "In general it will not pass through the other points.\n",
    "If the width of the interval in which $w_i(s)$ is non zero\n",
    "is less than or equal to $k+2$ then $x_i(s)$ will not affect $F(s)$\n",
    "outside the interpolation interval.\n",
    "This means that $F(s)$ will be an interpolating function.\n",
    "On the other hand\n",
    "if the width of $w_i(s)$ is greater than $k+2$\n",
    "then $x_i(s)$ will have an effect on the curve\n",
    "outside the interpolation interval.\n",
    "$F(s)$ will then be an approximating function.\n",
    ">\n",
    "> ---<cite data-cite-t=\"catmull1974splines\">Catmull and Rom (1974)</cite>, section 2: \"The Model\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After limiting the scope of the paper to *interpolating* splines,\n",
    "it is further reduced to *uniform* splines:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> [...] in\n",
    "the\n",
    "parametric\n",
    "space\n",
    "we can, without\n",
    "loss\n",
    "of\n",
    "generality, place $s_j=j$.\n",
    ">\n",
    "> ---<cite data-cite-t=\"catmull1974splines\">Catmull and Rom (1974)</cite>, section 2: \"The Model\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Whether or not generality is lost,\n",
    "this means that the rest of the paper doesn't give any hints\n",
    "on how to construct non-uniform splines.\n",
    "For those who are interested nevertheless,\n",
    "we show how to do that in the\n",
    "[notebook about non-uniform Catmull--Rom splines](catmull-rom-non-uniform.ipynb)\n",
    "and once again in the\n",
    "[notebook about the Barry--Goldman algorithm](catmull-rom-barry-goldman.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After the aforementioned constraints\n",
    "and the definition of the term *cardinal function* ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Cardinal function: a function that is $1$ at some\n",
    "knot, $0$ at all other knots and can be anything in\n",
    "between the other knots. It satisfies $F_i(s_j) = \\delta_{ij}$.\n",
    ">\n",
    "> ---<cite data-cite-t=\"catmull1974splines\">Catmull and Rom (1974)</cite>, section 1: \"Introduction\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... the gratuitously generic equation (1) is made a bit more concrete:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> If in equation (1) we assume $x_i(s)$\n",
    "to be polynomials of degree $k$\n",
    "then this equation can be reduced to a much simpler form:\n",
    ">\n",
    "> \\begin{equation*}\n",
    "F(s) =\n",
    "\\sum_j p_j C_{jk}(s)\n",
    "\\end{equation*}\n",
    "> where the $C_{jk}(s)$ are cardinal blending functions\n",
    "and $j$ is the knot to which the cardinal function and the point belong\n",
    "and each $C_{jk}(s)$ is a shifted version of $C_{0,k}(s)$.\n",
    "$C_{0,k}(s)$ is a function of both the degree $k$\n",
    "of the polynomials and the blending functions $w(s)$:\n",
    ">\n",
    "> \\begin{equation*}\n",
    "C_{0,k}(s) =\n",
    "\\sum_{i=0}^k\n",
    "\\Big[\n",
    "\\prod_{\\substack{j=i-k\\\\j \\ne 0}}^i \\left(\\frac{s}{j}+1\\right)\n",
    "\\Big]\n",
    "w(s+i)\n",
    "\\end{equation*}\n",
    ">\n",
    "> In essence we see that for a polynomial case\n",
    "our cardinal functions are a blend of Lagrange polynomials.\n",
    "When calculating $C_{0,k}(s)$,\n",
    "$w(s)$ should be centered about $\\frac{k}{2}$.\n",
    ">\n",
    "> ---<cite data-cite-t=\"catmull1974splines\">Catmull and Rom (1974)</cite>, section 4: \"Calculating Cardinal Functions\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This looks like something we can work with,\n",
    "even though the blending function $w(s)$ is still not defined."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sympy as sp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use $t$ instead of $s$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = sp.symbols('t')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i, j, k = sp.symbols('i j k', integer=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "w = sp.Function('w')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C0k = sp.Sum(\n",
    "        sp.Product(\n",
    "            sp.Piecewise((1, sp.Eq(j, 0)), ((t / j) + 1, True)),\n",
    "            (j, i - k, i)) * w(t + i),\n",
    "        (i, 0, k))\n",
    "C0k"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Blending Functions\n",
    "\n",
    "<cite data-cite-t=\"catmull1974splines\">Catmull and Rom (1974)</cite>\n",
    "leave the choice of blending function to the reader.\n",
    "They show two plots (figure 1 and figure 3) for a custom blending function\n",
    "stitched together from two Bézier curves,\n",
    "but they don't show the cardinal function nor an actual spline\n",
    "created from it.\n",
    "\n",
    "The only other concrete suggestion is to use B-spline basis functions\n",
    "as blending functions.\n",
    "A quadratic B-spline basis function is shown in figure 2\n",
    "and both cardinal functions and example curves are shown\n",
    "that utilize both quadratic and cubic B-spline basis functions\n",
    "(figures 4 through 7).\n",
    "No mathematical description of B-spline basis functions is given,\n",
    "instead they refer to\n",
    "<cite data-cite-t=\"gordon1974bspline\">Gordon and Riesenfeld (1974)</cite>.\n",
    "That paper provides a pair of equations (3.1 and 3.2)\n",
    "that can be used to recursively construct B-spline basis functions.\n",
    "Simplified to the *uniform* case,\n",
    "this leads to the base case (i.e. degree zero) ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B0 = sp.Piecewise((0, t < i), (1, t < i + 1), (0, True))\n",
    "B0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... which can be used to obtain the linear (i.e. degree one) basis functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B1 = (t - i) * B0 + (i + 2 - t) * B0.subs(i, i + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use one of them (where $i = 0$) as blending function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "w1 = B1.subs(i, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With some helper functions from [helper.py](helper.py)\n",
    "we can plot this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from helper import plot_sympy, grid_lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_sympy(w1, (t, -0.2, 2.2))\n",
    "grid_lines([0, 1, 2], [0, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The quadratic (i.e. degree two) basis functions can be obtained like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B2 = (t - i) / 2 * B1 + (i + 3 - t) / 2 * B1.subs(i, i + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For our further calculations,\n",
    "we use the function with $i=-1$ as blending function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "w2 = B2.subs(i, -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_sympy(w2, (t, -1.2, 2.2))\n",
    "grid_lines([-1, 0, 1, 2], [0, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This should be the same function as shown by\n",
    "<cite data-cite-t=\"catmull1974splines\">Catmull and Rom (1974)</cite>\n",
    "in figure 2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cardinal Functions\n",
    "\n",
    "The first example curve in the paper (figure 5)\n",
    "is a cubic curve,\n",
    "constructed using\n",
    "a cardinal function with $k=1$ (i.e. using linear Lagrange interpolation)\n",
    "and\n",
    "a quadratic B-spline basis function (as shown above)\n",
    "as blending function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the information so far,\n",
    "we can construct the cardinal function $C_{0,1}(t)$,\n",
    "using our *quadratic* B-spline blending function `w2`\n",
    "(which is, as required, centered about $\\frac{k}{2}$):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C01 = C0k.subs(k, 1).replace(w, lambda x: w2.subs(t, x)).doit().simplify()\n",
    "C01"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_sympy(C01, (t, -2.2, 2.2))\n",
    "grid_lines(range(-2, 3), [0, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This should be the same function as shown by\n",
    "<cite data-cite-t=\"catmull1974splines\">Catmull and Rom (1974)</cite>\n",
    "in figure 4."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The paper does not show that,\n",
    "but we can also try to flip the respective degrees\n",
    "of Lagrange interpolation and B-spline blending.\n",
    "In other words, we can set $k=2$ to construct the\n",
    "cardinal function $C_{0,2}(t)$,\n",
    "this time using the *linear* B-spline blending function `w1`\n",
    "(which is also centered about $\\frac{k}{2}$)\n",
    "leading to a total degree of 3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C02 = C0k.subs(k, 2).replace(w, lambda x: w1.subs(t, x)).doit().simplify()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And as it turns out, this is exactly the same thing!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert C01 == C02"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By the way, we come to the same conclusion in our\n",
    "[notebook about the Barry--Goldman algorithm](catmull-rom-barry-goldman.ipynb),\n",
    "which means that this is also true in the *non-uniform* case."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many authors nowadays, when using the term *Catmull--Rom spline*,\n",
    "mean the cubic spline created using exactly this cardinal function.\n",
    "\n",
    "As we have seen,\n",
    "this can be equivalently understood\n",
    "either as\n",
    "three linear interpolations\n",
    "(more exactly: one interpolation and two extrapolations)\n",
    "followed by quadratic B-spline blending\n",
    "or as\n",
    "two overlapping quadratic Lagrange interpolations\n",
    "followed by linear blending.\n",
    "The two equivalent approaches are illustrated\n",
    "by means of animations in the\n",
    "[notebook about non-uniform Catmull--Rom splines](catmull-rom-non-uniform.ipynb#Animation)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To quickly check how a spline segment would look like\n",
    "when using the cardinal function we just derived,\n",
    "let's define a few points ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vertices = np.array([\n",
    "    (-0.1, -0.5),\n",
    "    (0, 0),\n",
    "    (1, 0),\n",
    "    (0.5, 1),\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... and plot $F(t)$ (or $F(s)$, as it has been called originally):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.scatter(*np.array([\n",
    "    sum([vertices[i] * C01.subs(t, s - i + 1) for i in range(4)])\n",
    "    for s in np.linspace(0, 1, 20)]).T)\n",
    "plt.plot(*vertices.T, 'x:g');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For calculating more than one segment,\n",
    "and also for creating non-uniform Catmull--Rom splines,\n",
    "the class\n",
    "[splines.CatmullRom](../python-module/splines.rst#splines.CatmullRom)\n",
    "can be used.\n",
    "For more plots, see\n",
    "[the notebook about properties of Catmull--Rom splines](catmull-rom-properties.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basis Polynomials\n",
    "\n",
    "The piecewise expression for the cardinal function\n",
    "is a bit unwieldy to work with,\n",
    "so let's bring it into a form we already know how to deal with.\n",
    "\n",
    "We are splitting the piecewise expression into four separate pieces,\n",
    "each one to be evaluated at $0 \\le t \\le 1$.\n",
    "We are also reversing the order of the pieces,\n",
    "to match our intended control point order:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b_CR = sp.Matrix([\n",
    "    expr.subs(t, t + cond.args[1] - 1)\n",
    "    for expr, cond in C01.args[1:-1][::-1]]).T\n",
    "b_CR.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from helper import plot_basis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_basis(*b_CR, labels=sp.symbols('xbm_i-1 xbm_i xbm_i+1 xbm_i+2'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the following sections,\n",
    "we are using a few tools from [utility.py](utility.py):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from utility import NamedExpression, NamedMatrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basis Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b_monomial = sp.Matrix([t**3, t**2, t, 1]).T\n",
    "M_CR = NamedMatrix(r'{M_\\text{CR}}', 4, 4)\n",
    "control_points = sp.Matrix(sp.symbols('xbm3:7'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As usual, we look at the fifth polynomial segment $\\boldsymbol{p}_4(t)$\n",
    "(from $\\boldsymbol{x}_4$ to $\\boldsymbol{x}_5$), where $0 \\le t \\le 1$.\n",
    "Later, we will be able to generalize this to an arbitrary\n",
    "polynomial segment $\\boldsymbol{p}_i(t)$\n",
    "(from $\\boldsymbol{x}_i$ to $\\boldsymbol{x}_{i+1}$),\n",
    "where $0 \\le t \\le 1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p4 = NamedExpression('pbm4', b_monomial * M_CR.name * control_points)\n",
    "p4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the basis polynomials and the control points,\n",
    "we can already calculate $\\boldsymbol{p}_4(t)$ ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p4.expr = b_CR.dot(control_points).expand().collect(t)\n",
    "p4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... and with a little bit of squinting,\n",
    "we can directly read off\n",
    "the coefficients of the basis matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "M_CR.expr = sp.Matrix([\n",
    "    [b.get(m, 0) for b in [\n",
    "        p4.expr.expand().coeff(cv).collect(t, evaluate=False)\n",
    "        for cv in control_points]]\n",
    "    for m in b_monomial])\n",
    "M_CR.pull_out(sp.S.Half)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<cite data-cite-t=\"catmull1974splines\">Catmull and Rom (1974)</cite>\n",
    "show this matrix in section 6."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In case you want to copy&paste it, here's a plain text version:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(_.expr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And, in case somebody needs it, its inverse looks like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "M_CR.I"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(_.expr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tangent Vectors\n",
    "\n",
    "To get the tangent vectors,\n",
    "we simply have to take the first derivative ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd4 = p4.diff(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... and evaluate it at the beginning and the end of the segment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "start_tangent = pd4.evaluated_at(t, 0)\n",
    "start_tangent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "end_tangent = pd4.evaluated_at(t, 1)\n",
    "end_tangent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These two expressions can be generalized to\n",
    "-- as already shown in\n",
    "[the notebook about Catmull--Rom properties](catmull-rom-properties.ipynb#Tangent-Vectors):\n",
    "\n",
    "\\begin{equation*}\n",
    "\\boldsymbol{\\dot{x}}_i =\n",
    "\\frac{\\boldsymbol{x}_{i+1} - \\boldsymbol{x}_{i-1}}{2}\n",
    "\\end{equation*}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using Bézier Segments\n",
    "\n",
    "The above equation for the tangent vectors can be used to construct\n",
    "[Hermite splines](hermite.ipynb) or,\n",
    "after dividing them by 3,\n",
    "to obtain the control points for\n",
    "[cubic Bézier spline segments](bezier-de-casteljau.ipynb#Cubic-Tangent-Vectors):\n",
    "\n",
    "\\begin{align*}\n",
    "\\boldsymbol{\\tilde{x}}_i^{(+)}\n",
    "&= \\boldsymbol{x}_i + \\frac{\\boldsymbol{\\dot{x}}_i}{3}\n",
    "= \\boldsymbol{x}_i + \\frac{\\boldsymbol{x}_{i+1} - \\boldsymbol{x}_{i-1}}{6}\\\\\n",
    "\\boldsymbol{\\tilde{x}}_i^{(-)}\n",
    "&= \\boldsymbol{x}_i - \\frac{\\boldsymbol{\\dot{x}}_i}{3}\n",
    "= \\boldsymbol{x}_i - \\frac{\\boldsymbol{x}_{i+1} - \\boldsymbol{x}_{i-1}}{6}\n",
    "\\end{align*}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x4, x5 = control_points[1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x4tilde = x4 + start_tangent.expr / 3\n",
    "x4tilde"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x5tilde = x5 - end_tangent.expr / 3\n",
    "x5tilde"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Using Quadrangle Interpolation\n",
    "\n",
    "Remember the [notebook about quadrangle interpolation](quadrangle.ipynb)?\n",
    "It showed us how to calculate the quadrangle points\n",
    "given the Bézier control points:\n",
    "\n",
    "\\begin{align*}\n",
    "\\boldsymbol{\\bar{x}}_i^{(+)} &=\n",
    "\\frac{3}{2} \\boldsymbol{\\tilde{x}}_i^{(+)} -\n",
    "\\frac{1}{2} \\boldsymbol{x}_{i+1}\\\\\n",
    "\\boldsymbol{\\bar{x}}_i^{(-)} &=\n",
    "\\frac{3}{2} \\boldsymbol{\\tilde{x}}_i^{(-)} -\n",
    "\\frac{1}{2} \\boldsymbol{x}_{i-1}\n",
    "\\end{align*}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x4bar = 3 * x4tilde / 2 - x5 / 2\n",
    "x4bar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x5bar = 3 * x5tilde / 2 - x4 / 2\n",
    "x5bar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generalizing these expressions\n",
    "and juggling the terms around a bit, we get\n",
    "\n",
    "\\begin{equation*}\n",
    "\\boldsymbol{\\bar{x}}_i^{(+)} =\n",
    "\\boldsymbol{\\bar{x}}_i^{(-)} =\n",
    "\\boldsymbol{x}_i - \\frac{\n",
    "(\\boldsymbol{x}_{i+1} - \\boldsymbol{x}_i) +\n",
    "(\\boldsymbol{x}_{i-1} - \\boldsymbol{x}_i)\n",
    "}{4}.\n",
    "\\end{equation*}"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}