Kidnapped vehicle project of Udacity Self-Driving Car Nanodegree (cf. repo).

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

• 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
• 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.

Your folder hierarchy should look like below:

.
├── CMakeLists.txt
├── data
│   └── map_data.txt
├── include
│   ├── json.hpp
│   └── spdlog
├── lib
│   └── catch.hpp
├── LICENSE
├── README.md
├── scripts
│   ├── format-project.sh
│   ├── install-cppdeps.sh
│   ├── install-linux.sh
│   └── install-mac.sh
├── src
│   ├── helpers.h
│   ├── main.cpp
│   ├── map.h
│   ├── particle_filter.cpp
│   └── particle_filter.h
├── static
│   └── images
└── test
    ├── helpers_test.cpp
    └── main_test.cpp

Now you can build the project:

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

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.

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:

===============================================================================
All tests passed (8 assertions in 2 test cases)

Run the recently built project using the following command:

build/ParticleFilter

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 Next twice then 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 predicted state vector (spatial and angular position) in 2D.

This Unity environment provides a set of landmarks located on a map, where a car moves in 2D.

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.

We follow the description of the Particle Filter algorithm.

In the src folder, you will find:

• main.cpp: reads measurement data from Unity3D, runs the particle filter and evaluate the predictions.
• map.h: formalizes a landmark class.
• particle_filters.cpp: implements the core particle filter prediction steps.
• helpers.h: distance & error computation, data reading.

The previously mentioned implementation yields good performances in regards to L1-distance on the state vector, and the prediction visualized as a blue circle reflects accurately the position and orientation of the car.

The implementation is evaluated using the absolute difference for each state vector's component over the datasets.

The full-length lap recording in bird-eye view are available for download in the release attachments:

• Full lap recording

Currently, the implementation feels a bit shaky and could be improved further. Here are a few leads to investigate:

1. Spatio-temporal smoothness: implementing a smoothing mechanism for state prediction could help improve this localization unit.
2. Number of particles: grid-searching the number of particles could help to improve the implementation efficiency.

This implementation is vastly based on the following methods:

• Particle Filter: Nonlinear Filetring: Interacting Particle Resolution (1996), Measure-valued processes and interacting particle systems (1998)

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