Real-time Gaussian Filtering

2025-02-16 21:44 UTC o3-mini-high Open in ChatGPT ↗

When you apply a Gaussian “blur” (i.e. convolution with a Gaussian kernel) to a signal, you’re effectively doing low-pass filtering that is symmetric in time. That symmetry is what gives it a zero phase shift—but it also means the filter is non-causal, since it depends on future as well as past samples.

In a truly real‑time (causal) system like Unity’s, you can only work with past (and current) data. If you want to exactly cancel phase shifts by filtering both forward and backward (as in MATLAB’s filtfilt), you must buffer data and introduce a delay (roughly half your filter window). In other words, there’s a trade‑off:

Zero‑phase filtering: Achieved by applying the filter forward and then backward. This cancels phase shift but requires you to wait for future data (or use a delay buffer), which adds latency.
Causal filtering: You only use past data. This avoids buffering but will introduce some phase delay (and sometimes distortion) unless you use very clever predictive techniques.

Options to Consider in Unity/C#:

Forward–Backward Filtering (Non-Causal Zero-Phase):
If a small, fixed delay is acceptable, you can buffer your signal (say, a few frames or samples) and apply the filter in both directions. This will yield a zero-phase result at the cost of a delay of roughly half the window size.
Causal Low-Pass Filter with Minimal Delay:
You might design or use an IIR or FIR filter that approximates a Gaussian response. Although it won’t be perfectly zero‑phase, you can often tune it so the delay is minimal. For instance, a well-tuned exponential moving average (EMA) filter is simple and fast, though it inherently lags the input.
Predictive Filtering (e.g. Kalman Filter):
If you’re filtering noisy sensor data or similar, a Kalman filter can help “predict” the true signal while keeping the delay minimal. It won’t be the same as a Gaussian blur, but it can be very effective for real‑time applications.

Summary:
A true zero‑phase (symmetric Gaussian) filter isn’t possible in a strictly causal, real‑time system without buffering—and that buffering introduces a delay. So you must decide on the acceptable trade‑off between phase accuracy and latency.

If you’d like, I can help sketch out a C# example for one of these approaches. Which direction would you like to explore?

Below is an example of an efficient Exponential Moving Average (EMA) filter in C#. This implementation uses a simple one-line update formula:

$ y[n] = \alpha \cdot x[n] + (1 - \alpha) \cdot y[n-1] $

Where:

$x[n]$ is the current input.
$y[n]$ is the filtered output.
$\alpha$ is the smoothing factor between 0 and 1 (a lower value gives more smoothing but slower response).

Here’s the code:

using System;

public class EMAFilter
{
    // The smoothing factor (0 < alpha <= 1)
    private readonly float alpha;

    // The current filtered value
    private float filteredValue;

    // Flag to check if the filter has been initialized
    private bool initialized = false;

    /// <summary>
    /// Constructs an EMA filter with the specified smoothing factor.
    /// </summary>
    /// <param name="alpha">
    /// Smoothing factor.
    /// Closer to 0 means more smoothing (but slower response), and closer to 1 means less smoothing.
    /// Must be in the range (0, 1].
    /// </param>
    public EMAFilter(float alpha)
    {
        if (alpha <= 0 || alpha > 1)
            throw new ArgumentException("Alpha must be in the range (0, 1].");
        this.alpha = alpha;
    }

    /// <summary>
    /// Processes a new input sample and returns the filtered output.
    /// </summary>
    /// <param name="input">The new data point.</param>
    /// <returns>The updated EMA value.</returns>
    public float Update(float input)
    {
        if (!initialized)
        {
            filteredValue = input;
            initialized = true;
        }
        else
        {
            filteredValue = alpha * input + (1 - alpha) * filteredValue;
        }
        return filteredValue;
    }
}

How to Use the EMA Filter in Unity

For example, in a MonoBehaviour script, you might do:

using UnityEngine;

public class ExampleEMA : MonoBehaviour
{
    // Create an EMA filter with an alpha of 0.1 for heavy smoothing.
    private EMAFilter emaFilter = new EMAFilter(0.1f);

