Code Issue Analysis

2025-07-17 10:23 UTC o4-mini-high Open in ChatGPT ↗

identify problems with this code

if (bodyRoot != null)
        {
            bodyRoot.position = isSmoothAllowed && smoothFactor != 0f ?
                Vector3.Lerp(bodyRoot.position, targetPos, smoothFactor * (useUnscaledTime ? Time.unscaledDeltaTime : Time.deltaTime)) : targetPos;
        }
        else
        {
            transform.position = isSmoothAllowed && smoothFactor != 0f ?
                Vector3.Lerp(transform.position, targetPos, smoothFactor * (useUnscaledTime ? Time.unscaledDeltaTime : Time.deltaTime)) : targetPos;
        }

Here are a few issues and code‐quality problems that stand out in this snippet:

Code duplication
You’re essentially doing the same “smooth or jump” logic twice—once for bodyRoot.position and again for transform.position. This makes the code harder to maintain (any change has to be made in two places) and clutters the intent.
Ternary overuse hurts readability
Embedding the isSmoothAllowed && smoothFactor != 0f ? … : … inside each assignment makes it hard to quickly see what the code is actually doing. You’d get much more clarity by pulling that condition and the calculation out into named variables or a helper method.
Unbounded interpolation factor
You multiply smoothFactor by a delta‐time, but you never clamp the result. If smoothFactor * deltaTime exceeds 1, Vector3.Lerp(a, b, t) will extrapolate beyond b. Likewise, if you ever gave smoothFactor a negative value, you’d end up extrapolating backwards. You should clamp your t into [0,1] (or explicitly guard that smoothFactor is non-negative).
Float comparison pitfalls
Comparing floats for exact zero (smoothFactor != 0f) is brittle. Better to do something like Mathf.Approximately(smoothFactor, 0f) or test smoothFactor > Mathf.Epsilon.
Null check ambiguity
Depending on how bodyRoot is destroyed (e.g. via Destroy()), it might not actually be null in C#, but become a “fake null” Unity object that throws if you try to access it. Better test if (bodyRoot) (Unity’s overloaded operator) or guard against bodyRoot.gameObject == null.
Mixing world vs. local
You directly set .position on whichever Transform you have. If you really meant to move something in local‐space, you should use .localPosition. It’s not clear from context whether that’s intended, but mixing them can sometimes produce unexpected results.
Performance micro-optimization
Calling that ternary and two vector lerps every frame is cheap, but you could cache the delta = useUnscaledTime ? Time.unscaledDeltaTime : Time.deltaTime once, and maybe even the target reference (bodyRoot ?? transform) once, to simplify the Update loop.

A cleaner refactoring might look like this:

void Update()
{
    // Pick which transform to move
    Transform mover = bodyRoot != null && bodyRoot.gameObject != null ? bodyRoot : transform;

    // Early out if no movement needed
    if (!isSmoothAllowed || smoothFactor <= Mathf.Epsilon)
    {
        mover.position = targetPos;
        return;
    }

    // Compute time step once
    float dt = useUnscaledTime ? Time.unscaledDeltaTime : Time.deltaTime;
    // Compute t in [0,1]
    float t = Mathf.Clamp01(smoothFactor * dt);

    mover.position = Vector3.Lerp(mover.position, targetPos, t);
}

Single null check & single assignment point
Clamped interpolation factor
Better float‐zero test
Clear separation of concerns (choose mover → compute dt → compute t → apply)

This not only fixes the logical pitfalls (unclamped Lerp, float‐zero comparison, Unity null semantics) but makes the code far more maintainable and self-documenting.

Summary

To address Kinect jitter while preserving the ability to follow sudden movements, you can replace a naïve lerp‐based smoother with more sophisticated filters that adapt their behavior based on signal velocity, noise characteristics, or modeled motion dynamics. Common choices include the One‐Euro filter, which dynamically adjusts its cutoff frequency based on speed to trade off jitter vs. lag citeturn0search5turn0search20; Kalman filters (and extensions) that predict the next pose using a motion model then correct it with measurements citeturn0search1turn0search6; Savitzky–Golay filters, which fit local polynomials to smooth without overly blurring sharp transitions citeturn0search12turn0search2; and median/threshold‐based methods that reject outlier jumps while allowing genuine rapid motion citeturn0search4turn0search19. More advanced approaches include alpha–beta filtering for reduced phase lag citeturn0search7, particle filters for non‐Gaussian noise and complex motion models citeturn0search23, or even learned smoothing via neural networks like SmoothNet citeturn0search0. Below we outline each, discuss trade‐offs, and offer implementation tips.

One-Euro Filter

Principle: A first-order low-pass filter whose cutoff $\omega_c$ varies with signal speed: low $\omega_c$ at low speed to suppress jitter, higher $\omega_c$ at high speed to reduce lag citeturn0search20turn0search5.
Parameters:
- $ \text{minCutoff} $: baseline cutoff when nearly stationary
- $ \beta $: speed‐dependent cutoff gain
- $ dCutoff $: cutoff for derivative smoothing
Pros: Easy to implement; only two or three tunable parameters; good jitter‐lag trade-off in practice citeturn0search5.
Cons: May introduce some initial lag; tuning requires empirical testing on your motion profiles citeturn0search15.

Kalman Filter (and Variants)

Principle: Maintains a state estimate (e.g., position & velocity) and covariance; at each step it predicts the next state via a motion model, then updates with the noisy measurement citeturn0search1turn0search6.
Variants:
- Extended KF for nonlinear dynamics (e.g., joint angles) citeturn0search6
- Unscented KF for higher‐order nonlinearities
Pros: Statistically optimal for Gaussian noise; can gracefully handle missing data and occlusions citeturn0search6.
Cons: More complex to tune (motion/measurement covariances); computational overhead higher than simple LPFs.

Savitzky–Golay Filter

Principle: Fits a low-degree polynomial over a sliding window to smooth while preserving features citeturn0search12turn0search2.
Pros: Excellent at maintaining sharp edges and peaks; non-recursive (no feedback) avoids drift.
Cons: Must choose window size and polynomial order carefully: too large smooths out real motion, too small leaves noise citeturn0search2; inherent latency equal to half the window length.

Median & Threshold Filters

Dynamic‐Threshold (DiscreteMedian) Filter: Rejects small jitters below a threshold, passes larger deltas unchanged citeturn0search4.
Median Filters: Replace each sample with the median of recent samples—robust to spikes citeturn0search19.
Pros: Simple; zero extra lag for large motions.
Cons: Threshold must be set to your sensor’s noise amplitude; median windows can blur rapid motion edges.

Advanced & Hybrid Filters

Alpha–Beta Filter: A simpler cousin of Kalman, with fixed gain parameters $\alpha$ (position) & $\beta$ (velocity) for low phase lag and easy tuning citeturn0search7.
Particle Filter: Represents the posterior with a sample set—handles non-Gaussian noise & multimodal distributions citeturn0search23.
Learned Filters: E.g. SmoothNet, a neural‐network-based refiner that learns to remove jitter while preserving motion from data citeturn0search0.

Trade-Offs & Choosing the Right Filter

Filter	Jitter Suppression	Lag & Responsiveness	Complexity
One-Euro	High at low speed	Good at high speed	Low
Kalman	Very high	Tunable	Medium–High
Savitzky–Golay	Moderate	Fixed by window	Medium
Median/Threshold	Depends on threshold	Zero for large moves	Low
Alpha–Beta	Moderate	Low phase lag	Low
Particle/NN-Based	Potentially very high	Very responsive	High

Implementation Tips

