seqeyes-python 0.2.0__tar.gz → 0.2.2__tar.gz

{seqeyes_python-0.2.0 → seqeyes_python-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seqeyes-python
-Version: 0.2.0
+Version: 0.2.2
 Summary: Interactive Pulseq MRI sequence viewer for Jupyter — lightweight, beautiful, replaces seq.plot() in pypulseq.
 Project-URL: Homepage, https://github.com/bughht/seqeyes_plugin
 Project-URL: Repository, https://github.com/bughht/seqeyes_plugin

{seqeyes_python-0.2.0 → seqeyes_python-0.2.2}/examples/demo.ipynb

@@ -53,7 +53,7 @@
     "import pypulseq as pp\n",
     "\n",
     "# ── Enable SeqEyes (once per session) ──\n",
-    "seqeyes.set(time_disp=\"ms\", grad_disp=\"kHz/m\")\n",
+    "seqeyes.set(time_disp=\"ms\", grad_disp=\"Hz/m\")\n",
     "print(f\"SeqEyes {seqeyes.__version__} — seq.plot() is now interactive!\")\n",
     "\n",
     "# ═══════════════════════════════════════════════════════════════════════\n",
@@ -225,7 +225,7 @@
     }
    ],
    "source": [
-    "seq_gre.plot(time_range=(0, tr_gre), time_disp=\"ms\", grad_disp=\"kHz/m\", theme=\"dark\")"
+    "seq_gre.plot(time_range=(0, tr_gre), time_disp=\"ms\", grad_disp=\"Hz/m\", theme=\"dark\")"
    ]
   },
   {
@@ -259,7 +259,7 @@
     }
    ],
    "source": [
-    "seq_epi.plot(time_disp=\"ms\", grad_disp=\"kHz/m\", theme=\"dark\")"
+    "seq_epi.plot(time_disp=\"ms\", grad_disp=\"Hz/m\", theme=\"dark\")"
    ]
   },
   {
@@ -293,7 +293,7 @@
     }
    ],
    "source": [
-    "seq_rad.plot(time_disp=\"ms\", grad_disp=\"kHz/m\", theme=\"dark\")"
+    "seq_rad.plot(time_disp=\"ms\", grad_disp=\"Hz/m\", theme=\"dark\")"
    ]
   },
   {
@@ -311,7 +311,7 @@
     "| `show_blocks` | `False` | Show block‑boundary lines |\n",
     "| `time_range` | `(0, inf)` | Zoom to `(start_sec, end_sec)` |\n",
     "| `time_disp` | `\"s\"` | Time unit: `\"s\"`, `\"ms\"`, `\"us\"` |\n",
-    "| `grad_disp` | `\"kHz/m\"` | Gradient unit: `\"Hz/m\"`, `\"kHz/m\"`, `\"mT/m\"`, `\"G/cm\"` |\n",
+    "| `grad_disp` | `\"Hz/m\"` | Gradient unit: `\"Hz/m\"`, `\"Hz/m\"`, `\"mT/m\"`, `\"G/cm\"` |\n",
     "| `theme` | `\"system\"` | `\"light\"`, `\"dark\"`, `\"dracula\"`, `\"nord\"`, ... |"
    ]
   },
@@ -336,7 +336,7 @@
    ],
    "source": [
     "# Zoom to first TR with block boundaries + custom units\n",
-    "seqeyes.set(show_blocks=True, time_disp=\"ms\", grad_disp=\"kHz/m\")\n",
+    "seqeyes.set(show_blocks=True, time_disp=\"ms\", grad_disp=\"Hz/m\")\n",
     "seq_gre.plot(time_range=(0, tr_gre), theme=\"dark\")\n",
     "seqeyes.reset()  # restore defaults"
    ]

{seqeyes_python-0.2.0 → seqeyes_python-0.2.2}/examples/demo.py

@@ -10,7 +10,7 @@ import numpy as np
 import pypulseq as pp
 
 # ── Enable SeqEyes (once per session) ─────────────────────────────────
-seqeyes.set(time_disp="ms", grad_disp="kHz/m")
+seqeyes.set(time_disp="ms", grad_disp="Hz/m")
 print(f"SeqEyes {seqeyes.__version__} — seq.plot() is now interactive!")
 
 