    void Update()
    {
        // Let's assume you have some noisy signal, e.g., from a sensor or input.
        float noisySignal = GetNoisySignal();

        // Update the EMA filter
        float filteredSignal = emaFilter.Update(noisySignal);

        // Use the filtered signal (e.g., for movement, effects, etc.)
        Debug.Log(filteredSignal);
    }

    private float GetNoisySignal()
    {
        // Replace with your actual signal. For now, let's simulate noise.
        return Mathf.Sin(Time.time) + Random.Range(-0.2f, 0.2f);
    }
}

Explanation

Initialization:
The first input sets the initial filtered value to ensure no abrupt jumps when filtering begins.
Update Method:
Each call to Update applies the EMA formula to incorporate the new sample.
Efficiency:
This implementation only performs a couple of arithmetic operations per sample, making it very efficient for real-time use in Unity.

Feel free to adjust the alpha value based on how much smoothing you need. A smaller alpha provides more smoothing but can lag behind rapid changes in the input signal.

Below is an updated version of the EMA filter where you can adjust the smoothing factor $ \alpha $ in real time via a property:

using System;

public class EMAFilter
{
    // Backing field for alpha
    private float _alpha;

    /// <summary>
    /// Gets or sets the smoothing factor.
    /// Must be in the range (0, 1]. A smaller value gives more smoothing.
    /// </summary>
    public float Alpha
    {
        get => _alpha;
        set
        {
            if (value <= 0 || value > 1)
                throw new ArgumentException("Alpha must be in the range (0, 1].");
            _alpha = value;
        }
    }

    // The current filtered value
    private float filteredValue;

    // Indicates whether the filter has been initialized
    private bool initialized = false;

    /// <summary>
    /// Constructs an EMA filter with the specified initial smoothing factor.
    /// </summary>
    /// <param name="alpha">
    /// Initial smoothing factor.
    /// Closer to 0 means more smoothing (but slower response), and closer to 1 means less smoothing.
    /// Must be in the range (0, 1].
    /// </param>
    public EMAFilter(float alpha)
    {
        Alpha = alpha;
    }

    /// <summary>
    /// Processes a new input sample and returns the filtered output.
    /// </summary>
    /// <param name="input">The new data point.</param>
    /// <returns>The updated EMA value.</returns>
    public float Update(float input)
    {
        if (!initialized)
        {
            filteredValue = input;
            initialized = true;
        }
        else
        {
            filteredValue = Alpha * input + (1 - Alpha) * filteredValue;
        }
        return filteredValue;
    }
}

How to Adjust $ \alpha $ in Real Time

For example, in a Unity MonoBehaviour you can modify the filter’s Alpha property based on game events or user input:

using UnityEngine;

public class ExampleEMA : MonoBehaviour
{
    // Start with an initial alpha value of 0.1 for heavy smoothing.
    private EMAFilter emaFilter = new EMAFilter(0.1f);

    void Update()
    {
        // Example: Adjust alpha based on player input (or any other runtime condition)
        if (Input.GetKeyDown(KeyCode.UpArrow))
        {
            // Increase alpha (reduce smoothing)
            emaFilter.Alpha = Mathf.Min(emaFilter.Alpha + 0.05f, 1f);
            Debug.Log("Alpha increased to: " + emaFilter.Alpha);
        }
        else if (Input.GetKeyDown(KeyCode.DownArrow))
        {
            // Decrease alpha (increase smoothing)
            emaFilter.Alpha = Mathf.Max(emaFilter.Alpha - 0.05f, 0.01f);
            Debug.Log("Alpha decreased to: " + emaFilter.Alpha);
        }

        // Get your new noisy signal (this is just a simulation)
        float noisySignal = Mathf.Sin(Time.time) + Random.Range(-0.2f, 0.2f);

        // Update the EMA filter with the new value
        float filteredSignal = emaFilter.Update(noisySignal);

        // Use the filtered signal (for example, update an object position or log it)
        Debug.Log(filteredSignal);
    }
}

Explanation

Property for $ \alpha $:
The Alpha property now allows you to get or set the smoothing factor at runtime. When you set a new value, it checks that the value is within the valid range $(0, 1]$.
Real-Time Adjustments:
In the example MonoBehaviour, pressing the up or down arrow keys will adjust the $ \alpha $ value, allowing you to control how much smoothing is applied as the application runs.

