speedandcurrent 1.7.6 → 1.7.8

package/README.md

@@ -104,7 +104,7 @@ Leave a source blank or set to *(any)* to accept values from all sources. If mul
 5. The plugin will always estimate currents when Estimate boat speed is enabled. Even when Assume currents is disabled, as this setting is only used in updating the correction table.
 
 ## Persistence & Data Storage
-Each correction table is saved as a `.json` file in Signal K's plugin data directory (typically `~/.signalk/plugin-config-data/speedandcurrent/`). The active table name is stored in the plugin options and reloaded automatically on restart. While learning is active, the table is written to disk approximately every 5 seconds.
+Each correction table is saved as a `.json` file in Signal K's plugin data directory (typically `~/.signalk/plugin-config-data/speedandcurrent/`). The active table name is stored in the plugin options and reloaded automatically on restart. While learning is active, the table is written to disk approximately every 60 seconds.
 
 Safety & backup:
 - Tables can be copied to a new name with the **Copy** button before experimenting.
@@ -148,8 +148,8 @@ Each populated cell shows:
 - **Leeway** (°): the estimated sideways drift angle; also encoded visually as the stripe direction in the cell background.
 
 Cell highlighting:
-- **Blue outline**: the most recently updated table cell.
-- **Dashed outline**: cells contributing to the current interpolation.
+- **Blue values**: the most recently updated table cell (factor and leeway text rendered in blue).
+- **Thin border**: cells contributing to the current interpolation.
 - **No content**: not yet populated by learning.
 
 ### Correction Table Health Checklist

package/correctionTable.js

@@ -91,39 +91,6 @@ class CorrectionTable extends Table2D{
     this.lastUpdatedCell = cell;
   }
 
