speedandcurrent 1.4.2 → 1.5.1

package/leakyExtremes.js

@@ -0,0 +1,98 @@
+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 };

package/package.json

@@ -1,17 +1,16 @@
 {
   "name": "speedandcurrent",
-  "version": "1.4.2",
+  "version": "1.5.1",
   "description": "A plugin that automatically corrects boat speed and calculates current and leeway using sensor fusion.",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "author": "aswin.bouwmeester@gmail.com",
-  "license": "ISC",
+  "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Asw1n/speedandcurrent.git",
-    "directory": "./CHANGELOG.md"
+    "url": "git+https://github.com/Asw1n/speedandcurrent.git"
   },
   "bugs": {
     "url": "https://github.com/Asw1n/speedandcurrent/issues"
@@ -24,11 +23,17 @@
   ],
   "signalk-plugin-enabled-by-default": false,
   "signalk": {
-    "appIcon": "./icon.png",
+    "appIcon": "icon.png",
     "displayName": "Speed and current"
   },
   "dependencies": {
     "kalman-filter": "^2.3.0",
-    "signalkutilities": "^1.4.0"
-  }
+    "signalkutilities": "^1.5.1"
+  },
+  "files": [
+    "index.js",
+    "correctionTable.js",
+    "leakyExtremes.js",
+    "public/"
+  ]
 }

package/public/TableRenderer.js

