{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d5076396",
   "metadata": {},
   "source": [
    "# Kalman filtering"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "420d728b",
   "metadata": {},
   "source": [
    "This tutorial is a gentle introduction to Kalman filtering.\n",
    "\n",
    "Kalman filter (KF) is a powerful algorithm to estimate unknown values of state variables, given (noisy) observations and a physical model describing the evolution of state variables.\n",
    "\n",
    "In general, the states are the variables we are intersted in and we want to estimate. They can be time-varying (e.g. position, speed of a car, and in general all kinematic variables) or constant parameter (e.g. weight of a car). Note that all estimated parameters will be varying in the KF (the former will vary as the quantity they try to estimate is varying, the latter will vary because we have a more and more accurate approximation of the unknown quantity they try to estimate). To run KF, we need a dynamic model describing how parameters at time $t$ should nominally evolve to the next epoch $t+1$ (here 'nominally' means, in the absence of noise, and under the assumption that the underlying physical model is exact).\n",
    "\n",
    "On the other hand, observations will be supplied to KF in order to make up for the approximations of the dynamic model. Those observations need not be directly on the state variables. For example, we may want to estimate the 2D position of a vehicle (two state variables $x$ and $y$) and use observations based on a set of ranging beacons. But, at least, we need to provide the observation model, that tells KF how observations would be generated from state variables (simply put: if we had perfect knowledge of the state variables, how would we compute the observation values).\n",
    "\n",
    "To sum up, KF is efficient in all situations where:\n",
    "\n",
    "1. We want to estimate unknown states of a system.\n",
    "2. We have a set of observations, coming from various sensors, providing noisy and partial information on state variables, with a good knowledge of their respective accuracies.\n",
    "3. We have a prior approximate physical model on how the system should evolve under perfect conditions, and we know to what extent this approximation is correct.\n",
    "\n",
    "In Tracklib, state and observations are stored as analytical features (AF) in the tracks, and estimation is performed recursively at each timestamp (i.e. for each point in the track). As long as the KF parameters are not intentionnaly modified, the estimation will be performed in the exact same way on different tracks (output estimated values will of course depend on each individual track observations).\n",
    "\n",
    "Running a KF with $n$ states and $m$ observation variables requires 6 inputs:\n",
    "\n",
    "1. A dynamic model $F$ (an equation describing how the $n$ state variables are nominally evolving to the next time step).\n",
    "2. A covariance matrix $Q$ describing how $F$ is a close approximation of the actual behavior of the system. The higher the values of $Q$, the less confidence we have in our model.\n",
    "3. An observation model $H$ describing how the $n$ state variables are used to compute the $m$ observation variables.\n",
    "4. A covariance matrix $R$ describing how $H$ is a close approximation of the actual behavior of the sensors. The higher the values of $R$, the less confidence we have in our observations.\n",
    "5. An intial estimate $X_0$ of the state parameters.\n",
    "6. A covariance matrix $P_0$ describing the confidence we have in this initial estimate $X_0$.\n",
    "\n",
    "If we have no information about the initial state (blind initialization of the filter), we can set arbitrary values in $X_0$ and  set $P_0$ to be a diagonal matrix with arbitrarily large variances. \n",
    "\n",
    "Note that $Q$ and $R$ values are somehow apportionned to each other. Increasing values of $Q$ (i.e. decreasing our confidence in the dynamic model) is equivalent to decreasing the values of $R$ (hence increasing the confience we have in our observations).\n",
    "\n",
    "Note also that the physical relation $H$ between state and observations needs not be invertible. This means that we are not assuming that the perfect state of the system can be retrieved solely from the observations at any given epoch. However, if the relation $H$ is only poorly informative, then we would better have a strong and constraining model $F$ to avoid divergence of the solution. On the opposite, a sloppy and non-informative dynamic model should always be paired with invertible or nearly invertible observation model. \n",
    "\n",
    "In vanilla KF, the relations $F$ and $H$ must be linear, and are then described by matrices ($n \\times n$ matrix for $F$, with $n \\times n$ covariance matrix $Q$ and $m \\times n$ matrix for $H$ with $m \\times m$ covariance matrix $R$). However, Tracklib implements an Unscented Kalman Filter (UKF) which can be used to cover also the cases where $F$ and $H$ are non-linear. In this case they would be described as $\\mathbb{R}^n \\rightarrow \\mathbb{R}^n$ and $\\mathbb{R}^n \\rightarrow \\mathbb{R}^m$ functions for $F$ and $H$, respectively. In this case covariances $Q$ and $R$ still remain in matrix form.\n",
    "\n",
    "Let's start to implement a KF in Tracklib.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38c790a2",
   "metadata": {},
   "source": [
    "## First we set our environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "76f26ef8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# -*- coding: utf-8 -*-\n",
    "import matplotlib.pyplot as plt\n",
    "import os.path\n",
    "import sys\n",
    "\n",
    "#-------------------------------------------------------\n",
    "# Import de tracklib\n",
    "module_path = os.path.abspath(os.path.join('../../..'))\n",
    "if module_path not in sys.path:\n",
    "    sys.path.append(module_path)\n",
    "    \n",
    "import tracklib as trk"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "762476d6",
   "metadata": {},
   "source": [
    "In this example, we will generate a synthetic smooth track, add some noise to it, and then try to retrieve the original track. To generate a track we use the function generate from the package Synthetics. The parameter 0.2 describes the smoothness of the track; here we set not to low value, to get smooth and easily predictable kinematics. The parameter dt=10 is the timestamp increment. In order to get reproducible results, we use the seed 123."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ef02461d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generated track from 05/02/2042 00:44:56 to 05/02/2042 01:44:56 [360 pts, 159.24m]\n"
     ]
    }
   ],
   "source": [
    "trk.seed(123)\n",
    "track1 = trk.generate(0.2, dt=10)\n",
    "track2 = track1.noise(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "343fed75",
   "metadata": {},
   "source": [
    "Let's inspect the generated tracks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1bcb0f64",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------\n",
      "GPS track #0 of user 0:\n",
      "-------------------------------------\n",
      "  Nb of pt(s):   360\n",
      "  Ref sys id   : ENU\n",
      "  Starting at  : 05/02/2042 00:45:06\n",
      "  Ending at    : 05/02/2042 01:44:56\n",
      "  Duration     : 3590.000 s\n",
      "  Length       : 159.242 m\n",
      "-------------------------------------\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "track1.summary()\n",
    "track1.plot('k-')\n",
    "track2.plot('r+')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ede1243b",
   "metadata": {},
   "source": [
    "In this problem, we are interested in 4 parameters: 2 position parameters ($x$ and $y$) and 2 speed parameters ($v_x$ and $v_y$). The state vector is then $X = [x, y, v_x, v_y]^T$."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26a24e18",
   "metadata": {},
   "source": [
    "We need now to build the 6 inputs of the model. We are using here standard (linear) Kalman Filter. All ingredients of the filter will be matrices. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "cc391b4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0d99ceb",
   "metadata": {},
   "source": [
    "We will assume the speed of the mobile is constant.\n",
    "\n",
    "Warning: when we state that the speed of the mobile is constant, it's from a 'statistical' perspective. That does not necessarily mean that the estimated speed of the mobile out of the KF will be rigorously the same during all the sequence, but that the speed between two subsequent epochs is 'approximately' the same. How close they are to each other will be specified by the dynamic model covariance matrix $Q$."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a982098d",
   "metadata": {},
   "source": [
    "The speed being assumed constant between time steps, we can write: \n",
    "\n",
    "$v_x(t+1) = v_x(t)$\n",
    "\n",
    "$v_y(t+1) = v_y(t)$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3cae939",
   "metadata": {},
   "source": [
    "Of course, as stated above, those two equations are approximations. The rigorous version would be:\n",
    "\n",
    "$v_x(t+1) = v_x(t) + \\eta_x(t)$\n",
    "\n",
    "$v_y(t+1) = v_y(t) + \\eta_y(t)$\n",
    "\n",
    "\n",
    "where $\\eta_x$ and $\\eta_y$ describe a noise contribution on the model. For example, for a car trying to drive at constant speed , these parameters can represent the wind force variations on the front of the car. The wind being impredictable (they can as well push or slow down the car) there is no choice but considering its contribution in the covariance matrix $Q$. So we will use the two simplified equations.\n",
    "\n",
    "On the other hand, the evolution of the positions $x$ and $y$ is well described by kinematics equations:<br />\n",
    "$x(t+1) = x(t) + v_x(t)$<br />\n",
    "$y(t+1) = y(t) + v_y(t)$<br />\n",
    "\n",
    "These equations (corresponding to a first order Taylor expansion) are perfectly valid as long as we assume that the acceleration is null (which is the case, since we assumed no speed variations on any component $x$ and $y$).\n",
    "\n",
    "Putting all these equations together gives:\n",
    "\n",
    "$x(t+1) = x(t) + v_x(t)$\n",
    "\n",
    "$y(t+1) = y(t) + v_y(t)$\n",
    "\n",
    "$v_x(t+1) = v_x(t)$\n",
    "\n",
    "$v_y(t+1) = v_y(t)$\n",
    "\n",
    "which is expressed in matrix form as:\n",
    "\n",
    "\n",
    "$$\n",
    "\\begin{bmatrix}\n",
    "x\\\\\n",
    "y\\\\\n",
    "v_x\\\\\n",
    "v_y\n",
    "\\end{bmatrix}_{t+1} = \\begin{bmatrix}\n",
    "1 & 0 & 1 & 0\\\\\n",
    "0 & 1 & 0 & 1\\\\\n",
    "0 & 0 & 1 & 0\\\\\n",
    "0 & 0 & 0 & 1\\\\\n",
    "\\end{bmatrix}\\begin{bmatrix}\n",
    "x\\\\\n",
    "y\\\\\n",
    "v_x\\\\\n",
    "v_y\n",
    "\\end{bmatrix}_{t} \n",
    "$$\n",
    "\n",
    "\n",
    "This is the matrix we are going to feed to the KF:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "4602a5ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "F = np.array([\n",
    "    [1, 0, 1, 0],\n",
    "    [0, 1, 0, 1],\n",
    "    [0, 0, 1, 0],\n",
    "    [0, 0, 0, 1]])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82367c61",
   "metadata": {},
   "source": [
    "Note that this matrix can be directly and equivalently formed from Dynamics library:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5d6973c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "F = trk.DYN_MAT_2D_CST_SPEED(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc31bd2d",
   "metadata": {},
   "source": [
    "The covariance matrix might be a bit tricky to parameterize, but we'll start like that: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "dc866ab0",
   "metadata": {},
   "outputs": [],
   "source": [
    "Q = np.array([\n",
    "    [1e-8, 0, 0, 0],\n",
    "    [0, 1e-8, 0, 0],\n",
    "    [0, 0, 2e-4, 0],\n",
    "    [0, 0, 0, 2e-4]])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7814d325",
   "metadata": {},
   "source": [
    "It can be easily interpreted: the bottom-right value 2e-4, means that the last dynamic equation $v_y(t+1) = v_y(t)$ is true, up to a random variable $\\eta_y$, whose variance is 2e-4 (i.e. with 0.01414 standard deviation). This means that, between two subsequent epochs in the track, the speed on each component $v_x$ and $v_y$ would typically not increase or decrease by more than 0.05 m/s ($3\\sigma$). Similarly, the value 1e-8 on the first top rows, means that the update equations on positions $x(t+1) = x(t) + v_x(t)$ and $y(t+1) = y(t) + v_y(t)$ are accurate up to a random noise of standard deviation 0.0001 m."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eea755aa",
   "metadata": {},
   "source": [
    "For the observation model, we will assume that the GPS provides (noisy) estimates of the position variables $x$ and $y$. The model $H$ is therefore a $2 \\times 4$ matrix (it takes as input the 4 state parameters, and computes 2 observation values). Since the observation are directly the first two state parameters, the relation is simply:\n",
    "\n",
    "$$\n",
    "\\begin{bmatrix}\n",
    "x_{GPS}\\\\\n",
    "y_{GPS}\n",
    "\\end{bmatrix}_{t+1} = \\begin{bmatrix}\n",
    "1 & 0 & 0 & 0\\\\\n",
    "0 & 1 & 0 & 0\n",
    "\\end{bmatrix}\\begin{bmatrix}\n",
    "x\\\\\n",
    "y\\\\\n",
    "v_x\\\\\n",
    "v_y\n",
    "\\end{bmatrix}_{t} \n",
    "$$\n",
    "\n",
    "and then $H$ is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e025673b",
   "metadata": {},
   "outputs": [],
   "source": [
    "H = np.array([\n",
    "    [1, 0, 0, 0],\n",
    "    [0, 1, 0, 0]])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3fcff6c",
   "metadata": {},
   "source": [
    "The first (resp. second) row describes the computation of observation on $x$ (resp $y$) from the GPS. Note that these observations are only noisy measurements on the actual unknown state parameters $x$ and $y$. The noise variance is given by the matrix $R$. We will assume that the GPS has an accuracy of about 1 m on each axis. There is no correlation between errors on each individual component so the matrix is diagonal: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "3989c414",
   "metadata": {},
   "outputs": [],
   "source": [
    "R = np.array([\n",
    "    [1, 0],\n",
    "    [0, 1]])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a0e92af",
   "metadata": {},
   "source": [
    "Eventually, we will set the initial state $X_0$ from the first two (noisy) observations of the GPS, stored in the positions of the track, and we will start with zero speed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "6c20966e",
   "metadata": {},
   "outputs": [],
   "source": [
    "X0 = np.array([\n",
    "    [track2[0].position.getX()],\n",
    "    [track2[0].position.getY()],\n",
    "    [0],\n",
    "    [0]])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d47095c9",
   "metadata": {},
   "source": [
    "We provide the associated variance on these initial estimates:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "67d11b50",
   "metadata": {},
   "outputs": [],
   "source": [
    "P0 = np.array([\n",
    "    [1, 0, 0, 0],\n",
    "    [0, 1, 0, 0],\n",
    "    [0, 0, 1e4, 0],\n",
    "    [0, 0, 0, 1e4]])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45d65357",
   "metadata": {},
   "source": [
    "Unsurprisingly, the variances set on the initial position $x$ and $y$ are the same as the GPS variance (since $X_0$ has been initialized from the GPS measurements, this seems to be a reasonable assumption). If we had a perfect information on the starting point we could set a much lower variance, for example 1e-4 if we had centimetric accuracy on the starting point. However, this is at risk of slow convergence if the starting point happens to be erroneous. In order to avoid too slow convergence of the filter, it is often better to be conservative on our knowledge of initialization, and set $P_0$ with high variances. That is the case for the speed. We don't know the initial speed of the mobile (no speed sensor) but assuming we are dealing with a terrestrial vehicle, an initial variance of speed of 1e4 (100 m/s standard deviation) on each axis, seems more than reasonable. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db9f89fb",
   "metadata": {},
   "source": [
    "Then, we can initialize a Kalman object with those 6 matrices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d1082a61",
   "metadata": {},
   "outputs": [],
   "source": [
    "UKF = trk.KalmanFilter()\n",
    "UKF.setTransition(F, Q)\n",
    "UKF.setObservation(H, R)\n",
    "UKF.setInitState(X0, P0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cb8d192",
   "metadata": {},
   "source": [
    "The second line creates the Kalman filter object. The third line is for the dynamics (a.k.a. transition) model. The fourth line inputs the observation model. Eventually, the initial state is specified in the fifth line. To check that our parameterization is correct, a convenient tool is provided with the summary function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "1a103307",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===========================================================\n",
      "Kalman filter\n",
      "Type: standard (KF)\n",
      "Stationnarity: Yes\n",
      "Number of states         n = 4\n",
      "Number of observations   m = 2\n",
      "===========================================================\n",
      "Dynamic model [n x n]:\n",
      "[[1 0 1 0]\n",
      " [0 1 0 1]\n",
      " [0 0 1 0]\n",
      " [0 0 0 1]]\n",
      "E.g. x = [[3 1 3 4]] => F(x) = [[6 5 3 4]]\n",
      "-----------------------------------------------------------\n",
      "Dynamic model covariance matrix [n x n]:\n",
      "[[1.e-08 0.e+00 0.e+00 0.e+00]\n",
      " [0.e+00 1.e-08 0.e+00 0.e+00]\n",
      " [0.e+00 0.e+00 2.e-04 0.e+00]\n",
      " [0.e+00 0.e+00 0.e+00 2.e-04]]\n",
      "===========================================================\n",
      "Observation model [m x n]:\n",
      "[[1 0 0 0]\n",
      " [0 1 0 0]]\n",
      "E.g. x = [[3 1 3 4]] => H(x) = [[3 1]]\n",
      "-----------------------------------------------------------\n",
      "Observation model covariance matrix [m x m]:\n",
      "[[1 0]\n",
      " [0 1]]\n",
      "===========================================================\n",
      "Initial state vector [n x 1]\n",
      "[[-48.88511049]\n",
      " [-12.97500723]\n",
      " [  0.        ]\n",
      " [  0.        ]]\n",
      "-----------------------------------------------------------\n",
      "Initial state covariance matrix [n x n]\n",
      "[[1.e+00 0.e+00 0.e+00 0.e+00]\n",
      " [0.e+00 1.e+00 0.e+00 0.e+00]\n",
      " [0.e+00 0.e+00 1.e+04 0.e+00]\n",
      " [0.e+00 0.e+00 0.e+00 1.e+04]]\n",
      "===========================================================\n"
     ]
    }
   ],
   "source": [
    "UKF.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a490b403",
   "metadata": {},
   "source": [
    "It sums up all the parameters of the KF and also provides typical examples of transitions and measurements to check that everything is correct. For example, the line \n",
    "\n",
    "E.g. x = [[3 1 3 4]] => F(x) = [[6 5 3 4]]  \n",
    "\n",
    "is provided to check that, under the model assumptions, if the state at time $t$ is $[3~1~3~4]^T$ then at next epoch $t+1$, it would be $[6~5~3~4]^T$. This is correct since indeed:\n",
    "\n",
    "$3 + 3 \\rightarrow 6~~$   ($x$ update)\n",
    "\n",
    "$1 + 4 \\rightarrow 5~~$   ($y$ update)\n",
    "\n",
    "$3 \\rightarrow 3~~$   ($v_x$ update, no speed change)\n",
    "\n",
    "$4 \\rightarrow 4~~$   ($v_y$ update, no speed change)\n",
    "\n",
    "Similarly, for the observation model, the same fictive state [[3 1 3 4]] would indeed give the observation (GPS) vector [[3 1]]."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a028b730",
   "metadata": {},
   "source": [
    "Finally, we can perform the estimation on the track2 (noisy version of ground truth). We specify that the $m=2$ observations required by UKF object can be retrieved in \"x\" and \"y\" (i.e. track positions) AFs of track2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "271d4b74",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[38;2;0;255;0m100%\u001b[39m \u001b[38;2;0;255;0m(360 of 360)\u001b[39m |######################| Elapsed Time: 0:00:00 Time:  0:00:000000\n"
     ]
    }
   ],
   "source": [
    "UKF.estimate(track2, [\"x\", \"y\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d5e3efe",
   "metadata": {},
   "source": [
    "Let's inspect the fields created in track2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "67d63d05",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------\n",
      "GPS track #0 of user 0:\n",
      "-------------------------------------\n",
      "  Nb of pt(s):   360\n",
      "  Ref sys id   : ENU\n",
      "  Starting at  : 05/02/2042 00:45:06\n",
      "  Ending at    : 05/02/2042 01:44:56\n",
      "  Duration     : 3590.000 s\n",
      "  Length       : 801.411 m\n",
      "-------------------------------------\n",
      "Analytical feature(s):\n",
      " - kf_0\n",
      " - kf_1\n",
      " - kf_2\n",
      " - kf_3\n",
      " - kf_0_std\n",
      " - kf_1_std\n",
      " - kf_2_std\n",
      " - kf_3_std\n",
      " - kf_x_inov\n",
      " - kf_x_inov_std\n",
      " - kf_y_inov\n",
      " - kf_y_inov_std\n",
      " - kf_gain\n",
      " - kf_P\n",
      "-------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "track2.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49322a31",
   "metadata": {},
   "source": [
    "All the fields created by the Kalman filter start with \"kf_\". The first four variables kf_0 to kf_3 are the estimated values (at each time step) of the four state parameters $x$, $y$, $v_x$ and $v_y$. The next four AFs kf_0_std to kf_3_std are their associated standard deviations. The complete $4 \\times 4$ covariance matrix can be retrieved in kf_P. All the other parameters are used for trouble-shooting of the KF. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a564b9c",
   "metadata": {},
   "source": [
    "To check out the results, we plot the original ground truth track (in black), the noisy observations from track2 (in red dots) and the filtered track (blue), where \"kf_0\" and \"kf_1\" are the two AFs containing the estimated states $x$ and $y$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "f0a524c0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "track1.plot('k-')\n",
    "plt.plot(track2['kf_0'], track2['kf_1'], 'b-')\n",
    "track2.plot('r+')\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fb1ec85",
   "metadata": {},
   "source": [
    "We can also plot the estimated speeds $v_x$ and $v_y$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "e2955d46",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(track2['kf_2'], 'b-')\n",
    "plt.plot(track2['kf_3'], 'r-')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9189907",
   "metadata": {},
   "source": [
    "It is interesting to repeat the experimentation with completely wrong initial estimate of position $x$. We then observe that the filter takes a bit longer to converge. The issue is instantly solve if we are more conservative on $P_0$ and set its top-left value to, for example, 1e6 (1000 m standard deviation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "0657db6a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[38;2;0;255;0m100%\u001b[39m \u001b[38;2;0;255;0m(360 of 360)\u001b[39m |######################| Elapsed Time: 0:00:00 Time:  0:00:000:00\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "X0 = np.array([\n",
    "    [100],\n",
    "    [0],\n",
    "    [0],\n",
    "    [0]])\n",
    "\n",
    "P0 = np.array([\n",
    "    [1, 0, 0, 0],\n",
    "    [0, 1, 0, 0],\n",
    "    [0, 0, 1e4, 0],\n",
    "    [0, 0, 0, 1e4]])\n",
    "\n",
    "UKF.setInitState(X0, P0)\n",
    "\n",
    "UKF.estimate(track2, [\"x\", \"y\"])\n",
    "\n",
    "track1.plot('k-')\n",
    "plt.plot(track2['kf_0'], track2['kf_1'], 'b-')\n",
    "track2.plot('r+')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a627aaa5",
   "metadata": {},
   "source": [
    "Let's see the evolution of the standard deviations of $x$ position (blue) and speed (red) estimates. It converges quite fast, even with the inaccurate initialization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "cb3ab475",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(track2['kf_0_std'], 'b-')\n",
    "plt.plot(track2['kf_2_std'], 'r-')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63ba6230",
   "metadata": {},
   "source": [
    "We can also plot the innovations: difference between the expected observation (based on the current estimation of parameters) and the actual observations. A large innovation occurs at the begining of the filter in case of wrong initialization. Here we see that the innovation is especially large on the $x$ observation, because $x$ is not initialized properly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "dc74b9e2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(track2['kf_x_inov'], 'b-')\n",
    "plt.plot(track2['kf_y_inov'], 'r-')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99520e15",
   "metadata": {},
   "source": [
    "Once the filter has converged, the innovation should be a white noise process of standard deviations given by the observation covariance matrix $R$. Here we retrieve the 1 m white noise of the GPS sensor on both axes $x$ and $y$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "30a52b00",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(track2['kf_x_inov'][40:], 'b-')\n",
    "plt.plot(track2['kf_y_inov'][40:], 'r-')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfc92b3e",
   "metadata": {},
   "source": [
    "It is interesting as well to repeat the experiment, but with wrong initialization on speed $v_x$ and too optimistic variance on speed initialization in $P_0$ (1 m/s standard deviation). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "6a7b53ff",
   "metadata": {
    "tags": [
     "nbsphinx-thumbnail"
    ]
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[38;2;0;255;0m100%\u001b[39m \u001b[38;2;0;255;0m(360 of 360)\u001b[39m |######################| Elapsed Time: 0:00:00 Time:  0:00:000:00\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "X0 = np.array([\n",
    "    [0],\n",
    "    [0],\n",
    "    [100],\n",
    "    [0]])\n",
    "\n",
    "P0 = np.array([\n",
    "    [1e6, 0, 0, 0],\n",
    "    [0, 1e6, 0, 0],\n",
    "    [0, 0, 1, 0],\n",
    "    [0, 0, 0, 1]])\n",
    "\n",
    "UKF.setInitState(X0, P0)\n",
    "\n",
    "UKF.estimate(track2, [\"x\", \"y\"])\n",
    "\n",
    "track1.plot('k-')\n",
    "plt.plot(track2['kf_0'], track2['kf_1'], 'b-')\n",
    "track2.plot('r+')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "781cfabd",
   "metadata": {},
   "source": [
    "Here also, the filter takes longer than expected to converge to steady-state."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53dcdb8c",
   "metadata": {},
   "source": [
    "Let's try another experiment: we will initialize the filter properly (unknown state arbitrarily set at zero values and large variance in covariance matrix) and simulate a fake corrupted data observations at epoch 200. This will in turn corrupt the KF estimation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "23def4cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[38;2;0;255;0m100%\u001b[39m \u001b[38;2;0;255;0m(360 of 360)\u001b[39m |######################| Elapsed Time: 0:00:00 Time:  0:00:000:00\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "X0 = np.array([\n",
    "    [0],\n",
    "    [0],\n",
    "    [0],\n",
    "    [0]])\n",
    "\n",
    "P0 = np.array([\n",
    "    [1e6, 0, 0, 0],\n",
    "    [0, 1e6, 0, 0],\n",
    "    [0, 0, 1e6, 0],\n",
    "    [0, 0, 0, 1e6]])\n",
    "\n",
    "track2[200].position.setX(40)\n",
    "track2[200].position.setY(40)\n",
    "\n",
    "UKF.setInitState(X0, P0)\n",
    "\n",
    "UKF.estimate(track2, [\"x\", \"y\"])\n",
    "\n",
    "track1.plot('k-')\n",
    "plt.plot(track2['kf_0'], track2['kf_1'], 'b-')\n",
    "track2.plot('r+')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb87a00d",
   "metadata": {},
   "source": [
    "However, fortunately, monitoring innovation AFs (\"kf_x_inov\" and \"kf_y_inov\" for the 2 available observations) helps to detect the problem. If the innovation on any given observation is too large (comparatively to its standard deviation), it suggests that observation is not reliable, and may be rejected.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "e216c706",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(track2['kf_x_inov'], 'b-')\n",
    "plt.plot(track2['kf_y_inov'], 'r-')\n",
    "\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