This approach gives you the flexibility to modify the filter’s response on the fly while still using an efficient and straightforward EMA implementation.

Below is an example of a lightweight, one‑dimensional Kalman filter implementation in C#. This implementation is designed for efficiency and can be used to filter a noisy signal in real time.

KalmanFilter Class

using System;

public class KalmanFilter
{
    /// <summary>
    /// Process noise covariance. This reflects the uncertainty in your model.
    /// </summary>
    public float Q { get; set; }

    /// <summary>
    /// Measurement noise covariance. This reflects the noise level in your measurements.
    /// </summary>
    public float R { get; set; }

    /// <summary>
    /// The current estimated value (state).
    /// </summary>
    public float X { get; private set; }

    // Error covariance – represents the estimated accuracy of X.
    private float P;

    // Kalman gain (computed each update).
    private float K;

    /// <summary>
    /// Initializes a new instance of the KalmanFilter.
    /// </summary>
    /// <param name="processNoise">The process noise covariance (Q).</param>
    /// <param name="measurementNoise">The measurement noise covariance (R).</param>
    /// <param name="initialEstimate">The initial state estimate.</param>
    /// <param name="initialErrorCovariance">The initial error covariance (P).</param>
    public KalmanFilter(float processNoise, float measurementNoise, float initialEstimate, float initialErrorCovariance)
    {
        Q = processNoise;
        R = measurementNoise;
        X = initialEstimate;
        P = initialErrorCovariance;
    }

    /// <summary>
    /// Processes a new measurement and returns the updated state estimate.
    /// </summary>
    /// <param name="measurement">The new measurement.</param>
    /// <returns>The updated estimate.</returns>
    public float Update(float measurement)
    {
        // Prediction update:
        // Increase the error covariance by process noise.
        P = P + Q;

        // Measurement update:
        // Compute the Kalman Gain.
        K = P / (P + R);

        // Update the estimate with the measurement.
        X = X + K * (measurement - X);

        // Update the error covariance.
        P = (1 - K) * P;

        return X;
    }
}

Explanation

Process Noise (Q):
Represents the uncertainty in your process or model. A higher $ Q $ means you trust your model less, so the filter will react more strongly to new measurements.
Measurement Noise (R):
Represents the noise in your sensor or measurement. A higher $ R $ means your measurements are less reliable, so the filter will trust the model more.
State (X) and Error Covariance (P):
$ X $ is your best estimate of the true state, while $ P $ quantifies the uncertainty in that estimate.
Kalman Gain (K):
This is calculated dynamically and determines how much weight is given to the new measurement versus the current estimate.

Example Usage in Unity

Below is a simple Unity MonoBehaviour example that uses the Kalman filter to smooth out a simulated noisy signal:

using UnityEngine;

public class ExampleKalman : MonoBehaviour
{
    // Create a Kalman filter instance.
    // You might need to tune Q, R, the initial estimate, and initial error covariance for your specific application.
    private KalmanFilter kalmanFilter = new KalmanFilter(
        processNoise: 0.1f,
        measurementNoise: 0.1f,
        initialEstimate: 0f,
        initialErrorCovariance: 1f);

    void Update()
    {
        // Simulate a noisy measurement (for example, a sine wave with added random noise)
        float measurement = GetNoisyMeasurement();

        // Update the Kalman filter with the new measurement.
        float filteredValue = kalmanFilter.Update(measurement);

        // Use the filtered value (e.g., update an object's position, log it, etc.)
        Debug.Log("Filtered Value: " + filteredValue);
    }

    /// <summary>
    /// Simulates a measurement by adding random noise to a sine wave.
    /// </summary>
    private float GetNoisyMeasurement()
    {
        return Mathf.Sin(Time.time) + UnityEngine.Random.Range(-0.2f, 0.2f);
    }
}

Tuning the Filter

Process Noise (Q):
Increase $ Q $ if your system is highly dynamic or if the process model is not very reliable.
Measurement Noise (R):
Increase $ R $ if your measurements are very noisy.

Adjust these parameters based on your application’s characteristics to achieve the desired balance between responsiveness and smoothness.

This efficient one‑dimensional Kalman filter should work well for many real‑time signal filtering tasks in Unity using C#.