Parameter Calibration
- Record representative motion and jitter data.
- Sweep filter parameters (e.g., $\text{minCutoff}$ & $\beta$ for One-Euro; process & measurement covariances for Kalman) to find the best jitter–lag balance.
Derivative Estimation
- Most adaptive filters (One-Euro, alpha–beta) require estimating velocity. Use a small smoothing window or a separate low-pass on the derivative to avoid amplifying noise.
Clamping & Safety
- Clamp interpolation gains ($t\in[0,1]$) to prevent overshoot.
- Enforce non‐negative filter parameters.
Hybrid Strategies
- Combine coarse median filtering to remove spikes, followed by One-Euro for smoothness.
- Switch filters dynamically based on detected motion magnitude.
Performance Considerations
- For real-time (>30 Hz), prefer lightweight filters (One-Euro, alpha–beta).
- Offload heavy methods (particle filters, deep nets) to a separate thread or GPU if needed.

By selecting and tuning one of these filters—such as the One-Euro for simplicity or a Kalman variant for statistical rigor—you can significantly reduce Kinect jitter while still faithfully capturing rapid, expressive motion.

Below is a Unity C# implementation of the One-Euro filter—a simple, adaptive low-pass filter that reduces jitter at low speeds and minimizes lag at high speeds. The One-Euro filter consists of two cascaded components: a low-pass filter on the signal’s derivative and a low-pass filter on the signal itself with a cutoff that adapts based on the derivative’s magnitude. This implementation follows the original algorithm by Casiez et al. (CHI 2012) and leverages common Unity C# patterns for easy integration.

1. Algorithm Overview

1.1 Low-Pass Filter

A first-order exponential low-pass filter (LPF) updates its state $y$ via:
$ y_t = \alpha , x_t + (1 - \alpha), y_{t-1} $
where $\alpha = \tfrac{1}{1 + \tfrac{1}{2\pi f_c \Delta t}}$ and $f_c$ is the cutoff frequency in Hz citeturn0search5.

1.2 One-Euro Filter

The One-Euro filter uses:

Derivative LPF to smooth the estimated derivative $\dot{x}$.
Adaptive cutoff for the signal LPF:
$ f_c(t) = \text{minCutoff} + \beta , |\widehat{\dot{x}}_t| $
Signal LPF with cutoff $f_c(t)$.
This yields low noise when $|\dot{x}|$ is small, and low lag when $|\dot{x}|$ is large citeturn0search0turn0search3.

2. Unity C# Implementation

2.1 LowPassFilter Class

public class LowPassFilter {
    private float y;      // filter state
    private float a;      // smoothing factor
    private bool initialized = false;

    // Compute smoothing factor alpha from cutoff and dt
    private float ComputeAlpha(float cutoff, float dt) {
        float rc = 1f / (2f * Mathf.PI * cutoff);
        return dt / (dt + rc);
    }

    public float Filter(float x, float dt, float cutoff) {
        float alpha = ComputeAlpha(cutoff, dt);           // α = dt / (dt + 1/(2πfc))
        if (!initialized) {
            y = x;
            initialized = true;
        } else {
            y = alpha * x + (1f - alpha) * y;             // y ← αx + (1–α)y
        }
        return y;
    }

    public void Reset() {
        initialized = false;
    }
}

This class uses Unity’s Mathf.PI and is based on the reference C++ implementation by Nicolas Roussel citeturn0search4.

2.2 OneEuroFilter Class

public class OneEuroFilter {
    private LowPassFilter xFilter;      // for the signal
    private LowPassFilter dxFilter;     // for the derivative
    private float minCutoff;            // baseline cutoff frequency
    private float beta;                 // cutoff slope
    private float dCutoff;              // cutoff for derivative
    private float lastTime;

    public OneEuroFilter(float minCutoff = 1f, float beta = 0f, float dCutoff = 1f) {
        this.minCutoff = minCutoff;
        this.beta = beta;
        this.dCutoff = dCutoff;
        xFilter = new LowPassFilter();
        dxFilter = new LowPassFilter();
        lastTime = Time.realtimeSinceStartup;
    }

    public float Filter(float x) {
        float now = Time.realtimeSinceStartup;
        float dt = now - lastTime;
        lastTime = now;

        // 1) estimate derivative of the signal
        float dx = (x - xFilter.Filter(x, dt, minCutoff)) / Mathf.Max(dt, 1e-6f);
        float edx = dxFilter.Filter(dx, dt, dCutoff);

        // 2) adapt cutoff
        float cutoff = minCutoff + beta * Mathf.Abs(edx);

        // 3) filter the signal
        return xFilter.Filter(x, dt, cutoff);
    }

    public void Reset() {
        xFilter.Reset();
        dxFilter.Reset();
        lastTime = Time.realtimeSinceStartup;
    }
}

This mirrors the Unity sample by Keijiro Takahashi and the Dario Mazzanti port citeturn0search1turn0search2.

2.3 Usage Example in a MonoBehaviour

public class SmoothedMotion : MonoBehaviour {
    public Transform bodyRoot;
    public float minCutoff = 1f;
    public float beta = 0.005f;
    public float dCutoff = 1f;

    private OneEuroFilter filterX, filterY, filterZ;

    void Start() {
        filterX = new OneEuroFilter(minCutoff, beta, dCutoff);
        filterY = new OneEuroFilter(minCutoff, beta, dCutoff);
        filterZ = new OneEuroFilter(minCutoff, beta, dCutoff);
    }

    void Update() {
        Vector3 rawPos = GetKinectPosition();               // your own input
        float fx = filterX.Filter(rawPos.x);
        float fy = filterY.Filter(rawPos.y);
        float fz = filterZ.Filter(rawPos.z);
        Vector3 smoothPos = new Vector3(fx, fy, fz);
        (bodyRoot != null ? bodyRoot : transform).position = smoothPos;
    }
}

You may also filter rotation components or custom axes. This per-axis approach is recommended in Jaan Tollander’s tutorial citeturn0search3.

3. Parameter Tuning

minCutoff: Lower values suppress more jitter when nearly stationary; typical range 0.1–10 Hz citeturn0search5.
beta: Higher β reduces lag during fast motion; start around 0.005–0.1 and adjust to taste citeturn0search12.
dCutoff: Smoothing on the derivative; similar range as minCutoff; prevents derivative spikes citeturn0search3.

Record sample motion data, sweep parameters, and visualize error vs. lag to find the sweet spot.

4. Integration Tips

Vector3 support: Wrap three filters or implement a Filter(Vector3) overload.
Reset on occlusion: Call Reset() when tracking is lost to avoid large jumps.
Thread safety: If sampling Kinect in a background thread, synchronize calls to Filter().
Performance: The filter uses a handful of floating-point ops per sample—lightweight enough for 60+ Hz updates citeturn0search6.

With this implementation in place, you’ll enjoy smooth, responsive motion tracking that gracefully handles both jittery noise and rapid, dynamic movements.

In the One-Euro filter, minCutoff, beta, and dCutoff work together to balance jitter suppression against responsiveness:

minCutoff sets the baseline low-pass cutoff in Hz, directly trading off between noise reduction at low speeds and added lagciteturn0search1turn1search1.
beta scales how much the cutoff increases with signal speed, reducing latency during rapid motion but—if set too high—potentially passing through jitterciteturn0search1turn0search3.
dCutoff smooths the derivative estimate used by beta, preventing erratic cutoff jumps while still allowing the filter to adapt quickly on genuine speed changesciteturn0search3turn0search1.
A practical tuning workflow is to start with minCutoff ≈ 1 Hz, beta ≈ 0.001–0.01, and dCutoff ≈ 1 Hz, then first adjust minCutoff at low speeds (with beta = 0) to eliminate jitter, and then raise beta to reduce lag on fast movementsciteturn0search2turn0search5.

What it controls

minCutoff defines the minimum cutoff frequency of the underlying first-order low-pass filter in hertz; it must be strictly positiveciteturn0search1turn0search3.
A lower minCutoff value increases smoothing at low speeds, aggressively suppressing jitter but introducing more phase lag (i.e., latency) in trackingciteturn0search1turn0search5.

Tuning strategy