@@ -3,8 +3,8 @@ class TableRenderer {
     this.formatColumnHeader = this.defaultDisplay;
     this.formatRowHeader = this.defaultDisplay;
     this.formatCell = this.defaultDisplay;
-    this.formatCellX = this.defaultDisplay;
-    this.formatCellY = this.defaultDisplay;
+    this.colorMode = 'none';
+    this.cachedExtents = {}; // store min/max per mode
   }
 
   setColumnHeaderFormat(columnHeader) {
@@ -19,18 +19,15 @@ class TableRenderer {
     cell != null ? this.formatCell = cell : this.formatCell = this.defaultDisplay;
   }
 
-  setCellFormatX(cellX) {
-    cellX != null ? this.formatCellX = cellX : this.formatCellX = this.defaultDisplay;
-  }
-
-  setCellFormatY(cellY) {
-    cellY != null ? this.formatCellY = cellY : this.formatCellY = this.defaultDisplay;
-  }
+  // Removed legacy X/Y specific formatting.
 
   render(data) {
     const {id, row, col, table, displayAttributes } = data;
     this.data = data;
     const label = displayAttributes && displayAttributes.label ? displayAttributes.label : "";
+
+    // Pre-compute extents for color modes (skip weight which is already normalized)
+    this.computeExtents(table);
     
     // Create a table element
     const tableElement = document.createElement('table');
@@ -90,7 +87,12 @@ class TableRenderer {
       else {
       cell.classList.add('emptyCell');
       }
-      if (value.displayAttributes && value.displayAttributes.selected) cell.classList.add('selectedCell');
+      if (value.displayAttributes && value.displayAttributes.selected) {
+        cell.classList.add('selectedCell');
+        //console.log(value);
+      }
+      // Apply coloring based on selected color mode
+      this.applyColor(cell, value, table);
 
       rowElement.appendChild(cell);
       cIndex++;
@@ -102,86 +104,136 @@ class TableRenderer {
     return value.toFixed(2);
   }
 
-  createSurfacePlot() {
-    const { row, col, table, id } = this.data;
+  setColorMode(mode) {
+    this.colorMode = mode || 'none';
+  }
 
-    // Format the axes values
-    const x = [];
-    for (let c = col.min; c <= col.max + 0.01; c += col.step) {
-      x.push(this.formatColumnHeader(c));
+  computeExtents(table) {
+    if (!Array.isArray(table)) return;
+  const modesToCompute = ['leeway','factor','trace'];
+    const accum = {};
+    for (const m of modesToCompute) {
+      accum[m] = {min: Infinity, max: -Infinity};
     }
-
-    const y = [];
-    for (let r = row.min; r <= row.max + 0.01; r += row.step) {
-      y.push(this.formatRowHeader(r));
+    for (const row of table) {
+      for (const cell of row) {
+        if (!cell || cell.N === 0) continue;
+        const {x,y} = cell;
+        // Prefer server-provided leeway for consistent scaling; fallback to placeholder
+        const leeway = Number.isFinite(cell.leeway)
+          ? cell.leeway
+          : (Number.isFinite(y) && Number.isFinite(x) ? Math.atan2(y, 1) : null);
+        if (leeway != null) {
+          if (leeway < accum.leeway.min) accum.leeway.min = leeway;
+          if (leeway > accum.leeway.max) accum.leeway.max = leeway;
+        }
+        if (Number.isFinite(cell.factor)) {
+          const f = cell.factor;
+            if (f < accum.factor.min) accum.factor.min = f;
+            if (f > accum.factor.max) accum.factor.max = f;
+        }
+        if (Number.isFinite(cell.trace)) {
+          const t = cell.trace;
+          if (t < accum.trace.min) accum.trace.min = t;
+          if (t > accum.trace.max) accum.trace.max = t;
+        }
+      }
     }
-    
+    this.cachedExtents = accum;
+  }
 
-    const zX = table.map(row => row.map(cell => cell.N > 0 ? cell.x : null)); // Assuming 'x' values for the surface plot
-    const zY = table.map(row => row.map(cell => cell.N > 0 ? cell.y : null)); // Assuming 'y' values for the surface plot
-
-    // Open a new window
-    const newWindow = window.open('', 'Correction Plot', 'width=1024,height=800');
-    newWindow.document.title = 'Correction Plot';
-
-    // Create div elements for the plots
-    const plotDivX = newWindow.document.createElement('div');
-    plotDivX.id = 'surfacePlotX';
-    plotDivX.style.width = '100%';
-    plotDivX.style.height = '400px';
-
-    const plotDivY = newWindow.document.createElement('div');
-    plotDivY.id = 'surfacePlotY';
-    plotDivY.style.width = '100%';
-    plotDivY.style.height = '400px';
-
-    newWindow.document.body.appendChild(plotDivX);
-    newWindow.document.body.appendChild(plotDivY);
-
-    // Data for the surface plots
-    const plotDataX = [{
-      type: 'surface',
-      x: x,
-      y: y,
-      z: zX
-    }];
-
-    const plotDataY = [{
-      type: 'surface',
-      x: x,
-      y: y,
-      z: zY
-    }];
-
-    // Layout for the surface plots
-    const layoutX = {
-      title: 'X-value',
-      autosize: true,
-      scene: {
-        xaxis: { title: 'Speed' },
-        yaxis: { title: 'Heel' },
-        zaxis: { title: 'Correction' }
-      }
-    };
-
-    const layoutY = {
-      title: 'Y-value',
-      autosize: true,
-      scene: {
-        xaxis: { title: 'Speed' },
-        yaxis: { title: 'Heel' },
-        zaxis: { title: 'Correction' }
+  applyColor(cell, value, table) {
+    if (this.colorMode === 'none') return;
+    // weight uses provided normWeight
+    if (this.colorMode === 'weight') {
+      const weight = value.displayAttributes && Number.isFinite(value.displayAttributes.normWeight) ? Math.min(1, value.displayAttributes.normWeight) : 0;
+      const scaled = Math.pow(weight, 0.4);
+      cell.style.backgroundColor = this.blueScale(scaled);
+      return;
+    }
+    if (value.N === 0) return;
+    let v = 0;
+    if (this.colorMode === 'leeway') v = Number.isFinite(value.leeway) ? value.leeway : Math.atan2(value.y, 1); // prefer server-provided leeway
+    else if (this.colorMode === 'factor') v = Number.isFinite(value.factor) ? value.factor : null;
+    else if (this.colorMode === 'trace') v = Number.isFinite(value.trace) ? value.trace : null;
+
+    const extent = this.cachedExtents[this.colorMode];
+    if (!extent || !Number.isFinite(v) || extent.min === Infinity) return;
+
+    let color;
+    {
+      // sequential for magnitude
+      let norm;
+      if (this.colorMode === 'leeway') {
+        // leeway uses absolute value; recompute extent assuming cached min/max are signed
+        const maxAbs = Math.max(Math.abs(extent.min), Math.abs(extent.max));
+        norm = maxAbs > 0 ? Math.min(1, Math.abs(v) / maxAbs) : 0;
+          if (norm === 0) {
+            return; // blank for zero leeway
+          }
+      } else if (this.colorMode === 'factor') {
+        // Asymmetric: baseline 1 -> blank. <1 use orange scale, >1 use green scale.
+        if (!Number.isFinite(v) || v <= 0) return; // invalid or zero forward -> blank
+        if (Math.abs(v - 1) < 1e-6) return; // exactly baseline
+        // Determine deviation span using max distance from 1 among sampled extents
+        const maxDev = Math.max(Math.abs(extent.min - 1), Math.abs(extent.max - 1));
+        if (maxDev <= 0) return;
+        const dev = (v - 1) / maxDev; // in [-1,1]
+        const a = Math.min(1, Math.abs(dev));
+        if (dev < 0) {
+          // compression (factor<1): white -> orange (#FFA500)
+          const r = Math.round(255 - (255-255)*a); // stays 255
+          const g = Math.round(255 - (255-165)*a); // 255 -> 165
+          const b = Math.round(255 - (255-0)*a);   // 255 -> 0
+          color = `rgb(${r},${g},${b})`;
+        } else {
+          // expansion (factor>1): white -> green (#00A050 slightly toned)
+          const target = {r:0,g:160,b:80};
+          const r = Math.round(255 - (255-target.r)*a);
+          const g = Math.round(255 - (255-target.g)*a);
+          const b = Math.round(255 - (255-target.b)*a);
+          color = `rgb(${r},${g},${b})`;
+        }
+        cell.style.backgroundColor = color;
+        return;
+      } else if (this.colorMode === 'trace') {
+        if (!Number.isFinite(v) || v <= 0) return; // blank for no/zero trace
+        // Scale 0..1
+        const normTrace = (v - extent.min) / (extent.max - extent.min || 1);
+        if (normTrace <= 0) return;
+        const t = Math.pow(Math.min(1, Math.max(0, normTrace)), 0.5); // gamma 0.5 for contrast
+        // White -> Purple (#8000FF) gradient
+        const target = { r: 128, g: 0, b: 255 };
+        const r = Math.round(255 - (255 - target.r) * t);
+        const g = Math.round(255 - (255 - target.g) * t);
+        const b = Math.round(255 - (255 - target.b) * t);
+        cell.style.backgroundColor = `rgb(${r},${g},${b})`;
+        return;
+      } else {
+        norm = (v - extent.min) / (extent.max - extent.min || 1); // 0..1
       }
-    };
+      color = this.blueScale(Math.pow(norm,0.5));
+    }
+    cell.style.backgroundColor = color;
+  }
 
-    const config = {
-      displayModeBar: false,
-      responsive: true // Ensure the plot is responsive
-    };
+  blueScale(t) {
+    // t in [0,1]; 0 = white, 1 = deep blue
+    if (!Number.isFinite(t)) t = 0;
+    if (t < 0) t = 0; else if (t > 1) t = 1;
+    const r = Math.round(255 - 255 * t);
+    const g = Math.round(255 - 255 * t);
+    const b = 255;
+    return `rgb(${r},${g},${b})`;
+  }
 
-    // Render the plots using Plotly
-    Plotly.newPlot(plotDivX, plotDataX, layoutX, config);
-    Plotly.newPlot(plotDivY, plotDataY, layoutY, config);
+  redBlueDiverging(n) {
+    // n in [-1,1]; negative=blue positive=red, 0=white
+    const t = (n+1)/2; // 0..1
+    const r = Math.round(255 * t);
+    const g = Math.round(255 * (1 - Math.abs(n)));
+    const b = Math.round(255 * (1 - t));
+    return `rgb(${r},${g},${b})`;
   }
 }