speedandcurrent 1.0.1 → 1.3.0

package/index.js

@@ -1,4 +1,4 @@
-const {  PolarStat, DeltaStat, DeltaBase, DeltaSubscribe, PolarDeltaBase, PolarDeltaCatch, PolarDeltaSubscribe, SI, Reporter } = require('signalkutilities');
+const { MessageHandler, Polar, PolarDamped, SI, Reporter } = require('signalkutilities');
 const { CorrectionTable } = require('./correctionTable.js');
 const { KalmanFilter } = require('kalman-filter');
 
@@ -7,13 +7,25 @@ const { KalmanFilter } = require('kalman-filter');
 
 module.exports = function (app) {
 
-  let unsubscribes = [];
   let options = {};
   let isRunning = false;
   let corrTable = null;
   let lastSave = null;
-  var residual, heading, attitude, boatSpeed, boatSpeedPolar, correctedBoatSpeed, groundSpeed, current, currentDelta, speedCorrection, reporter;
-
+  reportFullheading = null;
+  reportFullattitude = null;
+  reportFullcurrent = null;
+  reportFullcurrentStat = null;
+  reportFullboatSpeed = null;
+  reportFullboatSpeedStat = null;
+  reportFullcorrectedBoatSpeed = null;
+  reportFullboatSpeedRefGround = null;
+  reportFullgroundSpeed = null;
+  reportFullgroundSpeedStat = null;
+  reportFullspeedCorrection = null;
+  reportFullresidual = null;
+  reportFullreportFull = null;
+  var reportVector = null;
+  var table = null;
 
   const plugin = {};
   plugin.id = "SpeedAndCurrent";
@@ -63,6 +75,42 @@ module.exports = function (app) {
         description: "Correction table maximum speed.",
         default: 9
       },
+
+      headingSource: {
+        type: "string",
+        title: "Heading Source",
+        description: "Source to use for navigation.heading (optional).",
+        default: " "
+      },
+
+      boatSpeedSource: {
+        type: "string",
+        title: "Boat Speed Source",
+        description: "Source to use for navigation.speedThroughWater (optional).",
+        default: " "
+      },
+
+      COGSource: {
+        type: "string",
+        title: "Course over ground",
+        description: "Source to use for navigation.courseOverGroundTrue (optional)",
+        default: " "
+      },
+
+      SOGSource: {
+        type: "string",
+        title: "Ground Speed Source",
+        description: "Source to use for navigation.speedOverGround (optional)",
+        default: " "
+      },
+
+      attitudeSource: {
+        type: "string",
+        title: "Attitude Source",
+        description: "Source to use for navigation.attitude (optional)",
+        default: " "
+      },
+
       preventDuplication: {
         type: "boolean",
         title: "Prevent duplication of boat speed",
@@ -119,10 +167,10 @@ module.exports = function (app) {
         maximum: 8
       }
     }
-  }; 
-  
-   plugin.uiSchema = {
-     'ui:order': ["mode", "maxSpeed", "speedStep", "maxHeel", "heelStep", "preventDuplication", "updateCorrectionTable", "estimateBoatSpeed", "correctionStability", "doStartFresh", "assumeCurrent", "estimateCurrent", "currentStability"],
+  };
+
+  plugin.uiSchema = {
+    'ui:order': ["mode", "maxSpeed", "speedStep", "maxHeel", "heelStep", "headingSource", "boatSpeedSource", "COGSource", "SOGSource", "attitudeSource", "preventDuplication", "updateCorrectionTable", "estimateBoatSpeed", "correctionStability", "doStartFresh", "assumeCurrent", "estimateCurrent", "currentStability"],
     doStartFresh: {
       "ui:widget": "hidden",
     },
@@ -141,7 +189,7 @@ module.exports = function (app) {
     mode: {
       "ui:widget": "select",
     },
-     updateCorrectionTable: {
+    updateCorrectionTable: {
       "ui:widget": "hidden",
     },
     estimateBoatSpeed: {
@@ -163,7 +211,8 @@ module.exports = function (app) {
       "ui:widget": "hidden",
     }
   };
- 
+
+
   plugin.registerWithRouter = function (router) {
     app.debug('registerWithRouter');
 
@@ -172,9 +221,8 @@ module.exports = function (app) {
         res.status(503).json({ error: "Plugin is not running" });
       }
       else {
-        res.json(reporter?.getReport());
+        res.json(reportFull.report());
       }
-
     });
 
     router.get('/getVectors', (req, res) => {
@@ -182,30 +230,14 @@ module.exports = function (app) {
         res.status(503).json({ error: "Plugin is not running" });
       }
       else {
-        const v = { deltas: [], polars: [] };
-        const d = [heading, attitude];
-        const p = [groundSpeed, boatSpeedPolar, correctedBoatSpeed, current, speedCorrection, residual];
-        p.forEach(polar => {
-          v.polars.push({
-            id: polar.id,
-            plane: polar.plane,
-            label: polar.label,
-            speed: polar.pValue.speed,
-            angle: polar.pValue.angle,
-          });
-        });
-        d.forEach(delta => {
-          v.deltas.push({
-            id: delta.id,
-            value: delta.value,
-          });
-        });
-        res.json(v);
+        res.json(reportVector.report());
       }
     });
 
   }
 
+  // ...existing code...
+
   function saveTable(options, correctionTable) {
     options.correctionTable = correctionTable.toJSON();
     app.savePluginOptions(options, () => { app.debug('Correction table saved') });
@@ -214,125 +246,161 @@ module.exports = function (app) {
 
 
   plugin.start = (opts) => {
-    app.debug("plugin started");
- 
+    app.setPluginStatus("starting");
+    app.debug("plugin starting");
+
     // make options survive to the stop function
     options = opts;
     loadPresets();
 
     // correction table
-    const table = loadTable(options);
-    
+    table = loadTable(options);
+
 
     // heading
-    // TBD: headingTrue or headingMagnetic
-    heading = new DeltaSubscribe("navigation.headingTrue");
-    heading.subscribe(app, plugin.id, unsubscribes);
-    heading.setDisplayAttributes("heading","heading");
+    heading = new MessageHandler("heading", "navigation.headingTrue", options.headingSource);
+    heading.subscribe(app, plugin.id, true);
+    heading.setDisplayAttributes({ label: "heading" });
 
-    //attitude
-    attitude = new DeltaSubscribe("navigation.attitude");
+    // attitude
+    attitude = new MessageHandler("attitude", "navigation.attitude", options.attitudeSource);
     attitude.value = { pitch: 0, roll: 0, yaw: 0 }; //prevents errors when there is no attitude sensor
-    attitude.setDisplayAttributes("attitude","attitude");
-    attitude.subscribe(app, plugin.id, unsubscribes);
- 
-    // current
-    currentDelta = new DeltaBase("environment.current");
-    current = new PolarDeltaBase();
-    current.setDisplayAttributes("current", "ref_ground", "current");
-
-    const currentStat = new PolarStat(current);
+    attitude.setDisplayAttributes({ label: "attitude" });
+    attitude.subscribe(app, plugin.id, true);
 
-    // magnetic variance 
-    variance = new DeltaSubscribe("navigation.magneticVariation");
+    // current
+    current = new Polar("current", "self.environment.current.drift", "self.environment.current.setTrue");
+    current.setDisplayAttributes({ label: "current", plane: "Ground" });
+    current.setAngleRange('0to2pi');
+    currentStat = new PolarDamped("currentDamped", current);
+    currentStat.setAngleRange('0to2pi');
+    currentStat.timeConstant = 60; // Set time constant for damping
+    // Current should be initialised as no current
+    current.setVectorValue({ x: 0, y: 0 });
+    // There should be at least two samples, otherwise we can't calculate a valid speed
+    currentStat.sample();
+    currentStat.sample();
 
     // boat speed
-    if (options.preventDuplication) {
-      // DeltaCatch needed here 
-      boatSpeed = new DeltaSubscribe("navigation.speedThroughWater");
-      boatSpeed.subscribe(app, plugin.id, unsubscribes, calculate);
-    }
-    else {
-      boatSpeed = new DeltaSubscribe("navigation.speedThroughWater");
-      boatSpeed.subscribe(app, plugin.id, unsubscribes, calculate);
-    }
-
-    boatSpeedPolar = new PolarDeltaBase("navigation.speedThroughWater", "environment.wind.directionTruenavigation.leewayAngle");
-    boatSpeedPolar.setDisplayAttributes("boatSpeed", "ref_boat", "observed boat speed");
-    const boatSpeedStat = new PolarStat(boatSpeedPolar);
-
-    correctedBoatSpeed = new PolarDeltaBase("navigation.speedThroughWater", "environment.wind.directionTruenavigation.leewayAngle");
-    correctedBoatSpeed.setDisplayAttributes("correctedSpeed", "ref_boat", "estimated boat Speed");
+    boatSpeed = new Polar("boatSpeed", "navigation.speedThroughWater", options.boatSpeedSource);
+    boatSpeed.subscribe(app, plugin.id, true, false, !options.preventDuplication || !options.estimateBoatSpeed);
+    boatSpeed.setDisplayAttributes({ label: "boat speed", plane: "Boat" });
+    boatSpeedStat = new PolarDamped("boatSpeedDamped", boatSpeed);
+    boatSpeedStat.setDisplayAttributes({ label: "boat speed (damped)", plane: "Boat" });
 
-    boatSpeedRefGround = new PolarDeltaBase();
-    boatSpeedRefGround.setDisplayAttributes("boatSpeedRefGround", "ref_ground","boat speed over ground");
+    correctedBoatSpeed = new Polar("correctedBoatSpeed", "navigation.speedThroughWater", "environment.wind.directionTruenavigation.leewayAngle");
+    correctedBoatSpeed.setDisplayAttributes({ label: "corrected boat speed", plane: "Boat" });
+    //const correctedBoatSpeedStat = new PolarDamped("correctedBoatSpeedDamped", correctedBoatSpeed);
 
+    boatSpeedRefGround = new Polar("boatSpeedRefGround");
+    boatSpeedRefGround.setDisplayAttributes("boat speed over ground", "Ground");
 
     // ground speed
-    groundSpeed = new PolarDeltaSubscribe("navigation.speedOverGround", "navigation.courseOverGroundTrue");
-    groundSpeed.subscribe(app, plugin.id, unsubscribes);
-    groundSpeed.setDisplayAttributes("groundSpeed", "ref_ground", "observed speed over ground");
-    const groundSpeedStat = new PolarStat(groundSpeed);
+    groundSpeed = new Polar("groundSpeed", "navigation.speedOverGround", "navigation.courseOverGroundTrue", options.SOGSource, options.COGSource);
+    groundSpeed.subscribe(app, plugin.id, true, true, true);
+    groundSpeed.setDisplayAttributes({ label: "ground speed", plane: "Ground" });
+    groundSpeed.setAngleRange('0to2pi');
+    groundSpeedStat = new PolarDamped("groundSpeedDamped", groundSpeed);
+    groundSpeedStat.setDisplayAttributes({ label: "ground speed (damped)", plane: "Ground" });
+    groundSpeedStat.setAngleRange('0to2pi');
 
     // correction vector
-    speedCorrection = new PolarDeltaBase();
-    speedCorrection.setDisplayAttributes("correction", "ref_boat", "correction");
+    speedCorrection = new Polar("speedCorrection");
+    speedCorrection.setDisplayAttributes("speed correction", "Boat");
+    speedCorrection.setDisplayAttributes({ label: "speed correction", plane: "Boat" });
 
     // residual
-    residual = new PolarDeltaBase();
-    residual.setDisplayAttributes("residual", "ref_ground", "residual");
+    residual = new Polar("residual");
+    residual.setDisplayAttributes({ label: "residual", plane: "Ground" });
 
     // Make reporting object for webApp
-    reporter = new Reporter();
-
-    // filter for current
-    stability = 10 ** (options.currentStability);
-    const currentEstimator = new KalmanFilter({
-      observation: {
-        stateProjection: [[1, 0], [0, 1]], // observation matrix H
-        covariance: [[1 , 0], [0, 1 ]], //measurement noise R
-        dimension: 2
-      },
-      dynamic: {
-        transition: [[1, 0], [0, 1]], // state transition matrix F
-        covariance: [1 / stability, 1 / stability],// process noise covariance matrix Q
-        init: {
-          mean: [[0], [0]],
-          covariance: [[1 / stability, 0], [0, 1 / stability]]
+    reportFull = new Reporter();
+    reportFull.addDelta(heading);
+    reportFull.addAttitude(attitude);
+    reportFull.addPolar(groundSpeed);
+    reportFull.addPolar(boatSpeed);
+    //reportFull.addPolar(boatSpeedStat);
+    //reportFull.addPolar(groundSpeedStat);
+    reportFull.addPolar(speedCorrection);
+    reportFull.addPolar(correctedBoatSpeed);
+    reportFull.addPolar(current);
+    reportFull.addPolar(residual);
+    reportFull.addTable(table);
+
+    reportVector = new Reporter();
+    reportVector.addDelta(heading);
+    reportVector.addPolar(residual);
+    reportVector.addPolar(speedCorrection);
+    reportVector.addPolar(current);
+    reportVector.addPolar(correctedBoatSpeed);
+    reportVector.addPolar(boatSpeed);
+    reportVector.addPolar(groundSpeed);
+
+
+
+    app.debug("Analyzing input data");
+    let candidates = [heading, attitude, boatSpeed, groundSpeed];
+    // wait for all to settle
+    setTimeout(() => {
+      //app.debug(groundSpeed.magnitudeHandler);
+      //app.debug(groundSpeed.angleHandler);
+      // Check if all candidates get input data
+      candidates.forEach(candidate => {
+        if (candidate.lackingInputData()) {
+          app.setPluginStatus("Halted: insufficient input data");
+          app.debug("Insufficient input data for " + candidate.displayAttributes.label  );
+          return;
         }
+      });
+
+      // determing slowest input path and use this as a heartbeat for calculations
+      candidates.sort((a, b) => (a.frequency || 0) - (b.frequency || 0));
+
+     
+
+      if (!candidates[0].lackingInputData()) {
+        slowestInput = candidates[0];
+        app.debug("Using " + slowestInput.displayAttributes.label + " as heartbeat for calculations ( " + Math.round(candidates[0].frequency) + " updates per second)");
+        slowestInput.onChange = calculate;
+        if (slowestInput == groundSpeed) {
+          groundSpeed.onChange = () => {
+            groundSpeedStat.sample();
+            calculate();
+          };
+        }
+        else {
+          groundSpeed.onChange = () => {
+            groundSpeedStat.sample();
+          };
+        }
+        if (slowestInput == boatSpeed) {
+          boatSpeed.onChange = () => {
+            boatSpeedStat.sample();
+            calculate();
+          };
+        }
+        else {
+          boatSpeed.onChange = () => {
+            boatSpeedStat.sample();
+          };
+        }
+        
+        isRunning = true;
+        app.setPluginStatus("Running");
+        app.debug("Running");  
       }
-    });
-    let currentEstimation = null;
-
-    // filter for boat speed
-    stability = 10 ** (1);
-    const boatSpeedEstimator = new KalmanFilter({
-      observation: {
-        stateProjection: [[1, 0], [0, 1]], // observation matrix H
-        covariance: [[1 * stability, 0], [0, 1 * stability]], //measurement noise R
-        dimension: 2
-      },
-      dynamic: {
-        transition: [[1, 0], [0, 1]], // state transition matrix F
-        covariance: [1, 1],// process noise covariance matrix Q
-      }
-    });
-    let boatSpeedEstimation = null;
 
+    }, 5000);
 
-    isRunning = true;
+    
 
 
 
     // Main function, estimates boatSpeed, leeway and current
-    function calculate(timestamp) {
+    function calculate() {
       // prepare iteration
-      boatSpeedPolar.setVValue({ x: boatSpeed.value, y: 0 });
-      groundSpeedStat.sample();
-      currentStat.sample();
-      boatSpeedStat.sample();
       heel = attitude.value.roll;
-      speed = boatSpeed.value;
+      speed = boatSpeed.magnitude;
       theta = heading.value;
       if (!Number.isFinite(heel)) {
         app.debug("Heel is not a valid number, skipping calculation");
@@ -346,18 +414,11 @@ module.exports = function (app) {
         app.debug("Heading is not a valid number, skipping calculation");
         return;
       }
-      reporter.newReport();
-      reporter.addOptions(options);
-      reporter.addPolar( groundSpeed);
-      reporter.addPolar( boatSpeedPolar);
-      reporter.addAttitude( attitude);
-      reporter.addDelta( heading);
 
       // update correction table
       if (options.updateCorrectionTable) {
         table.update(speed, heel, groundSpeedStat, currentStat, boatSpeedStat, theta);
       }
-      reporter.addTable(table, speed, heel);
 
       // correct and estimate boat speed
       estimateBoatSpeed();
@@ -370,14 +431,10 @@ module.exports = function (app) {
 
 
       // Send calculated delta's
-      if (options.estimateCurrent) {
-        // translate current into signalK data structure
-        const c = current.getPValue();
-        const cc = { drift: current.speed, setTrue: current.angle, setMagnetic: (current.angle - variance.value + Math.PI) % (2 * Math.PI) - Math.PI };
-        currentDelta.setValue(cc);
-        DeltaBase.sendDeltas(app, plugin.id, [currentDelta]);
-      }
-      if (options.estimateBoatSpeed) PolarDeltaBase.sendDeltas(app, plugin.id, [correctedBoatSpeed]);
+      updates = [];
+      if (options.estimateCurrent) updates.push(current);
+      if (options.estimateBoatSpeed) updates.push(correctedBoatSpeed);
+      if (updates.length) Polar.send(app, plugin.id, updates);
 
       // Save correction table 
       // periodically 
@@ -389,31 +446,19 @@ module.exports = function (app) {
     // estimates boat speed from observed boatSpeed and correction
     function estimateBoatSpeed() {
       cor = table.getKalmanCorrection(speed, heel);
-      // app.debug(cor);
-      correctedBoatSpeed.copyFrom(boatSpeedPolar);
-      speedCorrection.setVValue(cor);
-
-      reporter.addPolar(speedCorrection);
+      correctedBoatSpeed.copyFrom(boatSpeed);
+      speedCorrection.setVectorValue(cor);
       correctedBoatSpeed.add(speedCorrection);
-      const v = correctedBoatSpeed.getVValue();
-      const observation = [v.x, v.y];
-      boatSpeedEstimation = boatSpeedEstimator.filter({ previousCorrected: boatSpeedEstimation, observation });
-      correctedBoatSpeed.setKValue(boatSpeedEstimation);
-      reporter.addPolar(correctedBoatSpeed);
     }
 
     // estimates current from observed groundspeed and estimated boatspeed 
     function estimateCurrent() {
       boatSpeedRefGround.copyFrom(correctedBoatSpeed);
       boatSpeedRefGround.rotate(theta);
-      reporter.addPolar( boatSpeedRefGround);
       current.copyFrom(groundSpeed);
       current.substract(boatSpeedRefGround);
-      const v = current.getVValue();
-      const observation = [v.x, v.y];
-      currentEstimation = currentEstimator.filter({ previousCorrected: currentEstimation, observation });
-      current.setKValue(currentEstimation);
-      reporter.addPolar( current);
+      currentStat.sample();
+      current.copyFrom(currentStat);
     }
 
     // Calculate what ground speed is observed that is not attributed to estimated boat speed or estimated current
@@ -423,14 +468,13 @@ module.exports = function (app) {
       boatSpeedRefGround.rotate(theta);
       residual.substract(boatSpeedRefGround);
       residual.substract(current);
-      reporter.addPolar(residual);
     }
 
     // Make sure the table matches the settings
-    function enforceConsistancy(row, col ) {
+    function enforceConsistancy(row, col) {
       // function is bugged due to IS units vs knots and degrees
       if (!options?.correctionTable) return false;
-      const table = options.correctionTable;
+      table = options.correctionTable;
       if (!table) return false;
       if (!table.row) return false;
       if (table.row.min != row.min) return false;
@@ -446,28 +490,28 @@ module.exports = function (app) {
       const row = { min: 0, max: SI.fromKnots(options.maxSpeed), step: SI.fromKnots(options.speedStep) };
       const col = { min: -SI.fromDegrees(options.maxHeel), max: SI.fromDegrees(options.maxHeel), step: SI.fromDegrees(options.heelStep) };
       let table;
-      if ( enforceConsistancy(row, col) && !options.doStartFresh) {
+      if (enforceConsistancy(row, col) && !options.doStartFresh) {
         table = CorrectionTable.fromJSON(options.correctionTable, options.correctionStability);
         app.debug("Correction table loaded");
         lastSave = new Date();
       }
       else {
-        table = new CorrectionTable(row, col, options.correctionStability);
+        table = new CorrectionTable("correctionTable", row, col, options.correctionStability);
         app.debug("Correction table created");
         options.doStartFresh = false;
         lastSave = saveTable(options, table);
       }
-      table.setDisplayAttributes("correctionTable", "Speed / Heel");
+      table.setDisplayAttributes({ label: "correction table" });
       return table;
     }
 
 
-    function loadPresets() { 
+    function loadPresets() {
       const modeEnum = plugin.schema.properties.mode.enum;
       app.debug("Loading presests for mode: " + options.mode);
 
       switch (modeEnum.indexOf(options.mode)) {
-        case  -1: 
+        case -1:
           app.debug("Invalid mode");
           app.debug(options);
           //options.mode = modeEnum[2]; 
@@ -480,7 +524,7 @@ module.exports = function (app) {
           options.assumeCurrent = false;
           options.estimateCurrent = false;
           options.correctionStability = 5;
-          options.mode = modeEnum[2]; 
+          options.mode = modeEnum[2];
           break;
         case 1:
           // new table, with current
@@ -491,7 +535,7 @@ module.exports = function (app) {
           options.estimateCurrent = false;
           options.correctionStability = 5;
           options.currentStability = 7;
-          options.mode = modeEnum[3]; 
+          options.mode = modeEnum[3];
           break;
         case 2:
           // fresh table, no current
@@ -501,7 +545,7 @@ module.exports = function (app) {
           options.assumeCurrent = false;
           options.estimateCurrent = false;
           options.correctionStability = 6;
-         break;
+          break;
         case 3:
           // fresh table, with current
           options.doStartFresh = false;
@@ -535,11 +579,11 @@ module.exports = function (app) {
           // locked table
           options.doStartFresh = false;
           options.updateCorrectionTable = false;
-          options.estimateBoatSpeed = false;
+          options.estimateBoatSpeed = true;
           options.assumeCurrent = true;
           options.estimateCurrent = true;
           options.currentStability = 2;
-          break;  
+          break;
         case 7:
           // all manual configuration;
           break;
@@ -557,31 +601,33 @@ module.exports = function (app) {
   }
 
 
-    plugin.stop = () => {
+  plugin.stop = () => {
     return new Promise((resolve, reject) => {
       try {
-        unsubscribes.forEach(f => f());
-        unsubscribes = [];
         //corrTable.save(app);
         if (corrTable != null) {
           lastSave = saveTable(options, corrTable);
         }
-        options = {};
-  
-        residual = null;
+
         heading = null;
         attitude = null;
+        current = null;
+        currentStat = null;
         boatSpeed = null;
-        boatSpeedPolar = null;
+        boatSpeedStat = null;
         correctedBoatSpeed = null;
+        boatSpeedRefGround = null;
         groundSpeed = null;
-        current = null;
-        currentDelta = null;
+        groundSpeedStat = null;
         speedCorrection = null;
-        reporter = null;
+        residual = null;
+        reportFull = null;
+        reportVector = null;
+        table =
+          app.setPluginStatus("Stopped");
+        app.debug("Stopped");
+
         isRunning = false;
-        corrTable = null;
-  
         resolve();
       } catch (error) {
         reject(error);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "speedandcurrent",
-  "version": "1.0.1",
-  "description": "An experimental plugin that uses sensor fusion to get boat speed, current and leeway.",
+  "version": "1.3.0",
+  "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"
@@ -29,6 +29,6 @@
   },
   "dependencies": {
     "kalman-filter": "^2.3.0",
-    "signalkutilities": "^1.0.0"
+    "signalkutilities": "^1.3.0"
   }
 }

package/public/TableRenderer.js

@@ -28,11 +28,13 @@ class TableRenderer {
   }
 
   render(data) {
-    const { row, col, table, selected, id, label } = data;
+    const {id, row, col, table, displayAttributes } = data;
     this.data = data;
-
+    const label = displayAttributes && displayAttributes.label ? displayAttributes.label : "";
+    
     // Create a table element
     const tableElement = document.createElement('table');
+  
     tableElement.id = id;
     tableElement.classList.add('Table2D');
     // create header row
@@ -41,7 +43,7 @@ class TableRenderer {
     // Create other rows 
     var rIndex = 0;
     for (let r = row.min; r <= row.max + 0.01; r += row.step) {
-      tableElement.appendChild(this.tableRow(r, rIndex, col, table, selected));
+      tableElement.appendChild(this.tableRow(r, rIndex, col, table));
       rIndex++;
     }
     return tableElement;
@@ -54,7 +56,7 @@ class TableRenderer {
     firstHeaderCell.innerText = label ? label : ''; 
     firstHeaderCell.classList.add('TableRowHeader');
     headerRow.appendChild(firstHeaderCell);
-
+  
     // Create header row 
     for (let c = col.min; c <= col.max + 0.01; c += col.step) {
       const headerCell = document.createElement('th');
@@ -73,7 +75,7 @@ class TableRenderer {
     return headerCell;
   }
 
-  tableRow(r, rIndex, col, table, selected) {
+  tableRow(r, rIndex, col, table) {
     var cIndex = 0;
     const rowElement = document.createElement('tr');
     rowElement.appendChild(this.rowLabel(r));
@@ -88,7 +90,7 @@ class TableRenderer {
       else {
       cell.classList.add('emptyCell');
       }
-      if (selected[0] == rIndex && selected[1] == cIndex) cell.classList.add('selectedCell');
+      if (value.displayAttributes && value.displayAttributes.selected) cell.classList.add('selectedCell');
 
       rowElement.appendChild(cell);
       cIndex++;