Zero-Beta baseline: Temporarily set beta to 0, so the cutoff never rises above minCutoff. citeturn0search2
Slow-motion test: Move the tracked body part very slowly and reduce minCutoff until jitter is acceptably low without noticeable lag. citeturn0search5
Iterate: Increase minCutoff if lag is too great, decrease if jitter remains. Ensure minCutoff > 0 at all times. citeturn0search2

Recommended ranges

Default: 1 Hz in most implementations (e.g., NPM, Unity ports)citeturn0search1turn0search3.
Typical: 0.1–10 Hz; values near 0.1 Hz yield heavy smoothing (good for very noisy sensors), while values above 10 Hz apply minimal smoothingciteturn0search1turn0search3.

What it controls

beta is the speed coefficient that determines how much the filter’s cutoff frequency increases proportionally to the magnitude of the filtered derivative (i.e., speed)citeturn1search0turn0search1.
A higher beta raises the cutoff rapidly during fast motions, reducing lag but at the cost of potentially letting through more high-frequency noiseciteturn0search3turn1search0.

Tuning strategy

Hold minCutoff constant (from your low-speed tuning) and perform rapid motions.
Start small: try beta = 0.001 or 0.0001, then multiply/divide by 10 until fast movements feel responsive without overshootciteturn0search2turn1search4.
Check jitter: if noise reappears at moderate speeds, dial beta back downciteturn1search4.

Recommended ranges

Default: 0.0 (no adaptive component)citeturn0search1turn0search3.
Common: 0.001–0.1 in interactive motion tracking; 0.005–0.05 often balances lag vs. noise well in Kinect-style dataciteturn0search2turn0search5.

What it controls

dCutoff sets the cutoff frequency (in Hz) of the low-pass filter applied to the signal’s derivative (speed estimate) before computing the adaptive cutoffciteturn0search1turn0search3.
A lower dCutoff more heavily smooths rapid changes in estimated speed, preventing abrupt jumps in the adaptive cutoff but introducing additional lag in responding to genuine accelerationsciteturn0search3turn1search0.

Tuning strategy

Balance spikes vs. responsiveness: if you observe erratic jitter bursts when motion starts or stops, lower dCutoff toward 0.5–1 Hz to tame spikes. citeturn0search3
If the filter feels sluggish to react to speed changes, raise dCutoff up to 5–10 Hz, at the risk of passing through more derivative noiseciteturn0search3turn2search1.

Recommended ranges

Default: 1 Hz in most libraries (e.g., NPM, Unity)citeturn0search1turn0search3.
Practical: 0.5–5 Hz; start at 1 Hz and adjust in factor-of-two steps based on derivative spike behavior. citeturn0search3turn2search1.

By following these tooltips and citations to authoritative implementations and tuning guides, you can systematically dial in minCutoff, beta, and dCutoff to achieve smooth, responsive filtering that handles both subtle Kinect jitter and sudden, strong motions.

Here’s a concise recipe for extending the One-Euro filter to quaternions by working in their tangent (axis–angle) space rather than naïvely SLERP’ing with an adaptive $t$. The core idea is:

Map each new measurement $q_{\text{meas}}$ into a small rotation vector via
$ \Delta q = q_{\text{prev}}^{-1},q_{\text{meas}},\quad \mathbf{v} = \log(\Delta q)\in\mathbb{R}^3 $
Filter that 3-vector $\mathbf{v}$ component-wise with a standard One-Euro filter.
Reconstruct the smoothed quaternion by
$ \Delta \hat q = \exp(\widehat{\mathbf{v}}),\quad q_{\text{new}} = q_{\text{prev}},\Delta \hat q $ This preserves unit-length, handles flips, and adapts smoothing based on rotational speed.

1. Why naïve SLERP falls short

Fixed cutoff: SLERP with $t=\alpha(\lVert\omega\rVert)$ still uses a single blending factor and can’t simultaneously suppress low-speed jitter while reacting quickly to large rotations citeturn0search0turn0search2.
Flip artifacts: Direct interpolation across the $w$-sign boundary causes “ping-pong” flips if quaternions aren’t unwrapped citeturn0search0.
No adaptation: There’s no mechanism to raise the interpolation “speed” when angular velocity spikes, so fast movements always lag.

2. Tangent-space filtering via log/exp maps

Quaternions live on the unit 3-sphere $S^3$, but their tangent space at a reference $q_{\text{prev}}$ is Euclidean. We can:

Logarithm

// Δq = q_prev⁻¹ * q_meas
Quaternion delta = Quaternion.Inverse(qPrev) * qMeas;
float angle;
Vector3 axis;
delta.ToAngleAxis(out angle, out axis);            // Unity built-in citeturn4search3
if (angle > 180f) angle -= 360f;                   // unwrap
Vector3 v = axis.normalized * Mathf.Deg2Rad * angle;

Filter
- Run the Vector3 v through three separate One-Euro filters (one per component) using your existing OneEuroFilter class citeturn1view0.

Exponential

Vector3 fv = new Vector3(fx, fy, fz);              // filtered axis-angle
float fAngle = fv.magnitude;
Vector3 fAxis = fAngle > 1e-6f ? fv / fAngle : Vector3.right;
Quaternion fDelta = Quaternion.AngleAxis(fAngle * Mathf.Rad2Deg, fAxis);
Quaternion qNew = qPrev * fDelta;
qPrev = qNew;                                      // update state

This pipeline cleanly suppresses small jitters (when $|v|$ is small) and lets the cutoff rise automatically under rapid spins, exactly as in the original One-Euro design citeturn3search12turn3search10.

3. Complete C# class

public class OneEuroQuaternionFilter
{
    Vector3 lastV;                           // last raw log-vector
    Quaternion lastQ;                        // last filtered quaternion
    OneEuroFilter fx, fy, fz;                // per-component filters

    public OneEuroQuaternionFilter(
      float freq = 120f, float minCutoff = 1f,
      float beta = 0.005f, float dCutoff = 1f)
    {
        fx = new OneEuroFilter(freq, minCutoff, beta, dCutoff);
        fy = new OneEuroFilter(freq, minCutoff, beta, dCutoff);
        fz = new OneEuroFilter(freq, minCutoff, beta, dCutoff);
        lastQ = Quaternion.identity;
    }

    public Quaternion Filter(Quaternion qMeas)
    {
        // 1) Compute log-map into tangent space
        Quaternion delta = Quaternion.Inverse(lastQ) * qMeas;
        Vector3 v = LogMap(delta);

        // 2) Adaptive smoothing of each component
        float svx = fx.Filter(v.x);
        float svy = fy.Filter(v.y);
        float svz = fz.Filter(v.z);
        Vector3 sv = new Vector3(svx, svy, svz);

        // 3) Reconstruct quaternion and update
        Quaternion fDelta = ExpMap(sv);
        lastQ = lastQ * fDelta;
        return lastQ;
    }

    static Vector3 LogMap(Quaternion q)
    {
        q.Normalize();
        float angle;
        Vector3 axis;
        q.ToAngleAxis(out angle, out axis);      // Unity built-in citeturn4search3
        if (angle > 180f) angle -= 360f;
        return axis.normalized * angle * Mathf.Deg2Rad;
    }

    static Quaternion ExpMap(Vector3 v)
    {
        float angle = v.magnitude;
        if (angle < 1e-6f) return Quaternion.identity;
        Vector3 axis = v / angle;
        return Quaternion.AngleAxis(angle * Mathf.Rad2Deg, axis);
    }
}

LogMap/ExpMap implement the quaternion manifold log/exp using Unity’s ToAngleAxis/AngleAxis.
Filters fx, fy, fz are the standard One-Euro filters you already have for floats citeturn1view0.

4. Usage example

public class KinectSmoothed : MonoBehaviour
{
    public Transform bodyRoot;
    OneEuroQuaternionFilter rotFilter;

    void Start()
    {
        rotFilter = new OneEuroQuaternionFilter(
            freq: 60f, minCutoff: 1f, beta: 0.01f, dCutoff: 1f);
    }

