seqeyes-python 0.2.8__tar.gz → 0.2.10__tar.gz

{seqeyes_python-0.2.8 → seqeyes_python-0.2.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seqeyes-python
-Version: 0.2.8
+Version: 0.2.10
 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.8 → seqeyes_python-0.2.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "seqeyes-python"
-version = "0.2.8"
+version = "0.2.10"
 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.8 → seqeyes_python-0.2.10}/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.8"
+__version__ = "0.2.9"

{seqeyes_python-0.2.8 → seqeyes_python-0.2.10}/src/seqeyes/resources/pulseq-bundle.js

@@ -53,7 +53,7 @@ var Pulseq = (() => {
   });
 
   // package.json
-  var version = "0.2.8";
+  var version = "0.2.9";
 
   // src/pulseq/decompressor.ts
   function decompressShape(compressed, numSamples) {
@@ -1782,11 +1782,16 @@ var Pulseq = (() => {
   }
 
   // src/pulseq/kspace.ts
+  var TRAJECTORY_TIME_ACCURACY_SEC = 1e-10;
+  var GRADIENT_ENDPOINT_TOLERANCE_SEC = 1e-12;
+  function canonicalTrajectoryTime(timeSec) {
+    return TRAJECTORY_TIME_ACCURACY_SEC * Math.round(timeSec / TRAJECTORY_TIME_ACCURACY_SEC);
+  }
   function calculateKspace(blocks, gradientRaster, totalDuration, trajectoryDelay = 0, _options) {
     if (!blocks.length || !gradientRaster || gradientRaster <= 0) return null;
     const GR = gradientRaster;
     const RF = _options?.rfRaster && _options.rfRaster > 0 ? _options.rfRaster : 1e-6;
-    const tacc = 1e-10;
+    const tacc = TRAJECTORY_TIME_ACCURACY_SEC;
     const gradientSupport = _options?.gradientSupport ?? "endpoints";
     const excT = [], refT = [];
     const gradTimes = [];
@@ -1854,7 +1859,7 @@ var Pulseq = (() => {
     let cum = 0;
     for (const b of blocks) {
       cum += b.duration;
-      edges.push(cum);
+      edges.push(canonicalTrajectoryTime(cum));
     }
     for (let i = 0; i < N; i++) {
       const t = grid[i];
@@ -1955,7 +1960,10 @@ var Pulseq = (() => {
     if (!g || g.type === "none") return 0;
     const tp = g.timePoints, wf = g.waveform;
     if (!tp || tp.length < 2) return 0;
-    if (t < tp[0] || t > tp[tp.length - 1]) return 0;
+    const first = tp[0], last = tp[tp.length - 1];
+    if (t < first - GRADIENT_ENDPOINT_TOLERANCE_SEC || t > last + GRADIENT_ENDPOINT_TOLERANCE_SEC) return 0;
+    if (t <= first + GRADIENT_ENDPOINT_TOLERANCE_SEC) return wf[0];
+    if (t >= last - GRADIENT_ENDPOINT_TOLERANCE_SEC) return wf[wf.length - 1];
     let lo = 0, hi = tp.length - 1;
     while (hi - lo > 1) {
       const m = lo + hi >> 1;
@@ -2044,11 +2052,34 @@ var Pulseq = (() => {
     }
     add(tSec, value) {
       if (!Number.isFinite(tSec) || !Number.isFinite(value)) return;
+      this.addToBucket(this.bucketIndex(tSec), tSec, value);
+    }
+    /** Fill a known constant interval without visiting every source-raster sample. */
+    addConstantRange(startSec, endSec, value) {
+      if (!Number.isFinite(startSec) || !Number.isFinite(endSec) || !Number.isFinite(value)) return;
+      const start = Math.max(this.startSec, Math.min(startSec, endSec));
+      const end = Math.min(this.endSec, Math.max(startSec, endSec));
+      if (end < start) return;
+      const firstIndex = this.bucketIndex(start);
+      const lastIndex = this.bucketIndex(end);
+      for (let index = firstIndex; index <= lastIndex; index++) {
+        const bucketStart = this.span > 0 ? this.startSec + this.span * index / this.bucketCount : start;
+        const bucketEnd = this.span > 0 ? this.startSec + this.span * (index + 1) / this.bucketCount : end;
+        const left = Math.max(start, bucketStart);
+        const right = Math.min(end, bucketEnd);
+        if (right < left) continue;
+        this.addToBucket(index, left, value);
+        this.addToBucket(index, right, value);
+      }
+    }
+    bucketIndex(tSec) {
       const normalized = this.span > 0 ? (tSec - this.startSec) / this.span : 0;
-      const index = Math.max(0, Math.min(
+      return Math.max(0, Math.min(
         this.bucketCount - 1,
         Math.floor(normalized * this.bucketCount)
       ));
+    }
+    addToBucket(index, tSec, value) {
       const bucket = this.buckets[index];
       if (!bucket) {
         this.buckets[index] = {
@@ -2198,19 +2229,45 @@ var Pulseq = (() => {
     if (x.t.length !== y.t.length || x.t.length !== z.t.length) {
       warnings.push(`Internal warning: per-axis M1 output sizes disagree (${x.t.length}, ${y.t.length}, ${z.t.length}). Plot may be inconsistent.`);
     }
+    const output = referenceMode === "rfCenter" ? compactRfCenteredSamples(x.t, x.m1, y.m1, z.m1) : { t: x.t, x: x.m1, y: y.m1, z: z.m1 };
     return {
       valid: true,
       ok: true,
       referenceMode,
-      tSec: new Float64Array(x.t),
-      m1x: new Float64Array(x.m1),
-      m1y: new Float64Array(y.m1),
-      m1z: new Float64Array(z.m1),
+      tSec: new Float64Array(output.t),
+      m1x: new Float64Array(output.x),
+      m1y: new Float64Array(output.y),
+      m1z: new Float64Array(output.z),
       warnings,
       excitationTimesSec: new Float64Array(excitationTimes),
       refocusingTimesSec: new Float64Array(refocusingTimes)
     };
   }
+  function compactRfCenteredSamples(time, x, y, z) {
+    const count = Math.min(time.length, x.length, y.length, z.length);
+    if (count <= 2) return {
+      t: time.slice(0, count),
+      x: x.slice(0, count),
+      y: y.slice(0, count),
+      z: z.slice(0, count)
+    };
+    const out = { t: [time[0]], x: [x[0]], y: [y[0]], z: [z[0]] };
+    const sameVector = (left, right) => x[left] === x[right] && y[left] === y[right] && z[left] === z[right];
+    for (let index = 1; index < count - 1; index++) {
+      const duplicateTime = time[index] <= time[index - 1] + TIME_EPS2 || time[index + 1] <= time[index] + TIME_EPS2;
+      const insidePlateau = sameVector(index - 1, index) && sameVector(index, index + 1);
+      if (!duplicateTime && insidePlateau) continue;
+      out.t.push(time[index]);
+      out.x.push(x[index]);
+      out.y.push(y[index]);
+      out.z.push(z[index]);
+    }
+    out.t.push(time[count - 1]);
+    out.x.push(x[count - 1]);
+    out.y.push(y[count - 1]);
+    out.z.push(z[count - 1]);
+    return out;
+  }
   function appendM1AdvisoryWarnings(rfEvents, tMin, warnings) {
     let recentExcCount = 0;
     let lastExcT = -1e9;
@@ -2280,21 +2337,21 @@ var Pulseq = (() => {
       createDecodedGradientSampler(blocks, "gy"),
       createDecodedGradientSampler(blocks, "gz")
     ];
-    const unsignedM0 = [0, 0, 0];
-    const unsignedM1 = [0, 0, 0];
+    const effectiveM0 = [0, 0, 0];
+    const effectiveM1 = [0, 0, 0];
     let sign = 1;
     let tReset = excitationTimes.length ? excitationTimes[0] : range.first;
     if (range.first < tReset) tReset = range.first;
     let currentT = tReset;
-    const reported = (axis, tSec) => referenceMode === "observationTime" ? sign * (unsignedM1[axis] - (tSec - tReset) * unsignedM0[axis]) : sign * unsignedM1[axis];
+    const reported = (axis, tSec) => referenceMode === "observationTime" ? effectiveM1[axis] - (tSec - tReset) * effectiveM0[axis] : effectiveM1[axis];
     const advanceTo = (targetT) => {
       if (!(targetT > currentT + TIME_EPS2)) return;
       for (let axis = 0; axis < 3; axis++) {
         const ga = samplers[axis](currentT);
         const gb = samplers[axis](targetT);
         const integrated = integrateLinearSegment(currentT, targetT, tReset, ga, gb);
-        unsignedM0[axis] += integrated[0];
-        unsignedM1[axis] += integrated[1];
+        effectiveM0[axis] += sign * integrated[0];
+        effectiveM1[axis] += sign * integrated[1];
       }
       currentT = targetT;
     };
@@ -2305,19 +2362,45 @@ var Pulseq = (() => {
     const regularLast = range.first + Math.max(0, regularCount - 1) * gradientRaster;
     const hasFinalSample = regularLast < range.last - TIME_EPS2;
     const totalSamples = regularCount + (hasFinalSample ? 1 : 0);
+    const sampleTimeAt = (index) => index < regularCount ? range.first + index * gradientRaster : range.last;
+    const gradientFreeIntervals = referenceMode === "rfCenter" ? collectGradientFreeIntervals(blocks) : [];
+    let gradientFreeIndex = 0;
     let eventIndex = 0;
     let sampleIndex = 0;
     while (eventIndex < events.length || sampleIndex < totalSamples) {
       const eventTime = eventIndex < events.length ? events[eventIndex].tSec : Number.POSITIVE_INFINITY;
-      const sampleTime = sampleIndex < totalSamples ? sampleIndex < regularCount ? range.first + sampleIndex * gradientRaster : range.last : Number.POSITIVE_INFINITY;
+      const sampleTime = sampleIndex < totalSamples ? sampleTimeAt(sampleIndex) : Number.POSITIVE_INFINITY;
+      while (gradientFreeIndex < gradientFreeIntervals.length && gradientFreeIntervals[gradientFreeIndex].end <= currentT + TIME_EPS2) {
+        gradientFreeIndex++;
+      }
+      const gap = gradientFreeIntervals[gradientFreeIndex];
+      const ordinaryTarget = Math.min(eventTime, sampleTime);
+      if (gap && currentT < gap.start - TIME_EPS2 && gap.start < ordinaryTarget - TIME_EPS2) {
+        advanceTo(gap.start);
+        addReported(gap.start);
+        continue;
+      }
+      if (gap && currentT >= gap.start - TIME_EPS2 && currentT < gap.end - TIME_EPS2) {
+        const jumpTarget = Math.min(gap.end, eventTime, endSec);
+        if (jumpTarget > currentT + TIME_EPS2) {
+          for (let axis = 0; axis < 3; axis++) {
+            builders[axis].addConstantRange(currentT, jumpTarget, effectiveM1[axis]);
+          }
+          currentT = jumpTarget;
+          while (sampleIndex < totalSamples && sampleTimeAt(sampleIndex) <= currentT + TIME_EPS2) {
+            sampleIndex++;
+          }
+          continue;
+        }
+      }
       if (eventTime <= sampleTime) {
         advanceTo(eventTime);
         if (events[eventIndex].kind === "reset") {
           sign = 1;
           tReset = eventTime;
           currentT = eventTime;
-          unsignedM0.fill(0);
-          unsignedM1.fill(0);
+          effectiveM0.fill(0);
+          effectiveM1.fill(0);
           for (const builder of builders) builder.add(eventTime, 0);
         } else {
           addReported(eventTime);
@@ -2378,6 +2461,46 @@ var Pulseq = (() => {
     }
     return series;
   }
+  function collectGradientFreeIntervals(blocks) {
+    const gaps = [];
+    const appendGap = (start, end) => {
+      if (!(end > start + TIME_EPS2)) return;
+      const previous = gaps[gaps.length - 1];
+      if (previous && start <= previous.end + TIME_EPS2) {
+        previous.end = Math.max(previous.end, end);
+      } else {
+        gaps.push({ start, end });
+      }
+    };
+    for (const block of blocks) {
+      const blockStart = block.startTime;
+      const blockEnd = block.startTime + block.duration;
+      if (!(blockEnd > blockStart + TIME_EPS2)) continue;
+      const active = [];
+      for (const gradient of [block.gx, block.gy, block.gz]) {
+        if (!gradient?.timePoints.length || !gradient.waveform.length || gradient.type === "none") continue;
+        let nonzero = false;
+        for (const value of gradient.waveform) {
+          if (value !== 0) {
+            nonzero = true;
+            break;
+          }
+        }
+        if (!nonzero) continue;
+        const first = Math.max(blockStart, gradient.timePoints[0]);
+        const last = Math.min(blockEnd, gradient.timePoints[gradient.timePoints.length - 1]);
+        if (last > first + TIME_EPS2) active.push({ start: first, end: last });
+      }
+      active.sort((left, right) => left.start - right.start);
+      let cursor = blockStart;
+      for (const interval of active) {
+        if (interval.start > cursor + TIME_EPS2) appendGap(cursor, interval.start);
+        cursor = Math.max(cursor, interval.end);
+      }
+      if (cursor < blockEnd - TIME_EPS2) appendGap(cursor, blockEnd);
+    }
+    return gaps;
+  }
   function appendGradientPoint(series, t, value) {
     if (!Number.isFinite(t) || !Number.isFinite(value)) return;
     const last = series.time.length - 1;
@@ -2441,8 +2564,8 @@ var Pulseq = (() => {
     let tReset = excitationTimes.length ? excitationTimes[0] : tMin;
     if (samples.length && samples[0] < tReset) tReset = samples[0];
     let currentT = tReset;
-    let unsignedM0 = 0;
-    let unsignedM1 = 0;
+    let effectiveM0 = 0;
+    let effectiveM1 = 0;
     let gradientIndex = -1;
     const seekGradient = (t) => {
       while (gradientIndex + 1 < gradient.time.length && gradient.time[gradientIndex + 1] <= t + TIME_EPS2) {
@@ -2464,8 +2587,8 @@ var Pulseq = (() => {
       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;
+      if (referenceMode === "observationTime") return effectiveM1 - (t - tReset) * effectiveM0;
+      return effectiveM1;
     };
     const advanceTo = (targetT) => {
       if (!(targetT > currentT + TIME_EPS2)) return;
@@ -2476,8 +2599,8 @@ var Pulseq = (() => {
         const ga = sampleGradient(currentT);
         const gb = sampleGradient(nextT);
         const [m0Seg, m1Seg] = integrateLinearSegment(currentT, nextT, tReset, ga, gb);
-        unsignedM0 += m0Seg;
-        unsignedM1 += m1Seg;
+        effectiveM0 += sign * m0Seg;
+        effectiveM1 += sign * m1Seg;
         currentT = nextT;
       }
     };
@@ -2499,8 +2622,8 @@ var Pulseq = (() => {
           sign = 1;
           tReset = nextEvtT;
           currentT = nextEvtT;
-          unsignedM0 = 0;
-          unsignedM1 = 0;
+          effectiveM0 = 0;
+          effectiveM1 = 0;
         } else {
           outT.push(nextEvtT);
           outM1.push(reportedM1At(nextEvtT));