@meri-imperiumi/signalk-dead-reckoning 0.13.0 → 0.13.1

package/CHANGELOG.md

@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.13.1] - 2026-10-05
+
+### Fixed
+- The passage replay tool renders and fetches the short way across the antimeridian (`tools/replay-passage.js`): a track crossing 180° used to smear across the whole 360° span in the SVG track plot — the naive longitude min/max bounds turned 179E → 179W into a world-wide box — and the SCUD current grid fetch computed its 0–360 request box from the same raw bounds, returning nothing useful. Longitudes are now unwrapped against the first fix before bounds are computed, and the SCUD box is built by the new exported `trackBox()` helper in the server's 0–360 frame
+
 ## [0.13.0] - 2026-10-05
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meri-imperiumi/signalk-dead-reckoning",
-  "version": "0.13.0",
+  "version": "0.13.1",
   "description": "Offline-first dead reckoning and sensor fusion engine for Signal K",
   "main": "plugin/index.js",
   "scripts": {

package/tests/replay-passage.test.js

@@ -22,6 +22,8 @@ const {
   runReplay,
   summarize,
   currentAt,
+  toHtmlReport,
+  trackBox,
   PATH_SPECS,
 } = require("../tools/replay-passage.js");
 const {
@@ -316,3 +318,65 @@ test("leeway synthetic: the learning variant absorbs a 4° course offset", () =>
     `learn div ${last.learn.divNm}`,
   );
 });
+
+test("report plot: a track crossing the antimeridian renders contiguous", () => {
+  // A due-east track from 179°E crosses 180° and reads as -179° in the
+  // next fix (GPS wraps to [-180, 180]). The SVG plot must unwrap those
+  // longitudes so the polyline runs left-to-right across the seam —
+  // the naive min/max bounds used to smear the track across the whole
+  // 360° span.
+  const samples = [];
+  for (let i = 0; i < 20; i++) {
+    const lon = 179 + i * 0.2; // crosses 180 at i = 6
+    const wrapped = lon > 180 ? lon - 360 : lon;
+    samples.push({
+      tMs: Date.parse("2026-08-14T00:00:00Z") + i * DT_S * 1000,
+      gps: { latitude: -14, longitude: wrapped },
+      cold: {
+        position: { latitude: -14.001, longitude: wrapped },
+        divNm: 0.1 * i,
+      },
+    });
+  }
+  const summary = summarize(samples);
+  const html = toHtmlReport({
+    meta: {
+      vessel: "test",
+      from: "2026-08-14",
+      to: "2026-08-15",
+      historyUrl: "x",
+    },
+    samples,
+    summary,
+    hourly: [],
+  });
+  const polylines = html.match(/<polyline points="([^"]+)"/g);
+  assert.ok(polylines.length >= 1, "the report has a track polyline");
+  const gpsPts = polylines[0]
+    .match(/points="([^"]+)"/)[1]
+    .split(" ")
+    .map((p) => p.split(",").map(Number));
+  // x advances monotonically across the seam instead of jumping back
+  let monotonic = true;
+  for (let i = 1; i < gpsPts.length; i++) {
+    if (gpsPts[i][0] < gpsPts[i - 1][0] - 0.5) monotonic = false;
+  }
+  assert.ok(monotonic, "GPS polyline x is monotonic across the seam");
+  assert.ok(gpsPts[gpsPts.length - 1][0] > 800, "track spans the plot width");
+});
+
+test("trackBox: a seam-crossing track produces a contiguous SCUD box", () => {
+  // A track from 179E to 179W (wrapped at the seam by the GPS) must
+  // produce a box around 359-361 in the server's 0-360 frame — not the
+  // naive 179..359 span the raw min/max would request.
+  const track = [
+    { latitude: -14, longitude: 179.0 },
+    { latitude: -14.1, longitude: 179.5 },
+    { latitude: -14.2, longitude: -179.0 }, // wrapped at the seam
+  ];
+  const box = trackBox(track);
+  assert.ok(Math.abs(box.lonMin - 539) < 1e-9, `lonMin ${box.lonMin}`);
+  assert.ok(Math.abs(box.lonMax - 541) < 1e-9, `lonMax ${box.lonMax}`);
+  assert.ok(Math.abs(box.latMin - -14.2) < 1e-9);
+  assert.ok(Math.abs(box.latMax - -14) < 1e-9);
+});

package/tools/replay-passage.js

@@ -288,6 +288,42 @@ const SCUD_ERDDAP =
 /** Margin (deg) around the track bounds for the SCUD fetch box. */
 const SCUD_BOX_MARGIN_DEG = 0.5;
 