    void Update()
    {
        Quaternion rawRot = GetKinectRotation();      // your input
        Quaternion smoothRot = rotFilter.Filter(rawRot);
        (bodyRoot != null ? bodyRoot : transform).rotation = smoothRot;
    }
}

This ensures smooth, jitter-free head/body orientation tracking that still snaps to fast gestures.

5. Alternative approaches

Generic Quaternion Filter utils: Meta’s Unity Core SDK provides
```
var qFilter = OneEuroFilter.CreateQuaternion();
var smoothQ = qFilter.Filter(rawQ);
```
under the hood it does the same tangent-space trick citeturn0search3.
Direct SLERP with adaptive $t$: simpler but less robust to sign flips and angular wraparound citeturn3search10.
Particle/Kalman filters: heavier but statistically optimal for sensor fusion scenarios citeturn3search5.

This tangent–space extension preserves the One-Euro filter’s core benefits—easy tuning, minimal parameters, and real-time performance—while correctly handling the manifold structure of rotations.

Summary

Our existing OneEuroQuaternionFilter mistakenly presumed that the underlying OneEuroFilter took an explicit sampling frequency argument—however, our Unity C# OneEuroFilter computes its time step (dt) internally via Time.realtimeSinceStartup and only requires minCutoff, beta, and dCutoff parameters citeturn0search2. To correct this, we should remove the freq parameter from the quaternion filter’s constructor and its usage, instantiating three per-axis filters solely with the three cutoff parameters. This keeps the API consistent and avoids confusion between frequency-based and delta-time-based designs citeturn0search1.

Updated OneEuroQuaternionFilter (no frequency arg)

public class OneEuroQuaternionFilter
{
    private Quaternion lastQ = Quaternion.identity;
    private readonly OneEuroFilter fx, fy, fz;

    /// <summary>
    /// Constructs a quaternion One-Euro filter using only cutoff parameters.
    /// </summary>
    /// <param name="minCutoff">Base cutoff frequency in Hz (must be > 0).</param>
    /// <param name="beta">Speed sensitivity coefficient (>= 0).</param>
    /// <param name="dCutoff">Cutoff frequency for derivative smoothing in Hz.</param>
    public OneEuroQuaternionFilter(
        float minCutoff = 1f,
        float beta = 0.005f,
        float dCutoff = 1f)
    {
        fx = new OneEuroFilter(minCutoff, beta, dCutoff);
        fy = new OneEuroFilter(minCutoff, beta, dCutoff);
        fz = new OneEuroFilter(minCutoff, beta, dCutoff);
    }

    /// <summary>
    /// Filters the incoming measured quaternion, suppressing jitter while
    /// preserving rapid rotations.
    /// </summary>
    public Quaternion Filter(Quaternion qMeas)
    {
        // Compute the small‐angle log map in tangent space
        Quaternion delta = Quaternion.Inverse(lastQ) * qMeas;
        Vector3 v = LogMap(delta);

        // Filter each component with our Three One-Euro filters
        float sx = fx.Filter(v.x);
        float sy = fy.Filter(v.y);
        float sz = fz.Filter(v.z);

        // Reconstruct quaternion via exp map and update state
        Quaternion fDelta = ExpMap(new Vector3(sx, sy, sz));
        lastQ = lastQ * fDelta;
        return lastQ;
    }

    // Converts a quaternion to its axis–angle vector (radians)
    private static Vector3 LogMap(Quaternion q)
    {
        q.Normalize();
        q.ToAngleAxis(out float angleDeg, out Vector3 axis);
        if (angleDeg > 180f) angleDeg -= 360f;
        return axis.normalized * Mathf.Deg2Rad * angleDeg;
    }

    // Converts an axis–angle vector back to quaternion
    private static Quaternion ExpMap(Vector3 v)
    {
        float angleRad = v.magnitude;
        if (angleRad < 1e-6f) return Quaternion.identity;
        Vector3 axis = v / angleRad;
        return Quaternion.AngleAxis(angleRad * Mathf.Rad2Deg, axis);
    }
}

Key Changes

Removed freq parameter
We no longer pass a sampling frequency into OneEuroFilter; instead, each filter computes dt internally from Time.realtimeSinceStartup citeturn0search2.
Constructor signature
Now takes only (minCutoff, beta, dCutoff), matching the float-based filter’s API citeturn0search2.
Consistent per-axis filtering
We instantiate three identical filters (fx, fy, fz) using the same cutoff parameters, then reconstruct the quaternion via log/exp maps—preserving the unit-length constraint and handling flips correctly citeturn0search3.

With this alignment, your quaternion smoothing pipeline remains both conceptually clear and API-consistent with the rest of your One-Euro filter code.

Summary

Your avatar spinning out likely stems from a combination of quaternion “flips” at the 180° boundary, accumulated drift (i.e. loss of unit-length), and occasional zero or erratic timestep values—each of which wreak havoc on the log-exp filtering pipeline. The classic remedies are:

Keep quaternions continuous by flipping the sign of incoming measurements whenever they’re more than 90° “away” (negative dot-product) citeturn1view0.
Re-normalize after every compose (or switch to NLERP) so you never stray off the unit sphere citeturn0search5.
Initialize on the very first frame (set lastQ = qMeas) to avoid a huge first-step jump.
Guard your dt (e.g. clamp Time.realtimeSinceStartup deltas to ≥ε) so you don’t accidentally divide by zero or get massive spikes after a pause citeturn3search7.

1. Root Causes

1.1 Quaternion Sign Flips

Quaternions have two equivalent representations ±q. Without forcing continuity, your filter’s LogMap sees a 180° jump whenever the incoming quaternion flips sign—resulting in a massive axis-angle vector that “sloshes” the avatar around citeturn1view0.

1.2 Drift from Unit-Length

Every multiply and SLERP step can introduce floating-point error. If you never re-normalize, the quaternion length drifts away from 1.0, and subsequent LogMap/ExpMap calls yield distorted rotations citeturn0search5.

1.3 SLERP vs. NLERP Artifacts

Standard SLERP maintains constant angular velocity but can still overshoot slightly and is more expensive. Many real-time systems instead use a normalized LERP (NLERP), which is faster and often more stable for small-angle filtering citeturn2search9.

1.4 Erratic or Zero ∆t

Using Time.realtimeSinceStartup for dt can yield zero if the system timer resolution isn’t updated every frame, or huge deltas after pauses/backgrounding—leading to either divide-by-zero spikes or huge filter jumps citeturn3search7.

2. Solutions

Flip Incoming Quaternion

if (Quaternion.Dot(lastQ, qMeas) < 0f) {
    qMeas = new Quaternion(-qMeas.x, -qMeas.y, -qMeas.z, -qMeas.w);
}

This guarantees the smallest rotation path and prevents ping-pong flips citeturn1view0.

Normalize After Composition
```
lastQ = lastQ * fDelta;
lastQ = lastQ.normalized;
```
Ensures you stay exactly on the unit 3-sphere and avoids drift citeturn0search5.
Initialize State Once
```
if (!initialized) {
    lastQ = qMeas;
    initialized = true;
    return lastQ;
}
```
Avoids a gigantic first jump by seeding the filter with the true starting orientation.

Clamp ∆t

float now = Time.realtimeSinceStartup;
float dt = Mathf.Max(now - lastTime, 1e-6f);
lastTime = now;

Prevents zero or huge deltas from destabilizing the adaptive cutoff citeturn3search7.

Consider NLERP Instead of SLERP

// Quaternion nlerp
Quaternion fDelta = Quaternion.Lerp(Quaternion.identity, ExpMap(filteredV), t);
fDelta.Normalize();

Often smoother and cheaper than SLERP for high-update filters citeturn2search9.

3. Updated C# Snippet

public class OneEuroQuaternionFilter {
    private Quaternion lastQ;
    private bool initialized = false;
    private readonly OneEuroFilter fx, fy, fz;
    private float lastTime;