-  getKalmanCorrection(speed, heel) {
-    /**
-   * Return a estimated correction based on interpolation and weighting of correction variance;
-   */
-    if (speed == 0) return { x: 0, y: 0 };
-    const neighbours = this.findNeighbours(speed, heel);
-    let totalWeightX   = 0;
-    let totalWeightY   = 0;
-    let x = 0;
-    let y = 0;
-    for (const neighbour of neighbours) {
-      const { cell:correction, xdist, ydist } = neighbour;
-      if (correction.N > 0) {
-        const weightX = 1 / (xdist + 1e-6) ;
-        const weightY = 1 / (ydist + 1e-6) ;
-        const varianceX = correction.covariance[0][0];
-        const varianceY = correction.covariance[1][1];
-        const N = correction.N;
-        const varWeightX = weightX * N / (varianceX + 1e-6);
-        const varWeightY = weightY * N / (varianceY + 1e-6);
-        x += correction.x * varWeightX;
-        y += correction.y * varWeightY; 
-        totalWeightX += varWeightX;
-        totalWeightY += varWeightY;
-      }
-    }
-    if (totalWeightX == 0 || totalWeightY == 0) return { x: 0, y: 0 };  
-    x = x / totalWeightX;
-    y = y / totalWeightY;
-    return { x:x, y:y };
-
-  }
-
   getCorrection(speed, heel) {
     this.neighbours = this.findClosest(speed, heel, 5);
     if (this.neighbours.length == 0) return { correction: {x: 0, y: 0}, variance: null };
@@ -187,7 +154,6 @@ class CorrectionTable extends Table2D{
               if (cov && Array.isArray(cov) && cov[0] && cov[1] && Number.isFinite(cov[0][0]) && Number.isFinite(cov[1][1])) {
                 const a = cov[0][0];
                 const d = cov[1][1];
-                //trace = Math.sqrt(a*a + d*d);
                 trace = a + d;
               }
             } catch { /* silent */ }
@@ -285,7 +251,7 @@ class CorrectionEstimator {
 
     var groundCov = rotateVariance(groundSpeed.variance);
     var currentCov = rotateVariance(current.variance);
-    var boatCov = [[boatSpeed.variance[0], 0], [0, boatSpeed.variance[1]]];
+    var boatCov = [[boatSpeed.xVariance, 0], [0, boatSpeed.yVariance]];
 
     const observationCovariance = [[
       groundCov[0][0] + currentCov[0][0] + boatCov[0][0],
@@ -295,7 +261,6 @@ class CorrectionEstimator {
       groundCov[1][1] + currentCov[1][1] + boatCov[1][1]],
     ];
     this.filterState = this.filter.filter({ previousCorrected: this.filterState, observation, observationCovariance });
-    //console.log("Filterstate:", this.filterState, "Covariance:", observationCovariance);
     return true;
   }
 

package/index.js

@@ -41,7 +41,8 @@ module.exports = function (app) {
     smootherTau: 3,
     smootherTimeSpan: 5,
     smootherSteadyState: 0.2,
-    showStatistics: false
+    showStatistics: false,
+    stalenessDetection: true
   };
 
   
@@ -109,7 +110,6 @@ module.exports = function (app) {
   let isRunning = false;
   let pluginStatus = 'Stopped';
   let smoothedHeading = null;
-  let stability = null;
   let smoothedAttitude = null;
   let rawCurrent = null;
   let smoothedCurrent = null;
@@ -124,7 +124,6 @@ module.exports = function (app) {
   let reportFull = null;
   let table = null;
 
-  // add missing declarations
   let rawHeading = null;
   let rawAttitude = null;
   let noCurrent = null;
@@ -314,6 +313,10 @@ module.exports = function (app) {
       SmootherClass,
       smootherOptions
     });
+    // The magnitude handler has a fixed value of 1 and is never subscribed, so its timestamp
+    // stays null forever. Staleness detection on it would always force _stale=true, blocking
+    // processChanges() from setting polar._ready=true on every heading delta.
+    smoothedHeading.polar.magnitudeHandler.stalenessDetection = false;
     rawHeading = smoothedHeading.handler;
 
     //attitude
@@ -360,6 +363,7 @@ module.exports = function (app) {
     });
     noCurrent.xSmoother.reset(0,0);
     noCurrent.ySmoother.reset(0,0);
+    noCurrent.stalenessDetection = false; // noCurrent is a fixed zero-vector, never receives live data
     PolarSmoother.send(app, plugin.id, [noCurrent]);
 
     MessageHandler.setMeta(app, plugin.id, 'navigation.leewayAngle', {
@@ -425,8 +429,6 @@ module.exports = function (app) {
     residual.setMeta({ displayName: "Residual", plane: "Ground" });
     smoothedResidual = new PolarSmoother(residual, ExponentialSmoother, { tau: 30, timeSpan: 30 }); // id auto-derived: 'residual.smoothed'
     smoothedResidual.setAngleRange('0to2pi');
-    // smoothedResidual.xSmoother.reset(0, 0.00000001);
-    // smoothedResidual.ySmoother.reset(0, 0.00000001);
 
     //#endregion
 
@@ -458,6 +460,18 @@ module.exports = function (app) {
 
     //#endregion
 
+    // Apply staleness detection to all subscribed smoother instances.
+    // noCurrent is intentionally excluded — it is a fixed zero-vector and never receives live data.
+    // Only apply when sd = false: all smoothers already default to stalenessDetection = true.
+    // Explicitly calling the setter with true at startup forces _stale = true on handlers that have
+    // never received data, causing the first sample to be dropped (library side-effect).
+    const sd = options.stalenessDetection ?? true;
+    if (!sd) {
+      for (const s of [smoothedHeading, smoothedAttitude, smoothedBoatSpeed, smoothedGroundSpeed, smoothedCurrent, smoothedResidual]) {
+        if (s) s.stalenessDetection = false;
+      }
+    }
+
     isRunning = true;
     started = new Date();
     setStatus('Running');
@@ -488,7 +502,6 @@ module.exports = function (app) {
     return new Promise((resolve, reject) => {
       try {
         smoothedHeading = smoothedHeading?.terminate();
-        stability = stability?.terminate?.();
         smoothedAttitude = smoothedAttitude?.terminate();
         rawCurrent = rawCurrent?.terminate();
         smoothedCurrent = smoothedCurrent?.terminate?.();
@@ -587,18 +600,13 @@ module.exports = function (app) {
   }
 
   /**
-   * Updates the correction table and calculates the residual error.
-   *
-   * This function uses the current smoothed attitude, boat speed, and heading to update the correction table
-   * if the boat speed exceeds the specified minimum. It also calculates the residual between the measured ground speed
-   * and the expected ground speed (corrected boat speed plus current). The correction table is periodically saved.
-   *
-   * @param {boolean} [assumeCurrent=false] - If true, uses the smoothed current for correction; otherwise, assumes no current.
-   * @param {number} [minSpeed=0] - The minimum speed threshold (in SI units) required to update the correction table.
+   * Updates the correction table from the current smoothed inputs.
+   * Reads assumeCurrent and minSpeed from module-level options/state;
+   * silently returns if any required input is not yet ready.
    */
   function updateTable() {
-    lrnBoatSpeed.setVectorValue({ x: smoothedBoatSpeed.value, y: 0 });
-    if (!smoothedAttitude.ready || !smoothedBoatSpeed.ready || !smoothedHeading.ready || !smoothedGroundSpeed.ready || (options.assumeCurrent ? !smoothedCurrent.ready : !noCurrent.ready)) return;
+    lrnBoatSpeed.setVectorValue({ x: smoothedBoatSpeed.value, y: 0 }, { x: smoothedBoatSpeed.variance ?? 0, y: 0 });
+    if (!smoothedAttitude.ready || !smoothedBoatSpeed.ready || !smoothedHeading.ready || !smoothedGroundSpeed.ready || (options.assumeCurrent && !smoothedCurrent.ready)) return;
     
     // update correction table
     if (smoothedBoatSpeed.value > minSpeed) {
@@ -608,37 +616,12 @@ module.exports = function (app) {
   }
 
   /**
-   * Checks if the correction table in settings matches the expected row and column configuration.
-   *
-   * This function compares the min, max, and step values of the row and column definitions
-   * in the current correction table against the provided row and col objects. Returns true
-   * if all values match, otherwise false. If the table is missing or not properly structured,
-   * returns false.
-   *
-   * @param {Object} row - The expected row configuration ({ min, max, step }).
-   * @param {Object} col - The expected column configuration ({ min, max, step }).
-   * @returns {boolean} True if the table matches the configuration, false otherwise.
-   */
-  function enforceConsistancy(data, row, col) {
-    if (!data) return false;
-    if (!data.row) return false;
-    if (data.row.min != row.min) return false;
-    if (data.row.max != row.max) return false;
-    if (data.row.step != row.step) return false;
-    if (data.col.min != col.min) return false;
-    if (data.col.max != col.max) return false;
-    if (data.col.step != col.step) return false;
-    return true;
-  }
-
-  /**
-   * Loads or creates a correction table based on the provided options.
+   * Loads or creates a correction table from disk.
+   * If the file exists it is deserialized; otherwise a new table is created
+   * with default dimensions and saved to disk.
    *
-   * This function checks if the correction table in the options matches the expected row and column configuration.
-   * If so, it loads the table from JSON; otherwise, it creates a new correction table with the specified parameters.
-   * The table is labeled and, if newly created, saved to the plugin options.
-   *
-   * @param {Object} options - The plugin options containing correction table settings and parameters.
+   * @param {Object} options - Plugin options (stability, tableName, and dimension defaults).
+   * @param {string} filePath - Absolute path of the JSON file to read.
    * @returns {CorrectionTable} The loaded or newly created CorrectionTable instance.
    */
   function loadTable(options, filePath) {
@@ -660,15 +643,10 @@ module.exports = function (app) {
   }
 
   /**
-   * Saves the correction table to the plugin options and logs the save event.
-   *
-   * This function serializes the provided correction table, updates the options object,
-   * and triggers the plugin's save mechanism. It returns the current date/time to indicate
-   * when the save occurred.
+   * Saves the correction table to disk as JSON.
    *
-   * @param {Object} options - The plugin options object to update.
    * @param {CorrectionTable} correctionTable - The correction table instance to save.
-   * @returns {Date} The date and time when the table was saved.
+   * @param {string} filePath - Absolute path of the target JSON file.
    */
   function saveTable(correctionTable, filePath) {
     correctionTable.saveToFile(filePath);
@@ -698,6 +676,12 @@ module.exports = function (app) {
         if (smoothedBoatSpeed) smoothedBoatSpeed.handler.passOn = !preventDuplication();
       } else if (key === 'estimateBoatSpeed' ) {
         if (smoothedBoatSpeed) smoothedBoatSpeed.handler.passOn = !preventDuplication();
+      } else if (key === 'stalenessDetection') {
+        const sdVal = Boolean(value);
+        for (const s of [smoothedHeading, smoothedAttitude, smoothedBoatSpeed, smoothedGroundSpeed, smoothedCurrent, smoothedResidual]) {
+          if (s) s.stalenessDetection = sdVal;
+        }
+        // noCurrent is always excluded from staleness detection
       }
 
       // All other keys (sogFallback, estimateBoatSpeed, updateCorrectionTable,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "speedandcurrent",
-  "version": "1.7.6",
+  "version": "1.7.8",
   "description": "A plugin that automatically corrects boat speed and calculates current and leeway using sensor fusion.",
   "main": "index.js",
   "scripts": {
@@ -31,12 +31,11 @@
   },
   "dependencies": {
     "kalman-filter": "^2.3.0",
-    "signalkutilities": "^1.11.0"
+    "signalkutilities": "^1.12.0"
   },
   "files": [
     "index.js",
     "correctionTable.js",
-    "leakyExtremes.js",
     "public/"
   ]
 }

package/public/app.js

@@ -118,7 +118,7 @@ async function loadMeta() {
 
 function isStale(item) {
   if (!item) return true;
-  return item.state?.stale === true;
+  return item.state?.isStale === true;
 }
 
 function isNotReady(item) {
@@ -126,6 +126,36 @@ function isNotReady(item) {
   return item.state?.ready !== true;
 }
 
+// Returns a human-readable reason why an item is not ready.
+// Handles three state shapes:
+//   handler-nested  (MessageSmoother, SmoothedAngle):  state.handler.*
+//   magnitude/angle (PolarSmoother):                   state.magnitude.* / state.angle.*
+//   flat top-level  (MessageHandler, Polar):           state.*
+function getNotReadyReason(item) {
+  if (!item) return 'not available';
+  const s = item.state;
+  if (!s) return 'not available';
+
+  let subscribed, pathKnown;
+  if (s.handler !== undefined) {
+    subscribed = s.handler.subscribed;
+    pathKnown  = s.handler.pathKnown;
+  } else if (s.magnitude !== undefined || s.angle !== undefined) {
+    const mag = s.magnitude, ang = s.angle;
+    subscribed = (mag?.subscribed !== false) && (ang?.subscribed !== false);
+    pathKnown  = (mag?.pathKnown  !== false) && (ang?.pathKnown  !== false);
+  } else {
+    subscribed = s.subscribed;
+    pathKnown  = s.pathKnown;
+  }
+
+  if (subscribed === false) return 'not subscribed to Signal K';
+  if (pathKnown  === false) return 'path not found in Signal K';
+  if (!s.hasDelta)          return 'waiting for first data';
+  if (s.isStale)            return 'data is stale';
+  return 'not available';
+}
+
 function getAnyItem(id) {
   return state.polarsById[id] || state.deltasById[id] || state.attitudesById[id] || null;
 }
@@ -143,9 +173,10 @@ function renderWarnings(elId, ids) {
   const ul = document.createElement('ul');
   ul.className = 'list-unstyled text-danger small ps-3';
   notReady.forEach(id => {
+    const item = getAnyItem(id);
     const label = metaById[id]?.displayName ?? id;
     const li = document.createElement('li');
-    li.textContent = `"${label}" — not available`;
+    li.textContent = `"${label}" — ${getNotReadyReason(item)}`;
     ul.appendChild(li);
   });
   el.appendChild(ul);
@@ -273,10 +304,16 @@ const paramMeta = {
     min: 0.01, max: 0.99, step: 0.01, default: 0.2,
     description: 'Steady-state Kalman gain (0 ≈ slow/smooth, 1 ≈ fast/raw). Clamped to 0.01–0.99.'
   },
+  stalenessDetection: {
+    label: 'Staleness detection',
+    type: 'boolean',
+    description: 'Mark inputs as unavailable when no data has been received for a period. '
+  },
 };
 
 // Settings groups for each UI section
 const INPUTS_SOURCE_KEYS      = ['headingSource','boatSpeedSource','SOGSource','attitudeSource'];
+const INPUTS_SETTING_KEYS     = ['stalenessDetection'];
 const ESTIMATION_SETTING_KEYS = ['sogFallback','preventDuplication'];
 const LEARNING_SETTING_KEYS   = ['stability','assumeCurrent','showStatistics'];
 const SMOOTHER_SETTING_KEYS   = [
@@ -441,6 +478,7 @@ function renderSectionToggles() {
 function renderSettingsPanel() {
   if (!config) return;
   renderSettingsRows('inputs-sources-table',      INPUTS_SOURCE_KEYS);
+  renderSettingsRows('inputs-settings-table',     INPUTS_SETTING_KEYS);
   renderSettingsRows('estimation-settings-table', ESTIMATION_SETTING_KEYS);
   renderSettingsRows('smoother-settings-table',   SMOOTHER_SETTING_KEYS);
   renderSettingsRows('learning-settings-table',   LEARNING_SETTING_KEYS);

package/public/index.html

@@ -7,16 +7,36 @@
   <title>Speed and Current</title>
   <script>
     (async () => {
+      const appendStylesheet = (href) => {
+        const el = document.createElement('link');
+        el.rel  = 'stylesheet';
+        el.href = href;
+        document.head.appendChild(el);
+      };
+      try {
+        const res = await fetch('/admin/.vite/manifest.json');
+        if (res.ok) {
+          const manifest = await res.json();
+          let found = false;
+          for (const entry of Object.values(manifest)) {
+            if (!entry.isEntry) continue;
+            for (const css of entry.css ?? []) {
+              appendStylesheet('/admin/' + css);
+              found = true;
+            }
+          }
+          if (found) return;
+        }
+      } catch (e) {
+        // fall through to legacy scrape
+      }
       try {
         const res  = await fetch('/');
         const html = await res.text();
         const doc  = new DOMParser().parseFromString(html, 'text/html');
         const link = doc.querySelector('link[rel="stylesheet"]');
         if (link) {
-          const el = document.createElement('link');
-          el.rel  = 'stylesheet';
-          el.href = new URL(link.getAttribute('href'), res.url).href;
-          document.head.appendChild(el);
+          appendStylesheet(new URL(link.getAttribute('href'), res.url).href);
         }
       } catch (e) {
         console.warn('[webapp] Could not load SignalK admin stylesheet:', e);
@@ -76,6 +96,10 @@
               <table class="table table-sm table-borderless mb-0" id="inputs-sources-table">
                 <tbody></tbody>
               </table>
+              <h6 class="text-uppercase fw-bold text-muted border-bottom pb-1 mt-3 mb-1 small">Settings</h6>
+              <table class="table table-sm table-borderless mb-0" id="inputs-settings-table">
+                <tbody></tbody>
+              </table>
               <h6 class="text-uppercase fw-bold text-muted border-bottom pb-1 mt-3 mb-1 small">Live Values</h6>
               <div id="inputs-values"></div>
             </div>
@@ -151,6 +175,32 @@
               </div>
             </div>
             <div class="card-body">
+              <div class="table-legend small text-muted mb-3">
+                <div class="table-legend-row">
+                  <span class="legend-swatch legend-swatch--green"></span>
+                  <span><strong>Green</strong> — paddlewheel reads slow (factor &gt; 1, speed is corrected up)</span>
+                </div>
+                <div class="table-legend-row">
+                  <span class="legend-swatch legend-swatch--orange"></span>
+                  <span><strong>Orange</strong> — paddlewheel reads fast (factor &lt; 1, speed is corrected down)</span>
+                </div>
+                <div class="table-legend-row">
+                  <span class="legend-swatch legend-swatch--stripe"></span>
+                  <span><strong>Stripe angle</strong> — encodes leeway direction; stripes are tilted proportionally to the leeway correction (°)</span>
+                </div>
+                <div class="table-legend-row">
+                  <span class="legend-swatch legend-swatch--active">+1.2%</span>
+                  <span><strong>Blue text</strong> — most recently updated cell</span>
+                </div>
+                <div class="table-legend-row">
+                  <span class="legend-swatch legend-swatch--neighbour"></span>
+                  <span><strong>Faint tint</strong> — interpolation neighbours used in the current estimate</span>
+                </div>
+                <div class="table-legend-row mt-1">
+                  <span class="legend-label-wide">Cell values:</span>
+                  <span>top = speed-correction factor (±%), bottom = leeway correction (±°)</span>
+                </div>
+              </div>
               <div id="table-container"></div>
             </div>
           </div>

package/public/main.css

@@ -42,10 +42,11 @@
 .TableCorner { font-size: 10px; color: #888; font-weight: 400; text-align: center; }
 /* cell states */
 .cell--empty     { background-color: #f0f0f0; }
-.cell--active    { outline: 3px solid #1565c0; outline-offset: -3px; }
-.cell--neighbour { outline: 1px dashed #90a4ae; outline-offset: -2px; }
+.cell--neighbour { box-shadow: inset 0 0 0 1px #90a4ae; }
 .cell-factor     { font-weight: 600; font-size: 12px; }
 .cell-leeway     { font-weight: 600; font-size: 12px; margin-top: 2px; }
+.cell--active .cell-factor,
+.cell--active .cell-leeway { color: #1565c0; }
 
 /* ─── Stable table column widths inside cards ──────────────────────────────── */
 .card-body .table {
@@ -96,3 +97,27 @@ line { stroke-width: 2; }
 
 /* ─── Stale data rows ──────────────────────────────────────────────────────── */
 tr.stale td { color: #aaa; font-style: italic; }
+
+/* ─── Correction table legend ─────────────────────────────────────────────── */
+.table-legend { display: flex; flex-direction: column; gap: 3px; }
+.table-legend-row { display: flex; align-items: center; gap: 6px; }
+.legend-swatch {
+  flex-shrink: 0;
+  width: 28px;
+  height: 16px;
+  border: 1px solid #ccc;
+  border-radius: 2px;
+  display: inline-block;
+}
+.legend-swatch--green    { background-color: rgb(0, 160, 80); }
+.legend-swatch--orange   { background-color: rgb(255, 165, 0); }
+.legend-swatch--stripe   {
+  background: repeating-linear-gradient(
+    120deg,
+    rgb(100, 180, 100) 0px, rgb(100, 180, 100) 4px,
+    #f0f0f0 4px, #f0f0f0 5px
+  );
+}
+.legend-swatch--active   { background: transparent; border: none; width: auto; height: auto; font-weight: 600; color: #1565c0; font-size: 11px; white-space: nowrap; }
+.legend-swatch--neighbour { background: #fff; box-shadow: inset 0 0 0 1px #90a4ae; }
+.legend-label-wide       { flex-shrink: 0; white-space: nowrap; font-weight: 600; }

package/leakyExtremes.js

@@ -1,98 +0,0 @@
-class LeakyExtremes {
-  /**
-   * @param {Object} opts
-   * @param {number} opts.initialMin
-   * @param {number} opts.initialMax
-   * @param {number} opts.tau - time constant in seconds for exponential decay
-   * @param {number} opts.catchupTau - time constant in seconds for fast catchup
-   * @param {boolean} opts.isAngle - true if data is angular (radians)
-   * @param {number} opts.period - period for angle wrapping (e.g., 2*Math.PI)
-   */
-  constructor({  initialMin=0, initialMax=0, tau = .15, catchupTau=.5, isAngle = false, period = 2 * Math.PI }) {
-    this.min = initialMin;
-    this.max = initialMax;
-    this.tau = tau;
-    this.catchupTau = catchupTau;
-    this.isAngle = isAngle;
-    this.period = period;
-    this.lastUpdate = Date.now();
-  }
-
-  // Helper for angle difference in [-period/2, period/2]
-  angleDiff(a, b) {
-    let d = a - b;
-    while (d > this.period / 2) d -= this.period;
-    while (d < -this.period / 2) d += this.period;
-    return d;
-  }
-
-  // Helper for angle normalization to [0, period)
-  normalizeAngle(a) {
-    while (a < 0) a += this.period;
-    while (a >= this.period) a -= this.period;
-    return a;
-  }
-
-  update(obs) {
-    if (!isFinite(obs) ) return;
-    const now = Date.now();
-    const dt = (now - this.lastUpdate) / 1000;
-    if (dt==0) return; 
-    this.lastUpdate = now;
-
-    if (!this.isAngle) {
-      // Linear data
-      // Update min
-      if (obs < this.min) {
-        const alpha = 1 - Math.exp(-dt / this.catchupTau);
-        this.min += (obs - this.min) * alpha;
-      } else {
-        const alpha = 1 - Math.exp(-dt / this.tau);
-        this.min += (obs - this.min) * alpha;
-      }
-      // Update max
-      if (obs > this.max) {
-        const alpha = 1 - Math.exp(-dt / this.catchupTau);
-        this.max += (obs - this.max) * alpha;
-      } else {
-        const alpha = 1 - Math.exp(-dt / this.tau);
-        this.max += (obs - this.max) * alpha;
-      }
-    } else {
-      // Angular data
-      obs=this.normalizeAngle(obs);
-      let minDiff = this.angleDiff(obs, this.min);
-      let maxDiff = this.angleDiff(obs, this.max);
-
-      // Update min
-      if (minDiff < 0) {
-        const alpha = 1 - Math.exp(-dt / this.catchupTau);
-        this.min = this.normalizeAngle(this.min + minDiff * alpha);
-      } else {
-        const alpha = 1 - Math.exp(-dt / this.tau);
-        this.min = this.normalizeAngle(this.min + minDiff * alpha);
-      }
-      // Update max
-      if (maxDiff > 0) {
-        const alpha = 1 - Math.exp(-dt / this.catchupTau);
-        this.max = this.normalizeAngle(this.max + maxDiff * alpha);
-      } else {
-        const alpha = 1 - Math.exp(-dt / this.tau);
-        this.max = this.normalizeAngle(this.max + maxDiff * alpha);
-      }
-      
-    }
-  }
-
-  // For angles, returns the minimal arc between min and max
-  get range() {
-    if (!this.isAngle) {
-      return this.max - this.min;
-    } else {
-      let diff = this.angleDiff(this.max, this.min);
-      return Math.abs(diff);
-    }
-  }
-}
-
-module.exports = { LeakyExtremes };