+/**
+ * Bounds of a GPS track as SCUD fetch-box coordinates: latitude in
+ * degrees, longitude in the server's 0–360 east frame. Longitudes are
+ * unwrapped against the first fix so a track crossing the antimeridian
+ * stays contiguous (179E → 181, not −179): the naive min/max would
+ * request a box spanning the whole Pacific.
+ *
+ * @param {{latitude: number, longitude: number}[]} track
+ * @returns {{latMin: number, latMax: number, lonMin: number, lonMax: number}}
+ */
+function trackBox(track) {
+  if (!track.length) {
+    return { latMin: 0, latMax: 0, lonMin: 360, lonMax: 360 };
+  }
+  const unwrap = (lon, ref) => lon - 360 * Math.round((lon - ref) / 360);
+  let latMin = Infinity;
+  let latMax = -Infinity;
+  let lonMinU = track[0].longitude;
+  let lonMaxU = lonMinU;
+  let prev = lonMinU;
+  for (const p of track) {
+    latMin = Math.min(latMin, p.latitude);
+    latMax = Math.max(latMax, p.latitude);
+    const u = unwrap(p.longitude, prev);
+    lonMinU = Math.min(lonMinU, u);
+    lonMaxU = Math.max(lonMaxU, u);
+    prev = u;
+  }
+  return {
+    latMin,
+    latMax,
+    lonMin: lonMinU + 360,
+    lonMax: lonMaxU + 360,
+  };
+}
+
 /**
  * Fetches a SCUD current grid over a lat/lon box and time range.
  *
@@ -860,22 +896,34 @@ function toHtmlReport(report) {
     if (s.gps) pts.push(s.gps);
     for (const k of keys) if (s[k]?.position) pts.push(s[k].position);
   }
-  let latMinV = Infinity;
-  let latMaxV = -Infinity;
-  let lonMinV = Infinity;
-  let lonMaxV = -Infinity;
+  let latMin = Infinity;
+  let latMax = -Infinity;
   for (const p of pts) {
-    latMinV = Math.min(latMinV, p.latitude);
-    latMaxV = Math.max(latMaxV, p.latitude);
-    lonMinV = Math.min(lonMinV, p.longitude);
-    lonMaxV = Math.max(lonMaxV, p.longitude);
+    latMin = Math.min(latMin, p.latitude);
+    latMax = Math.max(latMax, p.latitude);
+  }
+  // Unwrap longitudes against the first point so a track crossing the
+  // antimeridian stays contiguous (179 -> 181 instead of 179 -> -179,
+  // which the naive min/max would smear across the whole 360° span)
+  const unwrap = (lon, ref) => lon - 360 * Math.round((lon - ref) / 360);
+  const lon0 = pts.length ? pts[0].longitude : 0;
+  let lonMin = Infinity;
+  let lonMax = -Infinity;
+  let prev = lon0;
+  for (const p of pts) {
+    const u = unwrap(p.longitude, prev);
+    lonMin = Math.min(lonMin, u);
+    lonMax = Math.max(lonMax, u);
+    prev = u;
+  }
+  if (!pts.length) {
+    lonMin = 0;
+    lonMax = 0;
+    latMin = 0;
+    latMax = 0;
   }
-  const latMin = latMinV;
-  const latMax = latMaxV;
-  const lonMin = lonMinV;
-  const lonMax = lonMaxV;
   const latMid = ((latMin + latMax) / 2) * (Math.PI / 180);
-  const xOf = (lon) => (lon - lonMin) * Math.cos(latMid);
+  const xOf = (lon) => (unwrap(lon, lonMin) - lonMin) * Math.cos(latMid);
   const yOf = (lat) => latMax - lat;
   const spanX = Math.max(1e-9, xOf(lonMax));
   const spanY = Math.max(1e-9, yOf(latMin));
@@ -1050,18 +1098,17 @@ async function main(argv) {
   let scudGrid = null;
   if (opts.scud) {
     const track = rows.map((r) => r.position).filter(Boolean);
-    const lats = track.map((p) => p.latitude);
-    const lons = track.map((p) => p.longitude);
+    const { latMin, latMax, lonMin, lonMax } = trackBox(track);
     const scudFrom = new Date(Date.parse(opts.from) - 86400000).toISOString();
     const scudTo = new Date(Date.parse(opts.to) + 86400000).toISOString();
     try {
       scudGrid = await fetchScudGrid({
         from: scudFrom,
         to: scudTo,
-        latMin: Math.min(...lats) - SCUD_BOX_MARGIN_DEG,
-        latMax: Math.max(...lats) + SCUD_BOX_MARGIN_DEG,
-        lonMin: Math.min(...lons) + 360 - SCUD_BOX_MARGIN_DEG,
-        lonMax: Math.max(...lons) + 360 + SCUD_BOX_MARGIN_DEG,
+        latMin: latMin - SCUD_BOX_MARGIN_DEG,
+        latMax: latMax + SCUD_BOX_MARGIN_DEG,
+        lonMin: lonMin - SCUD_BOX_MARGIN_DEG,
+        lonMax: lonMax + SCUD_BOX_MARGIN_DEG,
       });
       process.stderr.write(
         `SCUD grid: ${scudGrid.timesMs.length} days (${scudGrid.timesMs
@@ -1145,6 +1192,7 @@ module.exports = {
   forwardFill,
   fetchHistory,
   fetchScudGrid,
+  trackBox,
   currentAt,
   runReplay,
   hourlyBuckets,