{seqeyes_python-0.2.0 → seqeyes_python-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "seqeyes-python"
-version = "0.2.0"
+version = "0.2.2"
 description = "Interactive Pulseq MRI sequence viewer for Jupyter — lightweight, beautiful, replaces seq.plot() in pypulseq."
 readme = "README.md"
 license = {text = "MIT"}

{seqeyes_python-0.2.0 → seqeyes_python-0.2.2}/src/seqeyes/__init__.py

@@ -29,4 +29,4 @@ from seqeyes._plot import set, reset
 from seqeyes._renderer import SeqEyesViewer
 
 __all__ = ["set", "reset", "SeqEyesViewer"]
-__version__ = "0.2.0"
+__version__ = "0.2.2"

{seqeyes_python-0.2.0 → seqeyes_python-0.2.2}/src/seqeyes/_plot.py

@@ -20,6 +20,9 @@ from typing import Any, Optional, Tuple, Union
 
 _defaults: dict[str, Any] = {}
 _original_plot = None
+_original_repr_html = None
+_had_original_repr_html = False
+_patched_repr_html = None
 _patched = False
 
 
@@ -53,7 +56,7 @@ def reset() -> None:
 
     Call ``seqeyes.set()`` again to re‑enable at any time.
     """
-    global _patched
+    global _patched, _patched_repr_html
     _defaults.clear()
     _patched = False
 
@@ -64,6 +67,12 @@ def reset() -> None:
 
     if _original_plot is not None:
         _Seq.plot = _original_plot  # type: ignore[attr-defined]
+    if _patched_repr_html is not None and getattr(_Seq, "_repr_html_", None) is _patched_repr_html:
+        if _had_original_repr_html:
+            _Seq._repr_html_ = _original_repr_html  # type: ignore[attr-defined]
+        else:
+            delattr(_Seq, "_repr_html_")
+    _patched_repr_html = None
 
 
 # ── Internal helpers ──────────────────────────────────────────────────────
@@ -87,7 +96,7 @@ def _store_defaults(
 
 
 def _ensure_patched() -> None:
-    global _patched, _original_plot
+    global _patched, _original_plot, _original_repr_html, _had_original_repr_html, _patched_repr_html
 
     if _patched:
         return
@@ -100,6 +109,9 @@ def _ensure_patched() -> None:
 
     if _original_plot is None:
         _original_plot = getattr(_Seq, "plot", None)
+    if _patched_repr_html is None:
+        _had_original_repr_html = hasattr(_Seq, "_repr_html_")
+        _original_repr_html = getattr(_Seq, "_repr_html_", None)
 
     # ── Replacement .plot() ──────────────────────────────────────────
     def _seqeyes_plot(
@@ -108,7 +120,7 @@ def _ensure_patched() -> None:
         show_blocks: bool = False,
         time_range: Any = (0, float("inf")),
         time_disp: str = "s",
-        grad_disp: str = "kHz/m",
+        grad_disp: str = "Hz/m",
         **kwargs: Any,
     ) -> None:
         # Merge globals — per‑call args take precedence
@@ -147,6 +159,7 @@ def _ensure_patched() -> None:
         return SeqEyesViewer(_seq_to_text(self))._repr_html_()
 
     _Seq._repr_html_ = _seq_repr_html_  # type: ignore[attr-defined]
+    _patched_repr_html = _seq_repr_html_
 
 
 def _in_jupyter() -> bool:

{seqeyes_python-0.2.0 → seqeyes_python-0.2.2}/src/seqeyes/_renderer.py

@@ -26,6 +26,7 @@ _BUNDLE_CANDIDATES = [
     Path(__file__).resolve().parent.parent.parent.parent / "web" / "pulseq-bundle.js",
     Path.cwd() / "web" / "pulseq-bundle.js",
 ]
+_VALID_GRAD_UNITS = {"Hz/m", "mT/m", "G/cm"}
 
 
 def _find_bundle() -> str:
@@ -53,6 +54,11 @@ def _read_viewer_template() -> str:
     )
 
 
+def _normalize_grad_disp(unit: str) -> str:
+    """Return a viewer-supported gradient unit."""
+    return unit if unit in _VALID_GRAD_UNITS else "Hz/m"
+
+
 def _build_html(
     seq_text: str,
     *,
@@ -62,7 +68,7 @@ def _build_html(
     show_blocks: bool = False,
     time_range: tuple = (0, float("inf")),
     time_disp: str = "s",
-    grad_disp: str = "kHz/m",
+    grad_disp: str = "Hz/m",
 ) -> str:
     """Assemble the complete viewer HTML.
 
@@ -83,10 +89,10 @@ def _build_html(
     time_disp : str
         Initial time display unit (``"s"``, ``"ms"``, ``"us"``).
     grad_disp : str
-        Initial gradient display unit (``"Hz/m"``, ``"kHz/m"``,
-        ``"mT/m"``, ``"G/cm"``).
+        Initial gradient display unit (``"Hz/m"``, ``"mT/m"``, ``"G/cm"``).
     """
     template = _read_viewer_template()
+    grad_disp = _normalize_grad_disp(grad_disp)
     seq_b64 = base64.b64encode(seq_text.encode("utf-8")).decode("ascii")
 
     # 1. Inject the pulseq-bundle.js
@@ -150,7 +156,7 @@ class SeqEyesViewer:
     time_disp : str
         Time axis unit — ``"s"``, ``"ms"``, or ``"us"``.
     grad_disp : str
-        Gradient axis unit — ``"Hz/m"``, ``"kHz/m"``, ``"mT/m"``, ``"G/cm"``.
+        Gradient axis unit — ``"Hz/m"``, ``"mT/m"``, or ``"G/cm"``.
     theme : str or None
         Colour theme.
     width : str
@@ -167,7 +173,7 @@ class SeqEyesViewer:
         show_blocks: bool = False,
         time_range: tuple = (0, float("inf")),
         time_disp: str = "s",
-        grad_disp: str = "kHz/m",
+        grad_disp: str = "Hz/m",
         theme: Optional[str] = None,
         width: str = "100%",
         height: str = "550px",
@@ -177,7 +183,7 @@ class SeqEyesViewer:
         self._show_blocks = show_blocks
         self._time_range = time_range
         self._time_disp = time_disp
-        self._grad_disp = grad_disp
+        self._grad_disp = _normalize_grad_disp(grad_disp)
         self._theme = theme
         self._width = width
         self._height = height

{seqeyes_python-0.2.0 → seqeyes_python-0.2.2}/src/seqeyes/resources/pulseq-bundle.js

@@ -4,6 +4,7 @@ var Pulseq = (() => {
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
   var __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
@@ -17,6 +18,7 @@ var Pulseq = (() => {
     return to;
   };
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
   // web/pulseq-browser.ts
   var pulseq_browser_exports = {};
@@ -36,7 +38,7 @@ var Pulseq = (() => {
   });
 
   // package.json
-  var version = "0.1.17";
+  var version = "0.2.2";
 
   // src/pulseq/decompressor.ts
   function decompressShape(compressed, numSamples) {
@@ -103,23 +105,27 @@ var Pulseq = (() => {
 
   // src/pulseq/reader.ts
   function parseSequenceText(text) {
-    const lines = text.split(/\r?\n/);
     const seq = createEmptySequence();
     const seenSections = /* @__PURE__ */ new Set();
+    const shapeParser = new ShapeSectionParser(seq);
     let sectionName = null;
     let sectionLines = [];
-    for (const line of lines) {
+    forEachLine(text, (line) => {
       const m = line.match(/^\[(\w+)\]$/);
       if (m) {
-        if (sectionName) dispatchSection(seq, sectionName, sectionLines);
+        if (sectionName === "SHAPES") shapeParser.finish();
+        else if (sectionName) dispatchSection(seq, sectionName, sectionLines);
         sectionName = m[1];
         seenSections.add(sectionName);
         sectionLines = [];
+      } else if (sectionName === "SHAPES") {
+        shapeParser.consume(line);
       } else {
         sectionLines.push(line);
       }
-    }
-    if (sectionName) dispatchSection(seq, sectionName, sectionLines);
+    });
+    if (sectionName === "SHAPES") shapeParser.finish();
+    else if (sectionName) dispatchSection(seq, sectionName, sectionLines);
     seq.versionCombined = makeVersionCombined(
       seq.version.major,
       seq.version.minor,
@@ -129,7 +135,22 @@ var Pulseq = (() => {
     validateSequence(seq, seenSections);
     return seq;
   }
+  function forEachLine(text, visit) {
+    let start = 0;
+    while (start <= text.length) {
+      let end = text.indexOf("\n", start);
+      if (end < 0) end = text.length;
+      const contentEnd = end > start && text.charCodeAt(end - 1) === 13 ? end - 1 : end;
+      visit(text.slice(start, contentEnd));
+      if (end === text.length) break;
+      start = end + 1;
+    }
+  }
   function dispatchSection(seq, name, lines) {
+    if (name === "SHAPES") {
+      parseShapes(seq, lines);
+      return;
+    }
     const valid = lines.filter((l) => {
       const t = l.trim();
       return t && !t.startsWith("#");
@@ -159,9 +180,6 @@ var Pulseq = (() => {
       case "EXTENSIONS":
         parseExtensions(seq, valid);
         break;
-      case "SHAPES":
-        parseShapes(seq, lines);
-        break;
     }
   }
   function createEmptySequence() {
@@ -656,58 +674,71 @@ var Pulseq = (() => {
     }
   }
   function parseShapes(seq, lines) {
-    let i = 0;
-    while (i < lines.length) {
-      const t = lines[i].trim();
-      if (!t || t.startsWith("#") || t.startsWith("[")) {
-        i++;
-        continue;
+    const parser = new ShapeSectionParser(seq);
+    for (const line of lines) parser.consume(line);
+    parser.finish();
+  }
+  var ShapeSectionParser = class {
+    constructor(seq) {
+      __publicField(this, "seq", seq);
+      __publicField(this, "shapeId", 0);
+      __publicField(this, "numSamples", 0);
+      __publicField(this, "raw", new Float64Array());
+      __publicField(this, "rawCount", 0);
+    }
+    consume(line) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) return;
+      const shapeMatch = /^shape_id\s+(\d+)/.exec(trimmed);
+      if (shapeMatch) {
+        this.storeCurrent();
+        this.shapeId = Number(shapeMatch[1]);
+        return;
       }
-      const m = t.match(/^shape_id\s+(\d+)/);
-      if (!m) {
-        i++;
-        continue;
+      const countMatch = /^num_samples\s+(\d+)/.exec(trimmed);
+      if (countMatch) {
+        this.numSamples = Number(countMatch[1]);
+        this.raw = new Float64Array(Math.min(this.numSamples, 1024));
+        this.rawCount = 0;
+        return;
       }
-      const shapeId = +m[1];
-      i++;
-      let numSamples = 0;
-      while (i < lines.length) {
-        const l = lines[i].trim();
-        if (!l || l.startsWith("#")) {
-          i++;
-          continue;
-        }
-        const nm = l.match(/^num_samples\s+(\d+)/);
-        if (nm) {
-          numSamples = +nm[1];
-          i++;
-          break;
-        }
-        if (l.match(/^shape_id\s+\d+/) || l.startsWith("[")) break;
-        i++;
+      if (this.shapeId <= 0 || this.numSamples <= 0 || this.rawCount >= this.numSamples) return;
+      if (!/\s/.test(trimmed)) {
+        this.appendRawValue(trimmed);
+        return;
       }
-      if (numSamples <= 0) continue;
-      const vals = [];
-      while (i < lines.length && vals.length < numSamples) {
-        const l = lines[i].trim();
-        if (l.match(/^shape_id\s+\d+/) || l.startsWith("[")) break;
-        if (!l || l.startsWith("#")) {
-          i++;
-          continue;
-        }
-        for (const n of l.split(/\s+/).map(Number).filter((x) => !isNaN(x))) {
-          if (vals.length < numSamples) vals.push(n);
-        }
-        i++;
+      for (const field of trimmed.split(/\s+/)) {
+        this.appendRawValue(field);
+        if (this.rawCount >= this.numSamples) break;
       }
-      if (vals.length === 0) continue;
-      storeShape(seq, shapeId, numSamples, vals);
     }
-  }
-  function storeShape(seq, id, num, raw) {
-    const decompressed = raw.length === num ? new Float64Array(raw) : decompressShape(raw, num);
-    seq.shapes.set(id, { numSamples: num, samples: decompressed });
-  }
+    finish() {
+      this.storeCurrent();
+    }
+    ensureRawCapacity() {
+      if (this.rawCount < this.raw.length) return;
+      const nextLength = Math.min(this.numSamples, Math.max(1, this.raw.length * 2));
+      const expanded = new Float64Array(nextLength);
+      expanded.set(this.raw);
+      this.raw = expanded;
+    }
+    appendRawValue(field) {
+      const value = Number(field);
+      if (!Number.isFinite(value)) return;
+      this.ensureRawCapacity();
+      this.raw[this.rawCount++] = value;
+    }
+    storeCurrent() {
+      if (this.shapeId > 0 && this.numSamples > 0 && this.rawCount > 0) {
+        const samples = this.rawCount === this.numSamples ? this.raw : decompressShape(this.raw.subarray(0, this.rawCount), this.numSamples);
+        this.seq.shapes.set(this.shapeId, { numSamples: this.numSamples, samples });
+      }
+      this.shapeId = 0;
+      this.numSamples = 0;
+      this.raw = new Float64Array();
+      this.rawCount = 0;
+    }
+  };
   function extractRasterTimes(seq) {
     const set = (key, field) => {
       const v = seq.definitions.get(key);
@@ -1499,40 +1530,26 @@ var Pulseq = (() => {
     return mode === "observationTime" ? "observationTime" : "rfCenter";
   }
   function collectGradientSeries(blocks, channel) {
-    const time = [];
-    const value = [];
+    const series = { time: [], value: [] };
     for (const block of blocks) {
       const grad = block[channel];
       if (!grad?.timePoints || !grad.waveform) continue;
       const n = Math.min(grad.timePoints.length, grad.waveform.length);
       for (let i = 0; i < n; i++) {
-        time.push(grad.timePoints[i]);
-        value.push(grad.waveform[i]);
+        appendGradientPoint(series, grad.timePoints[i], grad.waveform[i]);
       }
     }
-    return sanitizeGradientSeries(time, value);
+    return series;
   }
-  function sanitizeGradientSeries(time, value) {
-    const pairs = [];
-    const n = Math.min(time.length, value.length);
-    for (let i = 0; i < n; i++) {
-      const t = time[i];
-      const v = value[i];
-      if (Number.isFinite(t) && Number.isFinite(v)) pairs.push([t, v]);
-    }
-    pairs.sort((a, b) => a[0] - b[0]);
-    const outT = [];
-    const outV = [];
-    for (const [t, v] of pairs) {
-      const last = outT.length - 1;
-      if (last >= 0 && Math.abs(t - outT[last]) <= TIME_EPS) {
-        outV[last] = 0.5 * (outV[last] + v);
-        continue;
-      }
-      outT.push(t);
-      outV.push(v);
+  function appendGradientPoint(series, t, value) {
+    if (!Number.isFinite(t) || !Number.isFinite(value)) return;
+    const last = series.time.length - 1;
+    if (last >= 0 && Math.abs(t - series.time[last]) <= TIME_EPS) {
+      series.value[last] = 0.5 * (series.value[last] + value);
+    } else if (last < 0 || t > series.time[last]) {
+      series.time.push(t);
+      series.value.push(value);
     }
-    return { time: outT, value: outV };
   }
   function collectRfEvents(blocks, warnings) {
     const events = [];
@@ -1589,6 +1606,26 @@ var Pulseq = (() => {
     let currentT = tReset;
     let unsignedM0 = 0;
     let unsignedM1 = 0;
+    let gradientIndex = -1;
+    const seekGradient = (t) => {
+      while (gradientIndex + 1 < gradient.time.length && gradient.time[gradientIndex + 1] <= t + TIME_EPS) {
+        gradientIndex++;
+      }
+    };
+    const sampleGradient = (t) => {
+      const n = gradient.time.length;
+      if (n === 0 || t < gradient.time[0] - TIME_EPS || t > gradient.time[n - 1] + TIME_EPS) return 0;
+      seekGradient(t);
+      if (gradientIndex < 0) return 0;
+      if (gradientIndex >= n - 1 || Math.abs(t - gradient.time[gradientIndex]) <= TIME_EPS) {
+        return gradient.value[gradientIndex];
+      }
+      const t0 = gradient.time[gradientIndex];
+      const t1 = gradient.time[gradientIndex + 1];
+      if (!(t1 > t0)) return gradient.value[gradientIndex];
+      const alpha = (t - t0) / (t1 - t0);
+      return gradient.value[gradientIndex] + alpha * (gradient.value[gradientIndex + 1] - gradient.value[gradientIndex]);
+    };
     const reportedM1At = (t) => {
       if (referenceMode === "observationTime") return sign * (unsignedM1 - (t - tReset) * unsignedM0);
       return sign * unsignedM1;
@@ -1596,10 +1633,11 @@ var Pulseq = (() => {
     const advanceTo = (targetT) => {
       if (!(targetT > currentT + TIME_EPS)) return;
       while (currentT < targetT - TIME_EPS) {
-        let nextT = nextGradientBreakpoint(gradient.time, currentT, targetT);
+        seekGradient(currentT);
+        let nextT = gradientIndex + 1 < gradient.time.length ? Math.min(targetT, gradient.time[gradientIndex + 1]) : targetT;
         if (!(nextT > currentT)) nextT = targetT;
-        const ga = sampleGradientAt(gradient, currentT);
-        const gb = sampleGradientAt(gradient, nextT);
+        const ga = sampleGradient(currentT);
+        const gb = sampleGradient(nextT);
         const [m0Seg, m1Seg] = integrateLinearSegment(currentT, nextT, tReset, ga, gb);
         unsignedM0 += m0Seg;
         unsignedM1 += m1Seg;
@@ -1641,36 +1679,6 @@ var Pulseq = (() => {
     }
     return { t: outT, m1: outM1 };
   }
-  function sampleGradientAt(gradient, t) {
-    const n = gradient.time.length;
-    if (n <= 0 || t < gradient.time[0] || t > gradient.time[n - 1]) return 0;
-    if (n === 1 || t <= gradient.time[0]) return gradient.value[0];
-    if (t >= gradient.time[n - 1]) return gradient.value[n - 1];
-    let lo = 0;
-    let hi = n - 1;
-    while (hi - lo > 1) {
-      const mid = lo + hi >> 1;
-      if (gradient.time[mid] <= t) lo = mid;
-      else hi = mid;
-    }
-    const t0 = gradient.time[lo];
-    const t1 = gradient.time[hi];
-    if (!(t1 > t0)) return gradient.value[lo];
-    const alpha = (t - t0) / (t1 - t0);
-    return gradient.value[lo] + alpha * (gradient.value[hi] - gradient.value[lo]);
-  }
-  function nextGradientBreakpoint(times, t, target) {
-    if (times.length <= 1 || t >= times[times.length - 1]) return target;
-    let lo = 0;
-    let hi = times.length;
-    const threshold = t + TIME_EPS;
-    while (lo < hi) {
-      const mid = lo + hi >> 1;
-      if (times[mid] <= threshold) lo = mid + 1;
-      else hi = mid;
-    }
-    return lo < times.length ? Math.min(target, times[lo]) : target;
-  }
   function integrateLinearSegment(a, b, tRef, ga, gb) {
     const h = b - a;
     if (!(h > 0)) return [0, 0];
@@ -1757,17 +1765,6 @@ var Pulseq = (() => {
     if (ntMax < ntMin) return invalidPns("Unable to build regular PNS raster.");
     const nSamples = Math.floor(ntMax - ntMin + 1);
     if (nSamples < 2) return invalidPns("Too few samples for PNS computation.");
-    const tAxis = new Float64Array(nSamples);
-    const gxTpm = new Float64Array(nSamples);
-    const gyTpm = new Float64Array(nSamples);
-    const gzTpm = new Float64Array(nSamples);
-    for (let i = 0; i < nSamples; i++) {
-      const tSec = (ntMin + i) * dtSec;
-      tAxis[i] = tSec;
-      gxTpm[i] = interpLinearZero(waves[0], tSec) / gammaHzPerT;
-      gyTpm[i] = interpLinearZero(waves[1], tSec) / gammaHzPerT;
-      gzTpm[i] = interpLinearZero(waves[2], tSec) / gammaHzPerT;
-    }
     const longestTauMs = Math.max(
       hardware.x.tau1Ms,
       hardware.x.tau2Ms,
@@ -1782,68 +1779,78 @@ var Pulseq = (() => {
     const zptSec = longestTauMs * 4 / 1e3;
     const preCount = Math.max(0, Math.round(zptSec / (4 * dtSec)));
     const postCount = Math.max(0, Math.round(zptSec / dtSec));
-    const gxPadded = padSamples(gxTpm, preCount, postCount);
-    const gyPadded = padSamples(gyTpm, preCount, postCount);
-    const gzPadded = padSamples(gzTpm, preCount, postCount);
-    const stimX = safePnsModel(diff(gxPadded, dtSec), dtSec, hardware.x);
-    const stimY = safePnsModel(diff(gyPadded, dtSec), dtSec, hardware.y);
-    const stimZ = safePnsModel(diff(gzPadded, dtSec), dtSec, hardware.z);
+    const stimX = calculatePnsAxis(waves[0], ntMin, nSamples, preCount, postCount, dtSec, gammaHzPerT, hardware.x);
+    const stimY = calculatePnsAxis(waves[1], ntMin, nSamples, preCount, postCount, dtSec, gammaHzPerT, hardware.y);
+    const stimZ = calculatePnsAxis(waves[2], ntMin, nSamples, preCount, postCount, dtSec, gammaHzPerT, hardware.z);
     const hasAnyNonTrap = blocks.some((block) => block.gx?.type === "arb" || block.gy?.type === "arb" || block.gz?.type === "arb");
     const hasAnyLabelExt = blocks.some((block) => !!(block.labelSets?.length || block.labelIncs?.length));
     const shift = hasAnyNonTrap || hasAnyLabelExt ? 1 : 0;
-    const selectedX = [];
-    const selectedY = [];
-    const selectedZ = [];
-    const selectedT = [];
+    let selectedCount = 0;
     for (let origIdx = 0; origIdx < nSamples; origIdx++) {
       const paddedIdx = preCount + origIdx;
       let stimIdx = paddedIdx - shift;
-      if (shift > 0 && hasAnyLabelExt && origIdx === tAxis.length - 1) {
+      if (shift > 0 && hasAnyLabelExt && origIdx === nSamples - 1) {
         stimIdx = Math.min(paddedIdx, stimX.length - 1);
       }
       if (stimIdx < 0 || stimIdx >= stimX.length || stimIdx >= stimY.length || stimIdx >= stimZ.length) continue;
-      selectedX.push(stimX[stimIdx]);
-      selectedY.push(stimY[stimIdx]);
-      selectedZ.push(stimZ[stimIdx]);
-      selectedT.push(tAxis[origIdx]);
-    }
-    const timeSec = new Float64Array(selectedX.length);
-    const pnsX = new Float64Array(selectedX.length);
-    const pnsY = new Float64Array(selectedX.length);
-    const pnsZ = new Float64Array(selectedX.length);
-    const pnsNorm = new Float64Array(selectedX.length);
+      selectedCount++;
+    }
+    const timeSec = new Float64Array(selectedCount);
+    const pnsX = new Float64Array(selectedCount);
+    const pnsY = new Float64Array(selectedCount);
+    const pnsZ = new Float64Array(selectedCount);
+    const pnsNorm = new Float64Array(selectedCount);
     let ok = true;
-    for (let i = 0; i < selectedX.length; i++) {
-      const xNorm = 0.01 * selectedX[i];
-      const yNorm = 0.01 * selectedY[i];
-      const zNorm = 0.01 * selectedZ[i];
+    let selectedIndex = 0;
+    for (let origIdx = 0; origIdx < nSamples; origIdx++) {
+      const paddedIdx = preCount + origIdx;
+      let stimIdx = paddedIdx - shift;
+      if (shift > 0 && hasAnyLabelExt && origIdx === nSamples - 1) {
+        stimIdx = Math.min(paddedIdx, stimX.length - 1);
+      }
+      if (stimIdx < 0 || stimIdx >= stimX.length || stimIdx >= stimY.length || stimIdx >= stimZ.length) continue;
+      const xNorm = 0.01 * stimX[stimIdx];
+      const yNorm = 0.01 * stimY[stimIdx];
+      const zNorm = 0.01 * stimZ[stimIdx];
       const norm = Math.sqrt(xNorm * xNorm + yNorm * yNorm + zNorm * zNorm);
-      timeSec[i] = selectedT[i];
-      pnsX[i] = xNorm;
-      pnsY[i] = yNorm;
-      pnsZ[i] = zNorm;
-      pnsNorm[i] = norm;
+      timeSec[selectedIndex] = (ntMin + origIdx) * dtSec;
+      pnsX[selectedIndex] = xNorm;
+      pnsY[selectedIndex] = yNorm;
+      pnsZ[selectedIndex] = zNorm;
+      pnsNorm[selectedIndex] = norm;
       if (norm >= 1) ok = false;
+      selectedIndex++;
     }
     return { valid: true, ok, timeSec, pnsX, pnsY, pnsZ, pnsNorm };
   }
   function safePnsModel(dgdt, dtSec, hw) {
-    const absDgdt = new Float64Array(dgdt.length);
-    for (let i = 0; i < dgdt.length; i++) absDgdt[i] = Math.abs(dgdt[i]);
+    return runPnsModel(dgdt.length, (index) => dgdt[index], dtSec, hw);
+  }
+  function runPnsModel(length, derivativeAt, dtSec, hw) {
     const dtMs = dtSec * 1e3;
-    const lp1 = lowpassTau(dgdt, hw.tau1Ms, dtMs);
-    const lp2 = lowpassTau(absDgdt, hw.tau2Ms, dtMs);
-    const lp3 = lowpassTau(dgdt, hw.tau3Ms, dtMs);
-    const stim = new Float64Array(dgdt.length);
+    const alpha1 = lowpassAlpha(hw.tau1Ms, dtMs);
+    const alpha2 = lowpassAlpha(hw.tau2Ms, dtMs);
+    const alpha3 = lowpassAlpha(hw.tau3Ms, dtMs);
+    const stim = new Float64Array(length);
     const denom = hw.stimLimit > 0 ? hw.stimLimit : 1;
-    for (let i = 0; i < dgdt.length; i++) {
-      const s1 = hw.a1 * Math.abs(lp1[i]);
-      const s2 = hw.a2 * lp2[i];
-      const s3 = hw.a3 * Math.abs(lp3[i]);
+    let lp1 = 0;
+    let lp2 = 0;
+    let lp3 = 0;
+    for (let i = 0; i < length; i++) {
+      const derivative = derivativeAt(i);
+      lp1 = alpha1 * derivative + (1 - alpha1) * lp1;
+      lp2 = alpha2 * Math.abs(derivative) + (1 - alpha2) * lp2;
+      lp3 = alpha3 * derivative + (1 - alpha3) * lp3;
+      const s1 = hw.a1 * Math.abs(lp1);
+      const s2 = hw.a2 * lp2;
+      const s3 = hw.a3 * Math.abs(lp3);
       stim[i] = (s1 + s2 + s3) / denom * hw.gScale * 100;
     }
     return stim;
   }
+  function lowpassAlpha(tauMs, dtMs) {
+    return tauMs <= 0 || dtMs <= 0 ? 1 : dtMs / (tauMs + dtMs);
+  }
   function invalidPns(error) {
     return {
       valid: false,
@@ -1939,79 +1946,58 @@ var Pulseq = (() => {
   function hasValidWeights(hw) {
     return Math.abs(hw.a1 + hw.a2 + hw.a3 - 1) <= 0.01 && hw.stimLimit > 0;
   }
-  function lowpassTau(input, tauMs, dtMs) {
-    const out = new Float64Array(input.length);
-    if (!input.length) return out;
-    if (tauMs <= 0 || dtMs <= 0) {
-      out.set(input);
-      return out;
-    }
-    const alpha = dtMs / (tauMs + dtMs);
-    out[0] = alpha * input[0];
-    for (let i = 1; i < input.length; i++) out[i] = alpha * input[i] + (1 - alpha) * out[i - 1];
-    return out;
-  }
   function collectGradientSeries2(blocks, channel) {
-    const time = [];
-    const value = [];
+    const series = { time: [], value: [] };
     for (const block of blocks) {
       const grad = block[channel];
       if (!grad?.timePoints || !grad.waveform) continue;
       const n = Math.min(grad.timePoints.length, grad.waveform.length);
       for (let i = 0; i < n; i++) {
-        time.push(grad.timePoints[i]);
-        value.push(grad.waveform[i]);
+        appendGradientPoint2(series, grad.timePoints[i], grad.waveform[i]);
       }
     }
-    return sanitizeGradientSeries2(time, value);
-  }
-  function sanitizeGradientSeries2(time, value) {
-    const pairs = [];
-    const n = Math.min(time.length, value.length);
-    for (let i = 0; i < n; i++) {
-      if (Number.isFinite(time[i]) && Number.isFinite(value[i])) pairs.push([time[i], value[i]]);
-    }
-    pairs.sort((a, b) => a[0] - b[0]);
-    const outT = [];
-    const outV = [];
-    for (const [t, v] of pairs) {
-      const last = outT.length - 1;
-      if (last >= 0 && Math.abs(t - outT[last]) <= TIME_EPS2) {
-        outV[last] = 0.5 * (outV[last] + v);
-        continue;
-      }
-      outT.push(t);
-      outV.push(v);
-    }
-    return { time: outT, value: outV };
-  }
-  function interpLinearZero(series, t) {
-    const n = series.time.length;
-    if (!n || t < series.time[0] || t > series.time[n - 1]) return 0;
-    if (n === 1 || t <= series.time[0]) return series.value[0];
-    if (t >= series.time[n - 1]) return series.value[n - 1];
-    let lo = 0;
-    let hi = n - 1;
-    while (hi - lo > 1) {
-      const mid = lo + hi >> 1;
-      if (series.time[mid] <= t) lo = mid;
-      else hi = mid;
-    }
-    const t0 = series.time[lo];
-    const t1 = series.time[hi];
-    if (!(t1 > t0)) return series.value[lo];
-    const alpha = (t - t0) / (t1 - t0);
-    return series.value[lo] + alpha * (series.value[hi] - series.value[lo]);
-  }
-  function padSamples(input, preCount, postCount) {
-    const out = new Float64Array(preCount + input.length + postCount);
-    out.set(input, preCount);
-    return out;
-  }
-  function diff(input, dtSec) {
-    const out = new Float64Array(Math.max(0, input.length - 1));
-    for (let i = 0; i < out.length; i++) out[i] = (input[i + 1] - input[i]) / dtSec;
-    return out;
+    return series;
+  }
+  function appendGradientPoint2(series, t, value) {
+    if (!Number.isFinite(t) || !Number.isFinite(value)) return;
+    const last = series.time.length - 1;
+    if (last >= 0 && Math.abs(t - series.time[last]) <= TIME_EPS2) {
+      series.value[last] = 0.5 * (series.value[last] + value);
+    } else if (last < 0 || t > series.time[last]) {
+      series.time.push(t);
+      series.value.push(value);
+    }
+  }
+  function calculatePnsAxis(series, ntMin, nSamples, preCount, postCount, dtSec, gammaHzPerT, hardware) {
+    const sampleGradient = createGradientSampler(series);
+    const totalSamples = preCount + nSamples + postCount;
+    const paddedValue = (index) => {
+      if (index < preCount || index >= preCount + nSamples) return 0;
+      const rasterIndex = index - preCount;
+      return sampleGradient((ntMin + rasterIndex) * dtSec) / gammaHzPerT;
+    };
+    let previous = paddedValue(0);
+    return runPnsModel(Math.max(0, totalSamples - 1), (index) => {
+      const current = paddedValue(index + 1);
+      const derivative = (current - previous) / dtSec;
+      previous = current;
+      return derivative;
+    }, dtSec, hardware);
+  }
+  function createGradientSampler(series) {
+    let index = -1;
+    return (t) => {
+      const n = series.time.length;
+      if (n === 0 || t < series.time[0] || t > series.time[n - 1]) return 0;
+      while (index + 1 < n && series.time[index + 1] <= t + TIME_EPS2) index++;
+      if (index < 0) return 0;
+      if (index >= n - 1 || t <= series.time[index] + TIME_EPS2) return series.value[index];
+      const t0 = series.time[index];
+      const t1 = series.time[index + 1];
+      if (!(t1 > t0)) return series.value[index];
+      const alpha = (t - t0) / (t1 - t0);
+      return series.value[index] + alpha * (series.value[index + 1] - series.value[index]);
+    };
   }
 
   // src/pulseq/trdetect.ts
@@ -2190,11 +2176,7 @@ var Pulseq = (() => {
     if (intervals.length === 0) return 0;
     intervals.sort((a, b) => a - b);
     const median = intervals[Math.floor(intervals.length / 2)];
-    const niceMs = niceRound(median * 1e3, 10);
-    return niceMs * 1e-3;
-  }
-  function niceRound(value, base) {
-    return Math.round(value / base) * base;
+    return Math.round(median * 1e6) / 1e6;
   }
 
   // src/pulseq/kspaceExportArtifacts.ts

{seqeyes_python-0.2.0 → seqeyes_python-0.2.2}/src/seqeyes/resources/viewer.html

@@ -163,6 +163,7 @@ function scheduleViewerDraw(includeMinimap){
 // ── Unit conversion ──
 function gradConv(v){if(gradUnit==='mT/m')return v/GAMMA;if(gradUnit==='G/cm')return v/(GAMMA*10);return v;}
 function gradUnitStr(){return gradUnit;}
+function normalizeGradUnit(unit){return(unit==='mT/m'||unit==='G/cm'||unit==='Hz/m')?unit:'Hz/m';}
 function timeConv(t){if(timeUnit==='ms')return t*1e3;if(timeUnit==='us')return t*1e6;return t;}
 function timeUnitStr(){return timeUnit;}
 
@@ -1519,7 +1520,7 @@ function loadSequenceText(rawText) {
       // ── Apply display options from Python host ──
       if (window.SEQEYES_SHOW_BLOCKS) { showBB = true; document.getElementById('bbc').checked = true; }
       if (window.SEQEYES_TIME_DISP) { timeUnit = window.SEQEYES_TIME_DISP; tuSel.value = timeUnit; }
-      if (window.SEQEYES_GRAD_DISP) { gradUnit = window.SEQEYES_GRAD_DISP; guSel.value = gradUnit; }
+      if (window.SEQEYES_GRAD_DISP) { gradUnit = normalizeGradUnit(window.SEQEYES_GRAD_DISP); guSel.value = gradUnit; }
       // Apply time_range if specified
       if (window.SEQEYES_TIME_RANGE && window.SEQEYES_TIME_RANGE.length === 2) {
         var tr0 = window.SEQEYES_TIME_RANGE[0], tr1 = window.SEQEYES_TIME_RANGE[1];

{seqeyes_python-0.2.0 → seqeyes_python-0.2.2}/tests/integration_test.py

@@ -57,7 +57,7 @@ try:
     import seqeyes
 
     # Test set()
-    seqeyes.set(theme="dracula", time_disp="ms", grad_disp="kHz/m")
+    seqeyes.set(theme="dracula", time_disp="ms", grad_disp="Hz/m")
     seqeyes.set(show_blocks=True)  # update a single key
     print("OK seqeyes.set() works")
 

{seqeyes_python-0.2.0 → seqeyes_python-0.2.2}/tests/test_plot.py

@@ -85,6 +85,17 @@ class TestSeqEyesViewer:
         assert '"ms"' in raw
         assert '"mT/m"' in raw
 
+    def test_viewer_default_gradient_unit_is_hz_per_m(self):
+        v = SeqEyesViewer(SAMPLE_SEQ_TEXT)
+        raw = v.to_html(inject_bundle=False)
+        assert 'window.SEQEYES_GRAD_DISP = "Hz/m";' in raw
+
+    def test_viewer_normalizes_unsupported_gradient_unit(self):
+        v = SeqEyesViewer(SAMPLE_SEQ_TEXT, grad_disp="kHz/m")
+        raw = v.to_html(inject_bundle=False)
+        assert 'window.SEQEYES_GRAD_DISP = "Hz/m";' in raw
+        assert "kHz/m" not in raw
+
 
 class TestSetAndReset:
     """Tests for set() and reset()."""
@@ -132,6 +143,26 @@ class TestSetAndReset:
         except ImportError:
             pytest.skip("pypulseq not installed")
 
+    def test_reset_removes_seqeyes_repr_html(self):
+        """reset() should restore bare Sequence display, not only plot()."""
+        try:
+            import seqeyes
+            from pypulseq import Sequence
+
+            had_original = hasattr(Sequence, "_repr_html_")
+            original_repr = getattr(Sequence, "_repr_html_", None)
+
+            seqeyes.set()
+            assert hasattr(Sequence, "_repr_html_")
+
+            seqeyes.reset()
+            if had_original:
+                assert getattr(Sequence, "_repr_html_", None) is original_repr
+            else:
+                assert not hasattr(Sequence, "_repr_html_")
+        except ImportError:
+            pytest.skip("pypulseq not installed")
+
     def test_set_defaults_merge(self):
         """Global defaults should merge with per-call args."""
         try: