Extended Kalman Filter

Extended Kalman Filter project of Udacity Self-Driving Car Engineer (cf. repo).

Table of Contents

• Getting Started
  • Prerequisites
  • Installation
• Usage
• Approach
• Credits
• License

Getting started

Prerequisites

• Unity3D: 3D game engine used for our simulation.
• make (>= 4.1 on Linux, Mac, >= 3.81 on Windows): the buildsystem of the project.
  • Linux: make is installed by default on most Linux distros
  • Mac: install Xcode command line tools to get make
  • Windows: Click here for installation instructions
• cmake 3.5 (or newer): buildsystem generator.
  • Any OS: click here for installation instructions
• gcc/g++ 5.4 (or newer): to compile the C++ code.
  • Linux: gcc / g++ is installed by default on most Linux distros
  • Mac: same deal as make - install Xcode command line tools
  • Windows: recommend using MinGW
• uWebSockets 0.13.0: to handle our web-server.
  • Linux/Mac: click here for installation instructions
  • Windows: use either Docker, VMware, or even Windows 10 Bash on Ubuntu to install uWebSocketIO
• json: to interact with JSON files (header-only).
  • Any OS: place the file in the include/ folder
• Eigen: for linear algebra (header-only).
  • Any OS: extract the archive and place the Eigen directory in the include/ folder
• Catch: for unittests (header-only)
  • Any OS: place the file in the lib/ folder
• spdlog: for console logging (header-only)
  • Any OS: extract the archive and place the include/spdlog directory in the include/ folder

Note: If you are running a Unix system, the installation scripts in the folder scripts/ will install all the requirements apart from Unity3D. From the repository's main directory, run bash scripts/install-linux.sh for Linux or run bash scripts/install-mac.sh for MacOS to install those dependencies.

Installation

C++

Your folder hierarchy should look like below:

.
├── CMakeLists.txt
├── include
│   ├── Eigen
│   ├── json.hpp
│   └── spdlog
├── lib
│   └── catch.hpp
├── LICENSE
├── README.md
├── scripts
│   ├── install-cppdeps.sh
│   ├── install-linux.sh
│   └── install-mac.sh
├── src
│   ├── FusionEKF.cpp
│   ├── FusionEKF.h
│   ├── kalman_filter.cpp
│   ├── kalman_filter.h
│   ├── main.cpp
│   ├── measurement_package.h
│   ├── tools.cpp
│   └── tools.h
├── static
│   └── images
└── test
    ├── main_test.cpp
    └── tools_test.cpp

Now you can build the project:

mkdir build && cd build
cmake .. && make && cd ..

Unity

After installing Unity3D, you will need an environment build to run the simulation. Download the appropriate build for your OS and extract it:

• Linux
• Mac
• Windows

If you encounter an issue with the above builds, please refer to the "Available Game Builds" section of this readme.

Usage

Unittests

By compiling the project previously, you created 2 executables. One of them is here to run unittests using Catch2. In order to run the tests, use the following command:

build/tests

which should yield something similar to:

[2020-03-27 12:28:17.342] [warning] Invalid argument dimensions - received sizes 0 and 1
[2020-03-27 12:28:17.343] [warning] Invalid argument dimensions - received sizes 1 and 0
[2020-03-27 12:28:17.343] [warning] Invalid argument dimensions - received sizes 2 and 1
[2020-03-27 12:28:17.343] [warning] Invalid state vector size - expected 4, received 2
[2020-03-27 12:28:17.343] [warning] Invalid measurement values - division by zero
===============================================================================
All tests passed (21 assertions in 2 test cases)

Project build

Run the recently built project using the following command:

build/ExtendedKF

The compiled program is now listening to events on port 4567 using a web server. We just need to run our Unity3D environment to see the results.

• Run the term2_sim executable after extracting the environment archive (you might have to make it executable on Unix systems).
• Select the Resolution and Graphics settings for your setup.
• Click on SELECT
• Click on Start

## Approach

This project has the particularity of using simulated data for evaluation, which easily solves the costs of collecting and annotating the data. The environment is not interactive for the user, the only accepted input is the prediction of position and velocity in 2D.

Environment

This Unity environment offers a dynamic motion measurement session over a car trajectory using several sensors with two datasets.

Dataset 1	Dataset 2

Both datasets include measurements from radar and LIDAR sensors. The environment will have the car follow a predefined trajectory and will expose the sensor measurements to our C++ program.

Please refer to this repository for further details.

Implementing an EKF

We follow the description of the Kalman Filter algorithm in its extended version, to accommodate non-linear motion.

In the src folder, you will find:

• main.cpp: reads measurement data from Unity3D, runs the EKF and evaluate the predictions.
• FusionEKF.cpp: initializes the filter, triggers the prediction and measurement update.
• kalman_filder.cpp: implements the prediction step and measurement update.
• tools.cpp: implements RMSE and Jacobian matrix computation.

Results

The previously mentioned implementation yields good performances in regards to RMSE on the state vector, and the prediction visualized in green reflects accurately the motion of the car.

The implementation is evaluated using the RMSE on the state vector component over the datasets.

State	Dataset 1	Dataset 2
Px	0.1377	0.1071
Py	0.0864	0.1044
Vx	0.4805	0.4433
Vy	0.4001	0.4582

Full-length lap recordings in bird-eye view are available for download in the release attachments:

• Dataset 1
• Dataset 2

Limitations and improvements

Now, our current filter runs with two sensors' information. Let us investigate the performances if we only keep one sensor information. You can do so by modifying the radar_enabled_ and laser_enabled_ values over here and recompile the project.

RMSE using only Radar

State	Dataset 1	Dataset 2
Px	0.2549	0.2924
Py	0.3479	0.3881
Vx	0.6409	0.6219
Vy	0.7622	0.8388

Switching to a single sensor brings about a significant performance drop. While RADAR measures both the position and velocity, it does not have the same precision as its laser counterpart.

RMSE using only LIDAR

State	Dataset 1	Dataset 2
Px	0.2370	0.1558
Py	0.1144	0.1550
Vx	0.8279	0.6908
Vy	0.5217	0.6126

As expected, since LIDAR provides only information about position and not velocity, the performances are better for position than with RADAR, but worse for velocity.

With that in mind, we can note two main advantages of combining both sensors' information to feed the filter:

1. increasing measurement reception frequency will help the filter to keep up with the current state.
2. coupling several sensors yields their respective advantages (precision on position for laser, availability of velocity measurement on radar).

Credits

This implementation is vastly based on the following methods:

• Kalman Filter: Contributions to the Theory of Optimal Control (1960), A New Approach to Linear Filtering and Prediction Problems (1960)

License

Distributed under the MIT License. See LICENSE for more information.