One Euro Filter (1€ Filter)

The 1€ filter (one Euro filter) is a simple algorithm designed to filter noisy signals while maintaining high precision and responsiveness. It works by using a first-order low-pass filter with an adaptive cutoff frequency:

• At low speeds: It uses a low cutoff frequency to stabilize the signal and reduce jitter.
• At high speeds: It increases the cutoff frequency to reduce lag.

It is characterized by being easy to implement, resource-efficient, and easy to tune using two primary parameters. Compared to other filters, it provides less lag for a given amount of jitter reduction.

The 1€ filter is available for multiple platforms and languages via the following package managers:

• Python: Install via PyPI using pip.
• JavaScript/TypeScript: Install via NPM using npm.
• Arduino: Available as an Arduino library.

# For Python
pip install OneEuroFilter

# For JavaScript/TypeScript
npm install 1eurofilter

Install the Python implementation of the 1€ filter using pip:

pip install OneEuroFilter --upgrade

To build a Docker image containing the 1€ filter implementations, run the build command from within the docker directory.

docker build -t oneeurofilter .

To run the container in detached mode with a bind mount that maps the current directory to /mnt/1euro inside the container, execute the following command from the parent folder of the docker directory:

docker run -i -t -d --name=oneeurofilter_con --mount type=bind,source=.,target=/mnt/1euro oneeurofilter

To interact with the running container, use docker exec to open a bash shell. Once inside, navigate to the mounted directory and use make to build the implementations.

docker exec -it oneeurofilter_con /bin/bash
cd /mnt/1euro
make

To use the TypeScript implementation of the 1€ filter, install the 1eurofilter package using npm.

npm install 1eurofilter

This example demonstrates how to initialize the filter with specific parameters and process a noisy value with a timestamp.

import {OneEuroFilter} from '1eurofilter'

let frequency = 120; // Hz
let mincutoff = 1.0; // Hz
let beta = 0.1;      
let dcutoff = 1.0; 

let f = new OneEuroFilter(frequency, mincutoff, beta, dcutoff);

let noisyvalue = 2.1;
let timestamp = 0.0; // in seconds

let filtered = f.filter(noisyvalue, timestamp);

To use the filter, instantiate the OneEuroFilter class with a configuration dictionary or specific parameters, then call the instance as a function with the noisy value and the current timestamp.

from OneEuroFilter import OneEuroFilter

config = {
    'freq': 120,       # Hz
    'mincutoff': 1.0,  # Hz
    'beta': 0.1,       
    'dcutoff': 1.0    
}

f = OneEuroFilter(**config)

# First parameter is the value to filter
# the second parameter is the current timestamp in seconds
filtered = f(2.1, 0)

You can update the filter's parameters after instantiation using the following methods:

• setBeta(beta: number): Sets the Beta parameter to reduce latency (> 0).
• setDerivateCutoff(dcutoff: number): Sets the dcutoff parameter used to filter derivates.
• setFrequency(freq: number): Sets the estimated frequency of the signal in Hz (> 0).
• setMinCutoff(mincutoff: number): Sets the min cutoff frequency in Hz (> 0). Lower values remove more jitter.
• setParameters(freq: number, mincutoff: number, beta: number): Sets the frequency, min cutoff, and beta parameters simultaneously.