    public OneEuroQuaternionFilter(float minCutoff = 1f, float beta = 0.005f, float dCutoff = 1f) {
        fx = new OneEuroFilter(minCutoff, beta, dCutoff);
        fy = new OneEuroFilter(minCutoff, beta, dCutoff);
        fz = new OneEuroFilter(minCutoff, beta, dCutoff);
        lastTime = Time.realtimeSinceStartup;
    }

    public Quaternion Filter(Quaternion qMeas) {
        // 1) Initialization
        if (!initialized) {
            lastQ = qMeas;
            initialized = true;
            return lastQ;
        }

        // 2) Ensure shortest path
        if (Quaternion.Dot(lastQ, qMeas) < 0f) {
            qMeas = new Quaternion(-qMeas.x, -qMeas.y, -qMeas.z, -qMeas.w);
        }

        // 3) Compute dt (clamped)
        float now = Time.realtimeSinceStartup;
        float dt = Mathf.Max(now - lastTime, 1e-6f);
        lastTime = now;

        // 4) Log-Map to axis-angle vector
        Vector3 v = LogMap(Quaternion.Inverse(lastQ) * qMeas);

        // 5) Filter each component
        float sx = fx.Filter(v.x), sy = fy.Filter(v.y), sz = fz.Filter(v.z);
        Vector3 sv = new Vector3(sx, sy, sz);

        // 6) Exp-Map back to quaternion (you can switch to NLERP if preferred)
        Quaternion fDelta = ExpMap(sv);

        // 7) Compose & normalize
        lastQ = (lastQ * fDelta).normalized;
        return lastQ;
    }

    private static Vector3 LogMap(Quaternion q) {
        q.Normalize();
        q.ToAngleAxis(out float angleDeg, out Vector3 axis);
        if (angleDeg > 180f) angleDeg -= 360f;
        return axis.normalized * angleDeg * Mathf.Deg2Rad;
    }

    private static Quaternion ExpMap(Vector3 v) {
        float angle = v.magnitude;
        if (angle < 1e-6f) return Quaternion.identity;
        Vector3 axis = v / angle;
        return Quaternion.AngleAxis(angle * Mathf.Rad2Deg, axis);
    }
}

4. Best Practices

Tuning: Follow the two-step procedure from Casiez et al.—set β=0, tune minCutoff on slow motion, then increase β to reduce lag at speed citeturn2search3.
Reset on Teleport/Occlusion: Call Reset() on your filters whenever you know the avatar jumps position/orientation discontinuously.
Performance: Filtering three floats per frame plus small quaternion math is very light; prefer these corrections over heavier Kalman or particle filters for interactive systems.

By enforcing quaternion continuity, normalizing religiously, guarding your timestep, and initializing correctly, your One-Euro quaternion filter should smooth jitter without sending your avatar into orbit.

use this as guide and update the scripts accordingly. Only make changes where necessary. comment thoroughly

