gnss-js 1.11.0 → 1.13.0

package/dist/{chunk-LKFSXVIZ.js → chunk-E5CP37P2.js}

@@ -2,7 +2,7 @@ import {
   computeDop,
   computeSatPosition,
   ecefToAzEl
-} from "./chunk-DMNFB7Q6.js";
+} from "./chunk-VAHMHYID.js";
 import {
   ecefToGeodetic
 } from "./chunk-37QNKGTC.js";

package/dist/{chunk-77VUSDNI.js → chunk-HXF7XVW7.js}

@@ -695,6 +695,496 @@ function parseIonex(text) {
   return { epochs, lats, lons, maps };
 }
 
+// src/rinex/sp3.ts
+var BAD_CLOCK = 999999.999999;
+function parseSp3(text) {
+  const lines = text.split("\n");
+  const epochs = [];
+  const satellites = {};
+  let version = "";
+  let intervalSec = 0;
+  let timeSystem = "GPS";
+  let timeSystemSet = false;
+  let epochIdx = -1;
+  for (const line of lines) {
+    if (!version && line.startsWith("#") && line.charAt(1) !== "#") {
+      version = line.charAt(1);
+    }
+    if (line.startsWith("##")) {
+      const f = line.slice(2).trim().split(/\s+/);
+      intervalSec = Number(f[2]) || 0;
+    } else if (line.startsWith("%c") && !timeSystemSet) {
+      const sys = line.slice(9, 12).trim();
+      if (sys && !/^c+$/.test(sys)) {
+        timeSystem = sys;
+        timeSystemSet = true;
+      }
+    } else if (line.startsWith("*")) {
+      const f = line.slice(1).trim().split(/\s+/).map(Number);
+      if (f.length >= 6 && f.every(Number.isFinite)) {
+        const sec = f[5];
+        epochs.push(
+          Date.UTC(
+            f[0],
+            f[1] - 1,
+            f[2],
+            f[3],
+            f[4],
+            Math.floor(sec),
+            Math.round(sec % 1 * 1e3)
+          )
+        );
+        epochIdx++;
+      }
+    } else if (line.startsWith("P") && epochIdx >= 0) {
+      const prn = line.slice(1, 4).replace(/\s/g, "0");
+      const f = line.slice(4).trim().split(/\s+/).map(Number);
+      if (f.length < 3) continue;
+      const [xKm, yKm, zKm] = f;
+      let arr = satellites[prn];
+      if (!arr) satellites[prn] = arr = [];
+      while (arr.length < epochIdx) arr.push(null);
+      if (xKm === 0 && yKm === 0 && zKm === 0) {
+        arr.push(null);
+        continue;
+      }
+      const clkUs = f[3];
+      arr.push({
+        x: xKm * 1e3,
+        y: yKm * 1e3,
+        z: zKm * 1e3,
+        clk: clkUs !== void 0 && Math.abs(clkUs) < BAD_CLOCK ? clkUs * 1e-6 : null
+      });
+    }
+  }
+  for (const arr of Object.values(satellites)) {
+    while (arr.length < epochs.length) arr.push(null);
+  }
+  return { version, epochs, intervalSec, timeSystem, satellites };
+}
+function sp3Position(sp3, prn, tMs, order = 9) {
+  const samples = sp3.satellites[prn];
+  const { epochs } = sp3;
+  const n = epochs.length;
+  if (!samples || n < order) return null;
+  if (tMs < epochs[0] || tMs > epochs[n - 1]) return null;
+  let lo = 0;
+  let hi = n - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (epochs[mid] <= tMs) lo = mid;
+    else hi = mid - 1;
+  }
+  let start = lo - (order >> 1) + (order % 2 === 0 ? 1 : 0);
+  start = Math.max(0, Math.min(n - order, start));
+  for (let i = start; i < start + order; i++) {
+    if (!samples[i]) return null;
+  }
+  const t0 = epochs[start];
+  const t = (tMs - t0) / 1e3;
+  let x = 0;
+  let y = 0;
+  let z = 0;
+  for (let i = 0; i < order; i++) {
+    const ti = (epochs[start + i] - t0) / 1e3;
+    let w = 1;
+    for (let j = 0; j < order; j++) {
+      if (j === i) continue;
+      const tj = (epochs[start + j] - t0) / 1e3;
+      w *= (t - tj) / (ti - tj);
+    }
+    const s = samples[start + i];
+    x += w * s.x;
+    y += w * s.y;
+    z += w * s.z;
+  }
+  let clk = null;
+  const a = samples[lo];
+  const b = samples[Math.min(lo + 1, n - 1)];
+  if (a?.clk != null && b?.clk != null) {
+    const span = epochs[Math.min(lo + 1, n - 1)] - epochs[lo];
+    const f = span > 0 ? (tMs - epochs[lo]) / span : 0;
+    clk = a.clk * (1 - f) + b.clk * f;
+  } else if (a?.clk != null) {
+    clk = a.clk;
+  }
+  return { x, y, z, clk };
+}
+
+// src/rinex/obs-writer-common.ts
+function createGzipLineSink() {
+  const encoder = new TextEncoder();
+  const compressor = new CompressionStream("gzip");
+  const writer = compressor.writable.getWriter();
+  const compressedChunks = [];
+  const readerDone = (async () => {
+    const reader = compressor.readable.getReader();
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      compressedChunks.push(value);
+    }
+  })();
+  let batch = [];
+  async function flush() {
+    if (batch.length === 0) return;
+    await writer.write(encoder.encode(batch.join("\n") + "\n"));
+    batch = [];
+  }
+  return {
+    push(line) {
+      batch.push(line);
+    },
+    flush,
+    async finish() {
+      await flush();
+      await writer.close();
+      await readerDone;
+      return new Blob(compressedChunks, {
+        type: "application/gzip"
+      });
+    }
+  };
+}
+function stationHeaderLines(header) {
+  const pos = header.approxPosition ?? [0, 0, 0];
+  const delta = header.antDelta ?? [0, 0, 0];
+  return [
+    hdrLine(header.markerName || "UNKNOWN", "MARKER NAME"),
+    hdrLine("", "MARKER NUMBER"),
+    hdrLine(
+      `${padL(header.observer || "", 20)}${padL(header.agency || "", 40)}`,
+      "OBSERVER / AGENCY"
+    ),
+    hdrLine(
+      `${padL(header.receiverNumber || "", 20)}${padL(header.receiverType || "", 20)}${padL(header.receiverVersion || "", 20)}`,
+      "REC # / TYPE / VERS"
+    ),
+    hdrLine(
+      `${padL(header.antNumber || "", 20)}${padL(header.antType || "", 20)}`,
+      "ANT # / TYPE"
+    ),
+    hdrLine(
+      `${fmtF(pos[0], 14, 4)}${fmtF(pos[1], 14, 4)}${fmtF(pos[2], 14, 4)}`,
+      "APPROX POSITION XYZ"
+    ),
+    hdrLine(
+      `${fmtF(delta[0], 14, 4)}${fmtF(delta[1], 14, 4)}${fmtF(delta[2], 14, 4)}`,
+      "ANTENNA: DELTA H/E/N"
+    )
+  ];
+}
+
+// src/rinex/obs-writer.ts
+function writeRinexObsBlob(header, epochs, obsTypes) {
+  return writeModernObsBlob(header, epochs, obsTypes, {
+    version: "3.04",
+    comment: "Merged from multiple RINEX files"
+  });
+}
+async function writeModernObsBlob(header, epochs, obsTypes, opts) {
+  if (epochs.length === 0) return new Blob([], { type: "application/gzip" });
+  const sink = createGzipLineSink();
+  const BATCH = 200;
+  const systems = [...obsTypes.keys()];
+  const sysChar = systems.length === 1 ? systems[0] : "M";
+  sink.push(
+    hdrLine(
+      `     ${opts.version}           OBSERVATION DATA    ${sysChar}`,
+      "RINEX VERSION / TYPE"
+    )
+  );
+  const now = /* @__PURE__ */ new Date();
+  const dateStr = `${now.getUTCFullYear()}${String(now.getUTCMonth() + 1).padStart(2, "0")}${String(now.getUTCDate()).padStart(2, "0")} ${String(now.getUTCHours()).padStart(2, "0")}${String(now.getUTCMinutes()).padStart(2, "0")}${String(now.getUTCSeconds()).padStart(2, "0")} UTC`;
+  sink.push(
+    hdrLine(
+      `${padL("GNSSCalc", 20)}${padL("", 20)}${dateStr}`,
+      "PGM / RUN BY / DATE"
+    )
+  );
+  sink.push(hdrLine(opts.comment, "COMMENT"));
+  for (const line of stationHeaderLines(header)) sink.push(line);
+  for (const [sys, types] of obsTypes) {
+    for (let i = 0; i < types.length; i += 13) {
+      const chunk = types.slice(i, i + 13);
+      let content;
+      if (i === 0) {
+        content = `${sys}  ${padR(String(types.length), 3)}`;
+      } else {
+        content = "      ";
+      }
+      content += chunk.map((t) => ` ${padL(t, 3)}`).join("");
+      sink.push(hdrLine(content, "SYS / # / OBS TYPES"));
+    }
+  }
+  const timeSys = systems.includes("R") && systems.length === 1 ? "GLO" : "GPS";
+  const obsTimeLine = (d) => `  ${d.getUTCFullYear()}    ${String(d.getUTCMonth() + 1).padStart(2)}    ${String(d.getUTCDate()).padStart(2)}    ${String(d.getUTCHours()).padStart(2)}    ${String(d.getUTCMinutes()).padStart(2)}   ${(d.getUTCSeconds() + d.getUTCMilliseconds() / 1e3).toFixed(7).padStart(10)}     ${timeSys}`;
+  sink.push(
+    hdrLine(obsTimeLine(new Date(epochs[0].time)), "TIME OF FIRST OBS")
+  );
+  sink.push(
+    hdrLine(
+      obsTimeLine(new Date(epochs[epochs.length - 1].time)),
+      "TIME OF LAST OBS"
+    )
+  );
+  if (epochs.length >= 2) {
+    const interval = (epochs[1].time - epochs[0].time) / 1e3;
+    if (interval > 0 && interval < 3600) {
+      sink.push(hdrLine(fmtF(interval, 10, 3), "INTERVAL"));
+    }
+  }
+  if (header.glonassSlots && Object.keys(header.glonassSlots).length > 0) {
+    const entries = Object.entries(header.glonassSlots).sort(
+      ([a], [b]) => Number(a) - Number(b)
+    );
+    for (let i = 0; i < entries.length; i += 8) {
+      const chunk = entries.slice(i, i + 8);
+      let content = i === 0 ? padR(String(entries.length), 3) + " " : "    ";
+      for (const [slot, freq] of chunk) {
+        content += `R${padR(slot, 2)} ${padR(String(freq), 2)} `;
+      }
+      sink.push(hdrLine(content, "GLONASS SLOT / FRQ #"));
+    }
+  }
+  sink.push(hdrLine("", "END OF HEADER"));
+  await sink.flush();
+  let epochCount = 0;
+  for (const epoch of epochs) {
+    const t = new Date(epoch.time);
+    const sec = t.getUTCSeconds() + t.getUTCMilliseconds() / 1e3;
+    const prns = [...epoch.sats.keys()].sort();
+    sink.push(
+      `> ${t.getUTCFullYear()} ${String(t.getUTCMonth() + 1).padStart(2, "0")} ${String(t.getUTCDate()).padStart(2, "0")} ${String(t.getUTCHours()).padStart(2, "0")} ${String(t.getUTCMinutes()).padStart(2, "0")}${fmtF(sec, 11, 7)}  0${padR(String(prns.length), 3)}`
+    );
+    for (const prn of prns) {
+      const sys = prn[0];
+      const sysTypes = obsTypes.get(sys);
+      if (!sysTypes) continue;
+      const valArr = epoch.sats.get(prn);
+      let line = prn;
+      for (let i = 0; i < sysTypes.length; i++) {
+        const val = i < valArr.length ? valArr[i] : NaN;
+        if (!isNaN(val)) {
+          line += fmtF(val, 14, 3) + "  ";
+        } else {
+          line += " ".repeat(16);
+        }
+      }
+      sink.push(line);
+    }
+    epochCount++;
+    if (epochCount % BATCH === 0) await sink.flush();
+  }
+  return sink.finish();
+}
+
+// src/rinex/obs-writer-v2.ts
+var V3_TO_V2 = {
+  // GPS
+  C1C: "C1",
+  C1S: "C1",
+  C1L: "C1",
+  C1X: "C1",
+  C1W: "P1",
+  C1P: "P1",
+  C2C: "C2",
+  C2S: "P2",
+  C2L: "P2",
+  C2X: "P2",
+  C2W: "P2",
+  C2P: "P2",
+  C5I: "C5",
+  C5Q: "C5",
+  C5X: "C5",
+  L1C: "L1",
+  L1S: "L1",
+  L1L: "L1",
+  L1X: "L1",
+  L1W: "L1",
+  L1P: "L1",
+  L2C: "L2",
+  L2S: "L2",
+  L2L: "L2",
+  L2X: "L2",
+  L2W: "L2",
+  L2P: "L2",
+  L5I: "L5",
+  L5Q: "L5",
+  L5X: "L5",
+  D1C: "D1",
+  D1S: "D1",
+  D1L: "D1",
+  D1X: "D1",
+  D1W: "D1",
+  D1P: "D1",
+  D2C: "D2",
+  D2S: "D2",
+  D2L: "D2",
+  D2X: "D2",
+  D2W: "D2",
+  D2P: "D2",
+  D5I: "D5",
+  D5Q: "D5",
+  D5X: "D5",
+  S1C: "S1",
+  S1S: "S1",
+  S1L: "S1",
+  S1X: "S1",
+  S1W: "S1",
+  S1P: "S1",
+  S2C: "S2",
+  S2S: "S2",
+  S2L: "S2",
+  S2X: "S2",
+  S2W: "S2",
+  S2P: "S2",
+  S5I: "S5",
+  S5Q: "S5",
+  S5X: "S5"
+};
+function v3ToV2Code(code3) {
+  return V3_TO_V2[code3] ?? null;
+}
+async function writeRinex2ObsBlob(header, epochs, obsTypes) {
+  if (epochs.length === 0) return new Blob([], { type: "application/gzip" });
+  const gpsCodes = obsTypes.get("G") ?? obsTypes.get("R") ?? [];
+  const v2Codes = [];
+  const v2CodeSet = /* @__PURE__ */ new Set();
+  const v3ToV2Map = /* @__PURE__ */ new Map();
+  for (const code3 of gpsCodes) {
+    const code2 = v3ToV2Code(code3);
+    if (!code2) continue;
+    if (!v2CodeSet.has(code2)) {
+      v2CodeSet.add(code2);
+      v3ToV2Map.set(code3, v2Codes.length);
+      v2Codes.push(code2);
+    } else {
+      v3ToV2Map.set(code3, v2Codes.indexOf(code2));
+    }
+  }
+  const gloCodes = obsTypes.get("R") ?? [];
+  for (const code3 of gloCodes) {
+    const code2 = v3ToV2Code(code3);
+    if (!code2) continue;
+    if (!v2CodeSet.has(code2)) {
+      v2CodeSet.add(code2);
+      v3ToV2Map.set(code3, v2Codes.length);
+      v2Codes.push(code2);
+    } else if (!v3ToV2Map.has(code3)) {
+      v3ToV2Map.set(code3, v2Codes.indexOf(code2));
+    }
+  }
+  const sink = createGzipLineSink();
+  const BATCH = 200;
+  const hasSystems = /* @__PURE__ */ new Set();
+  for (const epoch of epochs) {
+    for (const prn of epoch.sats.keys()) {
+      const sys = prn[0];
+      if (sys === "G" || sys === "R") hasSystems.add(sys);
+    }
+  }
+  const sysChar = hasSystems.has("G") && hasSystems.has("R") ? "M" : hasSystems.has("R") ? "R" : "G";
+  sink.push(
+    hdrLine(
+      `     2.11           OBSERVATION DATA    ${sysChar}`,
+      "RINEX VERSION / TYPE"
+    )
+  );
+  const now = /* @__PURE__ */ new Date();
+  const dateStr = `${now.getUTCFullYear()}-${String(now.getUTCMonth() + 1).padStart(2, "0")}-${String(now.getUTCDate()).padStart(2, "0")} ${String(now.getUTCHours()).padStart(2, "0")}:${String(now.getUTCMinutes()).padStart(2, "0")}:${String(now.getUTCSeconds()).padStart(2, "0")}`;
+  sink.push(
+    hdrLine(
+      `${padL("GNSSCalc", 20)}${padL("", 20)}${dateStr}`,
+      "PGM / RUN BY / DATE"
+    )
+  );
+  sink.push(hdrLine("Converted from RINEX 3 by GNSSCalc", "COMMENT"));
+  for (const line of stationHeaderLines(header)) sink.push(line);
+  sink.push(hdrLine("     1     1", "WAVELENGTH FACT L1/2"));
+  for (let i = 0; i < v2Codes.length; i += 9) {
+    const chunk = v2Codes.slice(i, i + 9);
+    let content;
+    if (i === 0) {
+      content = padR(String(v2Codes.length), 6);
+    } else {
+      content = "      ";
+    }
+    content += chunk.map((c) => padR(c, 6)).join("");
+    sink.push(hdrLine(content, "# / TYPES OF OBSERV"));
+  }
+  const first = new Date(epochs[0].time);
+  const timeSys = sysChar === "R" ? "GLO" : "GPS";
+  sink.push(
+    hdrLine(
+      `  ${first.getUTCFullYear()}    ${String(first.getUTCMonth() + 1).padStart(2)}    ${String(first.getUTCDate()).padStart(2)}    ${String(first.getUTCHours()).padStart(2)}    ${String(first.getUTCMinutes()).padStart(2)}   ${(first.getUTCSeconds() + first.getUTCMilliseconds() / 1e3).toFixed(7).padStart(10)}     ${timeSys}`,
+      "TIME OF FIRST OBS"
+    )
+  );
+  sink.push(hdrLine("", "END OF HEADER"));
+  await sink.flush();
+  let epochCount = 0;
+  for (const epoch of epochs) {
+    const t = new Date(epoch.time);
+    const sec = t.getUTCSeconds() + t.getUTCMilliseconds() / 1e3;
+    const prns = [...epoch.sats.keys()].filter((p) => p[0] === "G" || p[0] === "R").sort();
+    if (prns.length === 0) continue;
+    const yy = t.getUTCFullYear() % 100;
+    const yyS = padR(String(yy), 2);
+    const moS = padR(String(t.getUTCMonth() + 1), 2);
+    const ddS = padR(String(t.getUTCDate()), 2);
+    const hhS = padR(String(t.getUTCHours()), 2);
+    const mmS = padR(String(t.getUTCMinutes()), 2);
+    const secS = fmtF(sec, 11, 7);
+    const nSats = padR(String(prns.length), 3);
+    let epochLine = ` ${yyS} ${moS} ${ddS} ${hhS} ${mmS}${secS}  0${nSats}`;
+    for (let i = 0; i < prns.length; i++) {
+      if (i > 0 && i % 12 === 0) {
+        sink.push(epochLine);
+        epochLine = " ".repeat(32);
+      }
+      epochLine += prns[i];
+    }
+    sink.push(epochLine);
+    for (const prn of prns) {
+      const sys = prn[0];
+      const sysCodes3 = obsTypes.get(sys) ?? [];
+      const valArr = epoch.sats.get(prn);
+      const v2Vals = new Array(v2Codes.length).fill(NaN);
+      for (let j = 0; j < sysCodes3.length; j++) {
+        const v2Idx = v3ToV2Map.get(sysCodes3[j]);
+        if (v2Idx != null && j < valArr.length && !isNaN(valArr[j])) {
+          v2Vals[v2Idx] = valArr[j];
+        }
+      }
+      let line = "";
+      for (let j = 0; j < v2Codes.length; j++) {
+        const val = v2Vals[j];
+        if (!isNaN(val)) {
+          line += fmtF(val, 14, 3) + "  ";
+        } else {
+          line += " ".repeat(16);
+        }
+        if ((j + 1) % 5 === 0 || j === v2Codes.length - 1) {
+          sink.push(line);
+          line = "";
+        }
+      }
+    }
+    epochCount++;
+    if (epochCount % BATCH === 0) await sink.flush();
+  }
+  return sink.finish();
+}
+
+// src/rinex/obs-writer-v4.ts
+function writeRinex4ObsBlob(header, epochs, obsTypes) {
+  return writeModernObsBlob(header, epochs, obsTypes, {
+    version: "4.01",
+    comment: "Converted to RINEX 4 by GNSSCalc"
+  });
+}
+
 export {
   padL,
   padR,
@@ -704,5 +1194,13 @@ export {
   WarningAccumulator,
   parseNavFile,
   writeRinexNav,
-  parseIonex
+  parseIonex,
+  parseSp3,
+  sp3Position,
+  createGzipLineSink,
+  stationHeaderLines,
+  writeRinexObsBlob,
+  writeModernObsBlob,
+  writeRinex2ObsBlob,
+  writeRinex4ObsBlob
 };

package/dist/{chunk-DMNFB7Q6.js → chunk-VAHMHYID.js}

@@ -506,8 +506,14 @@ function computeVisibility(ephemerides, rxPos, startMs, endMs, stepSec = 300, el
   const stepMs = stepSec * 1e3;
   const times = [];
   for (let t = startMs; t <= endMs; t += stepMs) times.push(t);
+  return computeVisibilityFromPositions(
+    computeAllPositions(ephemerides, times, rxPos),
+    elevationMaskDeg
+  );
+}
+function computeVisibilityFromPositions(all, elevationMaskDeg = 10) {
+  const times = all.times;
   const maskRadFor = maskRadForAzimuth(elevationMaskDeg);
-  const all = computeAllPositions(ephemerides, times, rxPos);
   const elevation = {};
   const azimuth = {};
   const subLat = {};
@@ -605,5 +611,6 @@ export {
   ephInfoToEphemeris,
   computeLiveSkyPositions,
   maskRadForAzimuth,
-  computeVisibility
+  computeVisibility,
+  computeVisibilityFromPositions
 };