/** @file @brief Header file that completely implements a direction and orientation filter on tracking reports; it does not implement an actual server, it is intended to be built into a server.

@date 2012

@author
Jan Ciger
<jan.ciger@reviatech.com>

// Copyright Reviatech 2012. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt)

#pragma once

// Internal Includes #include <quat.h>

// Library/third-party includes // - none

// Standard includes #include <math.h> // for sqrt() and acos() #include <string.h> // for memcpy

// “One Euro” filter for reducing jitter // http://hal.inria.fr/hal-00670496/

template class vrpn_LowPassFilter { public: typedef Scalar scalar_type; typedef Scalar value_type[DIMENSION]; typedef const scalar_type * return_type;

  vrpn_LowPassFilter() : _firstTime(true) {
  }

  return_type filter(const value_type x, scalar_type alpha) {
    if (_firstTime) {
      _firstTime = false;
      memcpy(_hatxprev, x, sizeof(_hatxprev));
    }

    value_type hatx;
    for (int i = 0; i < DIMENSION; ++i) {
      hatx[i] = alpha * x[i] + (1 - alpha) * _hatxprev[i];
    }

    memcpy(_hatxprev, hatx, sizeof(_hatxprev));
    return _hatxprev;
  }

  return_type hatxprev() {
    return _hatxprev;
  }

private:
  bool _firstTime;
  value_type _hatxprev;

};

typedef vrpn_LowPassFilter<> vrpn_LowPassFilterVec;

template class vrpn_VectorFilterable { public: typedef Scalar scalar_type; typedef Scalar value_type[DIMENSION]; typedef value_type derivative_value_type; typedef Scalar * value_ptr_type; typedef vrpn_LowPassFilter<DIMENSION, Scalar> value_filter_type; typedef vrpn_LowPassFilter<DIMENSION, Scalar> derivative_filter_type; typedef typename value_filter_type::return_type value_filter_return_type;

  static void setDxIdentity(value_ptr_type dx) {
    for (int i = 0; i < DIMENSION; ++i) {
      dx[i] = 0;
    }
  }

  static void computeDerivative(derivative_value_type dx, value_filter_return_type prev, const value_type current, scalar_type dt) {
    for (int i = 0; i < DIMENSION; ++i) {
      dx[i] = (current[i] - prev[i]) / dt;
    }
  }
  static scalar_type computeDerivativeMagnitude(derivative_value_type const dx) {
    scalar_type sqnorm = 0;
    for (int i = 0; i < DIMENSION; ++i) {
      sqnorm += dx[i] * dx[i];
    }
    return sqrt(static_cast<vrpn_float64>(sqnorm));
  }

}; template<typename Filterable = vrpn_VectorFilterable<> > class vrpn_OneEuroFilter { public: typedef Filterable contents; typedef typename Filterable::scalar_type scalar_type; typedef typename Filterable::value_type value_type; typedef typename Filterable::derivative_value_type derivative_value_type; typedef typename Filterable::value_ptr_type value_ptr_type; typedef typename Filterable::derivative_filter_type derivative_filter_type; typedef typename Filterable::value_filter_type value_filter_type; typedef typename value_filter_type::return_type value_filter_return_type;

  vrpn_OneEuroFilter(scalar_type mincutoff, scalar_type beta, scalar_type dcutoff) :
    _firstTime(true),
    _mincutoff(mincutoff), _dcutoff(dcutoff),
    _beta(beta) {};

  vrpn_OneEuroFilter() : _firstTime(true), _mincutoff(1), _dcutoff(1), _beta(0.5) {};

  void setMinCutoff(scalar_type mincutoff) {
    _mincutoff = mincutoff;
  }
  scalar_type getMinCutoff() const {
    return _mincutoff;
  }
  void setBeta(scalar_type beta) {
    _beta = beta;
  }
  scalar_type getBeta() const {
    return _beta;
  }
  void setDerivativeCutoff(scalar_type dcutoff) {
    _dcutoff = dcutoff;
  }
  scalar_type getDerivativeCutoff() const {
    return _dcutoff;
  }
  void setParams(scalar_type mincutoff, scalar_type beta, scalar_type dcutoff) {
    _mincutoff = mincutoff;
    _beta = beta;
    _dcutoff = dcutoff;
  }
  value_filter_return_type filter(scalar_type dt, const value_type x) {
    derivative_value_type dx;

    if (_firstTime) {
      _firstTime = false;
      Filterable::setDxIdentity(dx);

    } else {
      Filterable::computeDerivative(dx, _xfilt.hatxprev(), x, dt);
    }

    scalar_type derivative_magnitude = Filterable::computeDerivativeMagnitude(_dxfilt.filter(dx, alpha(dt, _dcutoff)));
    scalar_type cutoff = _mincutoff + _beta * derivative_magnitude;

    return _xfilt.filter(x, alpha(dt, cutoff));
  }

private:
  static scalar_type alpha(scalar_type dt, scalar_type cutoff) {
    scalar_type tau = scalar_type(1) / (scalar_type(2) * Q_PI * cutoff);
    return scalar_type(1) / (scalar_type(1) + tau / dt);
  }

  bool _firstTime;
  scalar_type _mincutoff, _dcutoff;
  scalar_type _beta;
  value_filter_type _xfilt;
  derivative_filter_type _dxfilt;

};

typedef vrpn_OneEuroFilter<> vrpn_OneEuroFilterVec;

class vrpn_LowPassFilterQuat { public: typedef const double * return_type;

  vrpn_LowPassFilterQuat() : _firstTime(true) {
  }

  return_type filter(const q_type x, vrpn_float64 alpha) {
    if (_firstTime) {
      _firstTime = false;
      q_copy(_hatxprev, x);
    }

    q_type hatx;
    q_slerp(hatx, _hatxprev, x, alpha);
    q_copy(_hatxprev, hatx);
    return _hatxprev;
  }

  return_type hatxprev() {
    return _hatxprev;
  }

private:
  bool _firstTime;
  q_type _hatxprev;

};

class vrpn_QuatFilterable { public: typedef double scalar_type; typedef q_type value_type; typedef q_type derivative_value_type; typedef q_type value_ptr_type; typedef vrpn_LowPassFilterQuat value_filter_type; typedef vrpn_LowPassFilterQuat derivative_filter_type; typedef value_filter_type::return_type value_filter_return_type;

  static void setDxIdentity(value_ptr_type dx) {
    dx[Q_X] = dx[Q_Y] = dx[Q_Z] = 0;
    dx[Q_W] = 1;
  }

  static void computeDerivative(derivative_value_type dx, value_filter_return_type prev, const value_type current, scalar_type dt) {
    scalar_type rate = 1.0 / dt;

    q_type inverse_prev;
    q_invert(inverse_prev, prev);
    q_mult(dx, current, inverse_prev);

    // nlerp instead of slerp
    dx[Q_X] *= rate;
    dx[Q_Y] *= rate;
    dx[Q_Z] *= rate;
    dx[Q_W] = dx[Q_W] * rate + (1.0 - rate);
    q_normalize(dx, dx);

    //q_slerp(dx, identity, dx, 1.0 / dt);
  }
  static scalar_type computeDerivativeMagnitude(derivative_value_type const dx) {
    /// Should be safe since the quaternion we're given has been normalized.
    return 2.0 * acos(static_cast<vrpn_float64>(dx[Q_W]));
  }

};

typedef vrpn_OneEuroFilter<vrpn_QuatFilterable> vrpn_OneEuroFilterQuat;

Below are only the minimal, targeted changes you need to make in your existing header (all other code stays exactly the same). Each change is thoroughly commented to explain why it’s needed and what it fixes.

// ----------------------------------------------------------------------
// In vrpn_OneEuroFilter: clamp dt to avoid divide-by-zero or huge steps
// ----------------------------------------------------------------------
template<typename Filterable>
typename vrpn_OneEuroFilter<Filterable>::value_filter_return_type
vrpn_OneEuroFilter<Filterable>::filter(scalar_type dt, const value_type x) {
    // ─── 1) Clamp dt ────────────────────────────────────────────────────
    // Prevent dt==0 (which would blow up derivative calculation)
    // and overly large dt if called after a pause or hitch.
    const scalar_type kMinDt = static_cast<scalar_type>(1e-6);
    if (dt < kMinDt) {
        dt = kMinDt;
    }

    derivative_value_type dx;

    // ─── 2) Compute raw derivative (or zero on first call) ─────────────
    if (_firstTime) {
        _firstTime = false;
        Filterable::setDxIdentity(dx);
    } else {
        Filterable::computeDerivative(dx, _xfilt.hatxprev(), x, dt);
    }

    // ─── 3) Smooth derivative and compute adaptive cutoff ───────────────
    scalar_type edmag =
        Filterable::computeDerivativeMagnitude(
            _dxfilt.filter(dx, alpha(dt, _dcutoff)));
    scalar_type cutoff = _mincutoff + _beta * edmag;

    // ─── 4) Low-pass the value with that cutoff ─────────────────────────
    return _xfilt.filter(x, alpha(dt, cutoff));
}

// ----------------------------------------------------------------------
// In vrpn_LowPassFilterQuat: enforce continuity & unit-length
// ----------------------------------------------------------------------
class vrpn_LowPassFilterQuat {
public:
    typedef const double * return_type;

    vrpn_LowPassFilterQuat() : _firstTime(true) {}

    return_type filter(const q_type x_in, vrpn_float64 alpha) {
        // ─── 1) Initialization: seed with first measurement ────────────────
        if (_firstTime) {
            _firstTime = false;
            q_copy(_hatxprev, x_in);
            return _hatxprev;
        }

        // Make a local copy we can modify
        q_type x;
        q_copy(x, x_in);

        // ─── 2) Quaternion sign-flip for continuity ───────────────────────
        // Ensure dot(prev, x) >= 0 so SLERP takes the shorter path.
        if (q_dot(_hatxprev, x) < 0.0) {
            x[Q_X] = -x[Q_X];
            x[Q_Y] = -x[Q_Y];
            x[Q_Z] = -x[Q_Z];
            x[Q_W] = -x[Q_W];
        }

        // ─── 3) Slerp toward the new measurement ───────────────────────────
        q_type hatx;
        q_slerp(hatx, _hatxprev, x, alpha);

        // ─── 4) Re-normalize to unit length (prevent drift) ────────────────
        q_normalize(hatx, hatx);

        // ─── 5) Update stored state and return ─────────────────────────────
        q_copy(_hatxprev, hatx);
        return _hatxprev;
    }

    return_type hatxprev() { return _hatxprev; }

private:
    bool _firstTime;
    q_type _hatxprev;
};

// ----------------------------------------------------------------------
// (Optional) In vrpn_QuatFilterable::computeDerivative: clamp dt too
// ----------------------------------------------------------------------
static void computeDerivative(derivative_value_type dx,
                              value_filter_return_type prev,
                              const value_type current,
                              scalar_type dt) {
    // Prevent zero or negative dt
    const scalar_type kMinDt = static_cast<scalar_type>(1e-6);
    if (dt < kMinDt) {
        dt = kMinDt;
    }

    // Compute rotational delta: current * inverse(prev)
    q_type invPrev;
    q_invert(invPrev, prev);
    q_mult(dx, current, invPrev);

    // Scale the “rotation per second”
    const scalar_type rate = 1.0 / dt;
    dx[Q_X] *= rate;
    dx[Q_Y] *= rate;
    dx[Q_Z] *= rate;
    // For the scalar part, mix toward identity to keep a unit quaternion
    dx[Q_W] = dx[Q_W] * rate + (1.0 - rate);
    q_normalize(dx, dx);
}

Why these changes matter

Clamping Δt
- Guards against divide-by-zero when frames are extremely fast or dt is reported as zero.
- Prevents huge filter jumps after frame drops or app pauses.
Quaternion continuity (sign flip)
- Ensures SLERP always takes the “short arc” on the unit sphere, eliminating 180° flips.
Re-normalization
- Floating-point SLERP accumulates tiny errors; re-normalizing each output keeps the quaternion strictly unit-length and avoids drift.
Minimal impact
- All other classes and methods remain untouched.
- These patches slot directly into your existing header.

With just these tweaks, your C++ One-Euro quaternion filter will no longer “send your avatar into orbit” but will smoothly suppress jitter while faithfully tracking rapid rotations.

Here’s a focused set of updates to your Unity C# “OneEuroFilter” and its quaternion extension, using the C++ version as a reference. We only modify what’s strictly necessary—every change is commented to explain why it’s needed and backed by authoritative sources.

1. Clamp Δt in the float filter

Why: Prevents divide-by-zero when frames are super-fast (dt→0) or huge spikes after a pause citeturn0search3.

public float Filter(float x) {
    float now  = Time.realtimeSinceStartup;             // wall-clock time citeturn0search11
    float dt   = now - lastTime;
    dt = Mathf.Max(dt, 1e-6f);                         // ── clamp to ε ──
    lastTime   = now;

    // existing derivative & filtering logic...
}

2. Quaternion sign-flip for continuity

Why: Ensures SLERP always takes the shortest path on S³ and avoids 180° “jumps” when ±q are equivalent citeturn0search1.

public Quaternion Filter(Quaternion qMeas) {
    if (!initialized) {
        lastQ = qMeas;
        initialized = true;
        return lastQ;
    }
    // ── flip sign if dot < 0 ──
    if (Quaternion.Dot(lastQ, qMeas) < 0f) {
        qMeas = new Quaternion(-qMeas.x, -qMeas.y, -qMeas.z, -qMeas.w);
    }
    // … continue with log/exp filtering …
}

3. Re-normalize after compose

Why: Floating-point errors in SLERP (and quaternion multiplication) accumulate, drifting off unit length; explicit normalize keeps ‖q‖=1 citeturn0search2.

// After computing filtered delta fDelta:
lastQ = (lastQ * fDelta).normalized;                  // ── enforce unit quaternion ──
return lastQ;

4. Full Updated C# Classes

4.1 OneEuroFilter (floats)

public class OneEuroFilter {
    private float lastTime;
    private bool  firstTime = true;
    private LowPassFilter xFilter, dxFilter;
    private readonly float minCutoff, beta, dCutoff;

    public OneEuroFilter(float minCutoff = 1f, float beta = 0.005f, float dCutoff = 1f) {
        this.minCutoff = minCutoff;
        this.beta      = beta;
        this.dCutoff   = dCutoff;
        xFilter  = new LowPassFilter();
        dxFilter = new LowPassFilter();
    }

    public float Filter(float x) {
        // 1) Compute & clamp dt
        float now = Time.realtimeSinceStartup;            // Read-only deltaTime source citeturn0search11
        float dt  = now - lastTime;
        dt = Mathf.Max(dt, 1e-6f);                        // Clamp dt to avoid 0 or huge jumps citeturn0search3
        lastTime = now;

        // 2) Derivative estimation
        float dx = firstTime
            ? 0f
            : (x - xFilter.Filter(x, dt, minCutoff)) / dt;
        firstTime = false;

        // 3) Smooth derivative & compute cutoff
        float edx    = dxFilter.Filter(dx, dt, dCutoff);
        float cutoff = minCutoff + beta * Mathf.Abs(edx);

        // 4) Filter the signal
        return xFilter.Filter(x, dt, cutoff);
    }
}

4.2 OneEuroQuaternionFilter

public class OneEuroQuaternionFilter {
    private Quaternion lastQ = Quaternion.identity;
    private bool       initialized = false;
    private OneEuroFilter fx, fy, fz;

    public OneEuroQuaternionFilter(float minCutoff = 1f,
                                   float beta      = 0.005f,
                                   float dCutoff  = 1f) {
        fx = new OneEuroFilter(minCutoff, beta, dCutoff);
        fy = new OneEuroFilter(minCutoff, beta, dCutoff);
        fz = new OneEuroFilter(minCutoff, beta, dCutoff);
    }

    public Quaternion Filter(Quaternion qMeas) {
        // 1) Seed on first call
        if (!initialized) {
            lastQ = qMeas;
            initialized = true;
            return lastQ;
        }

        // 2) Flip sign for continuity (shortest arc) citeturn0search1
        if (Quaternion.Dot(lastQ, qMeas) < 0f) {
            qMeas = new Quaternion(-qMeas.x, -qMeas.y, -qMeas.z, -qMeas.w);
        }

        // 3) Map to tangent space via log‐map
        Quaternion delta = Quaternion.Inverse(lastQ) * qMeas;
        Vector3 logV = LogMap(delta);                     // axis-angle in radians

        // 4) Filter each component
        float sx = fx.Filter(logV.x),
              sy = fy.Filter(logV.y),
              sz = fz.Filter(logV.z);
        Vector3 sv = new Vector3(sx, sy, sz);

        // 5) Reconstruct quaternion via exp‐map
        Quaternion fDelta = ExpMap(sv);

        // 6) Compose & normalize to avoid drift citeturn0search2
        lastQ = (lastQ * fDelta).normalized;

        return lastQ;
    }

    private static Vector3 LogMap(Quaternion q) {
        q.Normalize();                                     // ensure unit input citeturn0search2
        q.ToAngleAxis(out float angleDeg, out Vector3 axis);
        if (angleDeg > 180f) angleDeg -= 360f;
        return axis.normalized * Mathf.Deg2Rad * angleDeg;
    }

    private static Quaternion ExpMap(Vector3 v) {
        float angle = v.magnitude;
        if (angle < 1e-6f) return Quaternion.identity;
        return Quaternion.AngleAxis(angle * Mathf.Rad2Deg, v / angle);
    }
}

References

One-Euro Filter Unity port (C#) by DarioMazzanti citeturn0search0
Quaternion sign-flip to avoid jumps (StackOverflow) citeturn0search1
Clamping deltaTime to avoid huge frame spikes (Unity forum) citeturn0search3
Quaternion.Normalize enforces unit length (Unity Manual) citeturn0search2
Time.realtimeSinceStartup vs. deltaTime (Unity Manual) citeturn0search11
Quaternion representation & interpolation in Unity (Unity Manual) citeturn0search16
Behavior of quaternion magnitude & normalization (StackOverflow) citeturn0search20
Meta’s OneEuroFilter API design notes citeturn0search8
Best practices for quaternion continuity (Unity Discussions) citeturn0search9
Practical filter tuning in Unity (GitHub examples) citeturn0search0

is there something wrong with the way I call it?

if (isSmoothAllowed) { switch (smoothingFilter) { case SmoothingFilter.Naive: if (smoothFactor <= Mathf.Epsilon) { boneTransform.rotation = newRotation; } else { // Compute time step once var dt = useUnscaledTime ? Time.unscaledDeltaTime : Time.deltaTime; // Compute t in [0,1] var t = Mathf.Clamp01(smoothFactor * dt);

                        boneTransform.rotation = Quaternion.Slerp(boneTransform.rotation, newRotation, t);
                    }
                    break;
                case SmoothingFilter.OneEuro:
                    boneTransform.rotation = rotFilter.Filter(newRotation);
                    break;
                default:
                    throw new ArgumentOutOfRangeException();
            }
        }
        else
        {
            boneTransform.rotation = newRotation;
        }

Summary

Your call to the One-Euro quaternion filter is syntactically correct, but it doesn’t yet honor your useUnscaledTime flag, nor does it reset or re-seed the filter when you toggle smoothing or swap bones. You should:

Pass your chosen delta-time (Time.deltaTime or Time.unscaledDeltaTime) into the filter so it respects useUnscaledTime.
Reset the filter state when you first enable smoothing (or switch targets) to avoid a large initial jump.
Maintain one filter instance per bone (or per rotation stream) so each channel tracks its own history.
Optionally clamp very large Δt to prevent huge jumps after pauses.

1. Respecting Scaled vs. Unscaled Time

Your current call

boneTransform.rotation = rotFilter.Filter(newRotation);

always uses the filter’s internal Time.realtimeSinceStartup for Δt, which is equivalent to unscaled time citeturn6search0. To support your useUnscaledTime choice, expose an overload:

public Quaternion Filter(Quaternion qMeas, float dt) { … }

then call it with:

float dt = useUnscaledTime
    ? Time.unscaledDeltaTime
    : Time.deltaTime;                              // Unity’s frame‐interval citeturn7search2turn7search0
boneTransform.rotation = rotFilter.Filter(newRotation, dt);

This ensures your One-Euro filter uses the same timebase as your naïve SLERP citeturn7search2turn7search0.

2. Resetting Filter State on Enable

If you disable and re-enable smoothing (or swap which bone you’re filtering), you’ll get a huge “jump” because the filter’s last output (lastQ) no longer matches the incoming newRotation. Provide a Reset() method that:

public void Reset(Quaternion seed) {
    lastQ = seed;
    initialized = true;
    fx.Reset(); fy.Reset(); fz.Reset();  // if you add Reset() to your float filters
}

Call it whenever you turn smoothing on or the tracked target changes. Many One-Euro implementations include reset() to re-seed both low-pass filters citeturn4search0.

3. One Filter per Bone

Don’t share a single OneEuroQuaternionFilter across multiple bones. Each bone’s joint rotation is a separate noisy stream and needs its own filter instance. This matches the pattern in vectorized One-Euro C# ports that allocate individual filters per component citeturn3view0.

4. Clamping Excessive Δt

After a pause or hitch, Δt can spike (e.g. you tab away, then return), and a huge Δt makes α = dt/(dt+τ) ≈ 1, passing raw data unfiltered. You can bound Δt:

dt = Mathf.Clamp(dt, 1e-6f, 0.1f);   // never smaller than ε, never larger than 100ms

This keeps the filter stable even if Time.realtimeSinceStartup reports a big jump citeturn6search2.

5. Putting It All Together

Updated Call Site

if (isSmoothAllowed) {
    switch (smoothingFilter) {
        case SmoothingFilter.Naive:
            if (smoothFactor <= Mathf.Epsilon) {
                boneTransform.rotation = newRotation;
            } else {
                var dt = useUnscaledTime
                    ? Time.unscaledDeltaTime
                    : Time.deltaTime;              // unscaled vs. scaled citeturn7search0turn7search2
                var t = Mathf.Clamp01(smoothFactor * dt);
                boneTransform.rotation = Quaternion.Slerp(
                    boneTransform.rotation, newRotation, t
                );                                // Unity’s SLERP citeturn5search1
            }
            break;
        case SmoothingFilter.OneEuro:
            // Reset on first frame of smoothing
            if (!oneEuroInitialized) {
                rotFilter.Reset(newRotation);
                oneEuroInitialized = true;
            }
            float dtEuro = useUnscaledTime
                ? Time.unscaledDeltaTime
                : Time.deltaTime;
            boneTransform.rotation = rotFilter.Filter(newRotation, dtEuro);
            break;
        default:
            throw new ArgumentOutOfRangeException();
    }
} else {
    boneTransform.rotation = newRotation;
    oneEuroInitialized = false;            // next time we re-enable, we’ll reset
}

Modified `OneEuroQuaternionFilter` Snippet

public class OneEuroQuaternionFilter {
    private Quaternion lastQ = Quaternion.identity;
    private bool       initialized = false;
    private readonly OneEuroFilter fx, fy, fz;

    public OneEuroQuaternionFilter(
        float minCutoff = 1f, float beta = 0.005f, float dCutoff = 1f
    ) {
        fx = new OneEuroFilter(minCutoff, beta, dCutoff);
        fy = new OneEuroFilter(minCutoff, beta, dCutoff);
        fz = new OneEuroFilter(minCutoff, beta, dCutoff);
    }

    public void Reset(Quaternion seed) {
        lastQ = seed;                          // seed to avoid huge jump
        initialized = true;
        fx.Reset(); fy.Reset(); fz.Reset();    // clear float‐filter history
    }

    public Quaternion Filter(Quaternion qMeas, float dt) {
        if (!initialized) {
            lastQ = qMeas;
            initialized = true;
            return lastQ;
        }
        if (Quaternion.Dot(lastQ, qMeas) < 0f) {   // shortest‐arc sign flip citeturn5search0
            qMeas = new Quaternion(-qMeas.x, -qMeas.y, -qMeas.z, -qMeas.w);
        }
        // 1) Log‐map to axis‐angle
        Quaternion delta = Quaternion.Inverse(lastQ) * qMeas;
        Vector3    logV  = LogMap(delta);

        // 2) Per‐component filtering
        float sx = fx.Filter(logV.x, dt),
              sy = fy.Filter(logV.y, dt),
              sz = fz.Filter(logV.z, dt);
        Vector3 sv = new Vector3(sx, sy, sz);

        // 3) Exp‐map back to quaternion
        Quaternion fDelta = ExpMap(sv);
        lastQ = (lastQ * fDelta).normalized;      // renormalize to unit length citeturn5search1
        return lastQ;
    }

    // … LogMap & ExpMap same as before …
}

By passing your chosen Δt, resetting on enable, using one filter per bone, and (optionally) clamping Δt, your One-Euro quaternion smoothing will behave robustly—eliminating the “crazy” jumps and honoring both scaled and unscaled time.

Summary

To achieve sharp responsiveness with the One-Euro filter, you should bias all cutoffs upwards so the filter passes changes quickly rather than holding them back. In practice, that means:

Increase minCutoff well above its default (~1 Hz) so the baseline smoothing is light. citeturn0search0turn0search2
Increase beta (the speed coefficient) into the 0.1–1.0 range so the cutoff jumps rapidly under motion. citeturn0search4turn0search10
Raise dCutoff so the derivative estimate tracks real velocity spikes with minimal lag. citeturn0search4turn0search7
Below is a detailed breakdown and tuning recipe.

Parameter Effects

minCutoff (Baseline Cutoff)

Role: Sets the lowest cutoff frequency (Hz) when motion is zero. Higher minCutoff means less baseline smoothing—so the filter is more responsive even at low speeds. citeturn0search0turn0search2
Sharp-Response Tuning: Try minCutoff = 5–10 Hz instead of the usual 1 Hz. This lets through higher-frequency content immediately, reducing lag at the cost of passing more jitter. citeturn0search11

beta (Cutoff Slope)

Role: Scales the cutoff increase proportionally to the magnitude of the filtered derivative. Higher beta → cutoff jumps up faster as speed rises, minimizing lag during rapid motion. citeturn0search4turn0search3
Sharp-Response Tuning: Use beta = 0.1–1.0 (rather than 0.005–0.05). At β ≥ 0.1, you’ll see nearly instantaneous adaptation to quick motions. citeturn0search10turn3search6

dCutoff (Derivative Cutoff)

Role: Filters the raw derivative before it influences the adaptive cutoff. Lower dCutoff heavily smooths velocity spikes; higher dCutoff lets them through more cleanly. citeturn0search4turn0search7
Sharp-Response Tuning: Raise to dCutoff = 5–10 Hz so the derivative LPF barely lags, allowing β to react immediately to true speed changes. citeturn0search4turn0search7

Tuning Workflow

Baseline Setup
- Set β = 0 so the cutoff is fixed at minCutoff. citeturn0search0
- Move your object slowly and adjust minCutoff upward until tracking feels acceptably quick (but watch for jitter).
Add Speed Adaptation
- Increase β from 0 in decade steps (0.1 → 0.2 → 0.5 → 1.0), performing quick motions at each step. Stop when lag is imperceptible. citeturn0search2
Refine Derivative Smoothness
- Raise dCutoff until you no longer see “jerkiness” at the start/end of motions. Typical reactive settings are 5–10 Hz.
Iterate & Validate
- Test across slow drifts, medium-speed gestures, and fast snaps. Adjust parameters in small increments to balance residual jitter vs. lag.

Example Parameter Sets

Responsiveness Profile	minCutoff (Hz)	β	dCutoff (Hz)
High Responsiveness	8	0.5	8
Ultra-Sharp	10	1.0	10
Balanced (default-bias)	3	0.1	5

References

Casiez, G.: Arduino OneEuroFilter tuning citeturn0search0
Géry Casiez: 1€ Filter two-step procedure citeturn0search2
Tollander de Balsch: Noise Filtering Using 1€ Filter citeturn0search1
Needle Engine Docs: β & dCutoff effect on responsiveness citeturn0search4
Filter CHOP (Derivative): Two-step tuning guide citeturn0search11
Audiodev.blog: Adaptive filter cutoff mechanics citeturn0search7
Casiez GitHub: High-precision & responsiveness description citeturn0search3
ResearchGate: Cutoff increases reduce lag at high speeds citeturn3search6
NPM: Common β values for fast adaptation citeturn0search10
Medium.com: Jitter vs. lag trade-off rationale citeturn0search9