MindGrab-only WebGPU Space

.gitattributes

@@ -1,35 +1,2 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
 *.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.nii.gz filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+dist
+node_modules

LICENSE

@@ -0,0 +1,24 @@
+BSD 2-Clause License
+
+Copyright (c) 2025, Ahmed Harmouche
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -1,11 +1,56 @@
 ---
-title: Mindgrab
-emoji: 🏢
-colorFrom: pink
-colorTo: green
+title: MindGrab WebGPU
+emoji: 🧠
+colorFrom: purple
+colorTo: indigo
 sdk: static
+app_file: dist/index.html
+app_build_command: npm run build
+license: apache-2.0
 pinned: false
-license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+### Overview
+
+This Space bundles the MindGrab skull-stripping model (and its three TTA variants) exported from [brainchop](https://github.com/neuroneural/brainchop) via tinygrad. Everything runs in the browser with WebGPU; MRI data never leaves the client. The UI embeds [Niivue](https://github.com/niivue/niivue) for visualization and uses the same conform/normalization steps as the CLI.
+
+### Local Development
+
+```bash
+cd hf
+npm install          # once
+npm run dev          # hot reload, http://localhost:5173
+npm run build        # produces dist/
+npx serve dist       # static preview (or npm run preview)
+```
+
+### Deploying to Hugging Face Spaces
+
+Follow the latest [Spaces overview docs](https://huggingface.co/docs/hub/spaces-overview) / [Static HTML guide](https://huggingface.co/docs/hub/spaces-sdks-static):
+
+1. **Create or open the Space** – visit https://huggingface.co/spaces/neuroneural/mindgrab, choose SDK `static`, and ensure the README metadata matches the block above (it declares `app_file` + `app_build_command` so Hugging Face runs the same `npm run build` step you run locally).
+2. **Authenticate once** – `pip install -U huggingface_hub` if needed, then run `huggingface-cli login` with a write-enabled token.
+3. **Clone the Space repo (instead of initializing a fresh Git repo)**:
+   ```bash
+   git clone https://huggingface.co/spaces/neuroneural/mindgrab mindgrab-space
+   cd mindgrab-space
+   git lfs install  # .gitattributes already tracks .safetensors + .nii.gz
+   ```
+4. **Sync this project into the clone** (from the `brainchop-cli` root run something like):
+   ```bash
+   rsync -av --delete hf/ /path/to/mindgrab-space/
+   ```
+   or copy the files manually—the key is to keep `.gitattributes`, `public/`, and the built `dist/` folder together.
+5. **Build locally before pushing** (same command Hugging Face runs server-side):
+   ```bash
+   npm install
+   npm run build
+   ```
+6. **Commit + push** – every push to `main` triggers an automatic Space rebuild:
+   ```bash
+   git add -A
+   git commit -m "Update MindGrab Space assets"
+   git push origin main
+   ```
+
+Because `.gitattributes` tracks `.safetensors` and `.nii.gz`, Git LFS handles the large weights/sample volumes automatically. Once pushed, the Space serves the built `dist/` bundle and fetches weights from `/public`, so inference continues entirely client-side over WebGPU.

index.html

@@ -1,19 +1,42 @@
 <!doctype html>
-<html>
-	<head>
-		<meta charset="utf-8" />
-		<meta name="viewport" content="width=device-width" />
-		<title>My static Space</title>
-		<link rel="stylesheet" href="style.css" />
-	</head>
-	<body>
-		<div class="card">
-			<h1>Welcome to your static Space!</h1>
-			<p>You can modify this app directly by editing <i>index.html</i> in the Files and versions tab.</p>
-			<p>
-				Also don't forget to check the
-				<a href="https://huggingface.co/docs/hub/spaces" target="_blank">Spaces documentation</a>.
-			</p>
-		</div>
-	</body>
+<html lang="en">
+
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <link rel="stylesheet" href="./niivue.css" />
+  <title>MindGrab WebGPU</title>
+</head>
+
+<body>
+  <header>
+    <button id="segmentBtn">Segment</button>
+    <label for="clipCheck">Clip Plane</label>
+    <input type="checkbox" id="clipCheck" unchecked />
+    <label for="opacitySlider0">Background Opacity</label>
+    <input type="range" min="0" max="255" value="255" class="slider" id="opacitySlider0" />
+    &nbsp;
+    <label for="opacitySlider1">Overlay Opacity</label>
+    <input type="range" min="0" max="255" value="128" class="slider" id="opacitySlider1" />
+    &nbsp;
+    <button id="saveImgBtn">Save Overlay</button>
+    &nbsp;
+    <button id="aboutBtn">About</button>
+    &nbsp;
+    <div id="loadingCircle" class="loading-circle hidden"></div>
+    <label for="segmentationDropdown">MindGrab Variant:</label>
+    <select id="segmentationDropdown">
+      <option value="mindgrab">MindGrab (default)</option>
+      <option value="mindgrab_tta_sagittal">MindGrab (TTA Sagittal)</option>
+      <option value="mindgrab_tta_coronal">MindGrab (TTA Coronal)</option>
+      <option value="mindgrab_tta_axial">MindGrab (TTA Axial)</option>
+    </select>
+  </header>
+  <main id="canvas-container">
+    <canvas id="gl1"></canvas>
+  </main>
+  <footer id="intensity">&nbsp;</footer>
+  <script type="module" src="/main.js"></script>
+</body>
+
 </html>

main.js

@@ -0,0 +1,295 @@
+import { Niivue } from '@niivue/niivue'
+import mindgrab from "./net_mindgrab.js"
+import mindgrab_tta_sagittal from "./net_mindgrab_tta_sagittal.js"
+import mindgrab_tta_coronal from "./net_mindgrab_tta_coronal.js"
+import mindgrab_tta_axial from "./net_mindgrab_tta_axial.js"
+
+const models = {
+  "mindgrab": {
+    "net": mindgrab,
+    "weightPath": "./net_mindgrab.safetensors",
+    "colormap": "./colormap_mindgrab.json",
+    "volume": "./t1_crop.nii.gz",
+    "normalization": "qnormalize"
+  },
+  "mindgrab_tta_sagittal": {
+    "net": mindgrab_tta_sagittal,
+    "weightPath": "./net_mindgrab_tta_sagittal.safetensors",
+    "colormap": "./colormap_mindgrab.json",
+    "volume": "./t1_crop.nii.gz",
+    "normalization": "qnormalize"
+  },
+  "mindgrab_tta_coronal": {
+    "net": mindgrab_tta_coronal,
+    "weightPath": "./net_mindgrab_tta_coronal.safetensors",
+    "colormap": "./colormap_mindgrab.json",
+    "volume": "./t1_crop.nii.gz",
+    "normalization": "qnormalize"
+  },
+  "mindgrab_tta_axial": {
+    "net": mindgrab_tta_axial,
+    "weightPath": "./net_mindgrab_tta_axial.safetensors",
+    "colormap": "./colormap_mindgrab.json",
+    "volume": "./t1_crop.nii.gz",
+    "normalization": "qnormalize"
+  }
+}
+
+let selectedModel = models[document.getElementById("segmentationDropdown").value]
+
+function qnormalize(img32, qmin = 0.02, qmax = 0.98, eps = 1e-3) {
+  // Create sorted copy to find quantiles
+  const sorted = [...img32].sort((a, b) => a - b);
+  // Calculate quantile indices
+  const n = sorted.length;
+  const qminIndex = Math.floor(qmin * (n - 1));
+  const qmaxIndex = Math.floor(qmax * (n - 1));
+  // Linear interpolation for accurate quantiles
+  const qminFrac = qmin * (n - 1) - qminIndex;
+  const qmaxFrac = qmax * (n - 1) - qmaxIndex;
+  let qlow = sorted[qminIndex];
+  if (qminIndex < n - 1) {
+    qlow += qminFrac * (sorted[qminIndex + 1] - sorted[qminIndex]);
+  }
+  let qhigh = sorted[qmaxIndex];
+  if (qmaxIndex < n - 1) {
+    qhigh += qmaxFrac * (sorted[qmaxIndex + 1] - sorted[qmaxIndex]);
+  }
+  // Normalize and clip in-place
+  const scale = 1 / (qhigh - qlow + eps);
+  for (let i = 0; i < img32.length; i++) {
+    img32[i] = Math.max(0, Math.min(1, (img32[i] - qlow) * scale));
+  }
+}
+
+async function main() {
+  clipCheck.onchange = function () {
+    if (clipCheck.checked) {
+      nv1.setClipPlane([0, 0, 90])
+    } else {
+      nv1.setClipPlane([2, 0, 90])
+    }
+  }
+  opacitySlider0.oninput = function () {
+    nv1.setOpacity(0, opacitySlider0.value / 255)
+    nv1.updateGLVolume()
+  }
+  opacitySlider1.oninput = function () {
+    nv1.setOpacity(1, opacitySlider1.value / 255)
+  }
+  function doLoadImage() {
+    opacitySlider0.oninput()
+  }
+  async function fetchJSON(fnm) {
+    const response = await fetch(fnm)
+    const js = await response.json()
+    return js
+  }
+  saveImgBtn.onclick = function () {
+    nv1.volumes[1].saveToDisk('Custom.nii')
+  }
+  aboutBtn.onclick = function () {
+    const url = "https://github.com/niivue/niivue-tinygrad"
+    window.open(url, "_blank")
+  }
+  async function ensureConformed() {
+    const nii = nv1.volumes[0]
+    let isConformed = nii.dims[1] === 256 && nii.dims[2] === 256 && nii.dims[3] === 256
+    if (nii.permRAS[0] !== -1 || nii.permRAS[1] !== 3 || nii.permRAS[2] !== -2) {
+      isConformed = false
+    }
+    if (isConformed) {
+      return
+    }
+    const nii2 = await nv1.conform(nii, false)
+    nv1.removeVolume(nv1.volumes[0])
+    nv1.addVolume(nii2)
+  }
+  async function closeAllOverlays() {
+    while (nv1.volumes.length > 1) {
+      nv1.removeVolume(nv1.volumes[1])
+    }
+  }
+  const getDevice = async () => {
+    if (!navigator.gpu) return false;
+    const adapter = await navigator.gpu.requestAdapter();
+
+    // Allow simulating lower buffer limits via URL param: ?maxBufferMB=128
+    const params = new URLSearchParams(window.location.search);
+    const simulatedMaxMB = params.get('maxBufferMB');
+    const simulatedMax = simulatedMaxMB ? parseInt(simulatedMaxMB) * 1024 * 1024 : Infinity;
+
+    const maxBufferSize = Math.min(simulatedMax, adapter.limits.maxBufferSize);
+    const maxStorageBufferBindingSize = Math.min(simulatedMax, adapter.limits.maxStorageBufferBindingSize);
+
+    console.log('Adapter limits:', adapter.limits);
+    console.log('Adapter max buffer size:', adapter.limits.maxBufferSize);
+    console.log('Requested max buffer size:', maxBufferSize, simulatedMaxMB ? `(simulated ${simulatedMaxMB}MB)` : '(using adapter max)');
+
+    return await adapter.requestDevice({
+        requiredLimits: {
+          maxBufferSize,
+          maxStorageBufferBindingSize,
+        },
+        requiredFeatures: ["shader-f16"]
+    });
+  };
+
+  const device = await getDevice();
+
+  // Buffer profiling monkeypatch
+  const bufferStats = { totalAllocated: 0, maxSingleBuffer: 0, count: 0 };
+  const _createBuffer = device.createBuffer.bind(device);
+  device.createBuffer = (descriptor) => {
+    bufferStats.totalAllocated += descriptor.size;
+    bufferStats.maxSingleBuffer = Math.max(bufferStats.maxSingleBuffer, descriptor.size);
+    bufferStats.count++;
+    return _createBuffer(descriptor);
+  };
+  window.bufferStats = bufferStats;
+  window.logBufferStats = () => console.log({
+    totalMB: (bufferStats.totalAllocated / 1024 / 1024).toFixed(2),
+    maxSingleMB: (bufferStats.maxSingleBuffer / 1024 / 1024).toFixed(2),
+    count: bufferStats.count
+  });
+
+  function convertInMemoryOrder(inverse, size, data) {
+    let output = new Float32Array(data.length)
+    let it = 0;
+
+    for (let x = 0; x < size; x++) {
+      for (let y = 0; y < size; y++) {
+        for (let z = 0; z < size; z++) {
+          let idx = x + y * size + z * size * size;
+          if (inverse) {
+            output[idx] = data[it++];
+          } else {
+            output[it++] = data[idx];
+          }
+        }
+      }
+    }
+
+    return output
+  }
+
+  segmentBtn.onclick = async function () {
+    if (nv1.volumes.length < 1) {
+      window.alert('Please open a voxel-based image')
+      return
+    }
+    const startTime = Date.now();
+    console.log('[Model] Starting segmentation...')
+    loadingCircle.classList.remove('hidden')
+
+    console.log('[Model] Phase 1: Preparing volume (closing overlays, conforming)...')
+    await closeAllOverlays()
+    await ensureConformed()
+    console.log('[Model] Phase 1: Volume preparation complete')
+
+    console.log('[Model] Phase 2: Normalizing input data...')
+    let img32 = convertInMemoryOrder(/*inverse*/ false, 256, new Float32Array(nv1.volumes[0].img))
+
+    console.log(selectedModel)
+    if (selectedModel['normalization'] === 'min-max') {
+      console.log('[Model] Phase 2: Using min-max normalization')
+      // normalize input data to range 0..1
+      let mx = img32[0]
+      let mn = mx
+      for (let i = 0; i < img32.length; i++) {
+        mx = Math.max(mx, img32[i])
+        mn = Math.min(mn, img32[i])
+      }
+      let scale32 = 1 / (mx - mn)
+      for (let i = 0; i < img32.length; i++) {
+        img32[i] = (img32[i] - mn) * scale32
+      }
+    } else {
+      console.log('[Model] Phase 2: Using quantile normalization')
+      qnormalize(img32);
+    }
+    console.log('[Model] Phase 2: Normalization complete')
+
+    console.log('[Model] Phase 3: Loading model weights...')
+    const session = await selectedModel["net"].load(device, selectedModel["weightPath"]);
+    console.log('[Model] Phase 3: Model weights loaded')
+
+    const shape = [1, 1, 256, 256, 256]
+    const nvox = shape.reduce((a, b) => a * b)
+    if (img32.length !== nvox) {
+      throw new Error(`img32 length (${img32.length}) does not match expected tensor length (${expectedLength})`)
+    }
+
+    console.log('[Model] Phase 4: Running inference...')
+    // Convert to Float16Array if model requires fp16 input
+    let inputData = img32;
+    if (selectedModel['fp16']) {
+      console.log('[Model] Phase 4: Converting to Float16Array for fp16 model')
+      inputData = new Float16Array(img32);
+    }
+    const results = await session(inputData);
+    console.log('[Model] Phase 4: Inference complete')
+
+    // Log label distribution in output cube
+    const outputData = results[0];
+    const totalVoxels = outputData.length;
+    const labelCounts = {};
+    for (let i = 0; i < totalVoxels; i++) {
+      const label = Math.round(outputData[i]);
+      labelCounts[label] = (labelCounts[label] || 0) + 1;
+    }
+    console.log('[Model] Label distribution in output cube:');
+    const sortedLabels = Object.keys(labelCounts).sort((a, b) => a - b);
+    for (const label of sortedLabels) {
+      const count = labelCounts[label];
+      const ratio = (count / totalVoxels * 100).toFixed(2);
+      console.log(`  Label ${label}: ${count} voxels (${ratio}%)`);
+    }
+
+    console.log('[Model] Phase 5: Post-processing results...')
+    let segmentImg = nv1.cloneVolume(0)
+    segmentImg.img = convertInMemoryOrder(/*inverse*/ true, 256, results[0])
+    segmentImg.hdr.datatypeCode = 16
+    segmentImg.hdr.dims[4] = 1
+    segmentImg.trustCalMinMax = false
+
+    // Add the output to niivue
+    const cmap = await fetchJSON(selectedModel["colormap"])
+    segmentImg.setColormapLabel(cmap)
+    segmentImg.opacity = opacitySlider1.value / 255
+    nv1.addVolume(segmentImg)
+    console.log('[Model] Phase 5: Post-processing complete')
+
+    loadingCircle.classList.add('hidden')
+    const elapsedTime = Date.now() - startTime
+    console.log(`[Model] Segmentation complete in ${elapsedTime}ms`)
+    document.getElementById("intensity").innerHTML = `${elapsedTime}ms to segment`
+  }
+  function handleLocationChange(data) {
+    document.getElementById("intensity").innerHTML = data.string
+  }
+  const defaults = {
+    backColor: [0.4, 0.4, 0.4, 1],
+    onLocationChange: handleLocationChange,
+  }
+  const nv1 = new Niivue(defaults)
+  nv1.attachToCanvas(gl1)
+  nv1.opts.multiplanarForceRender = true
+  nv1.opts.yoke3Dto2DZoom = true
+  nv1.opts.crosshairGap = 11
+  nv1.setInterpolation(true)
+  nv1.onImageLoaded = doLoadImage
+  await nv1.loadVolumes([{ url: selectedModel["volume"] }])
+  segmentBtn.onclick()
+
+  document.getElementById("segmentationDropdown").addEventListener("change", async function () {
+    selectedModel = models[this.value]
+    if (nv1.volumes[0].url != selectedModel["volume"]) {
+      nv1.removeVolumeByIndex(0)
+      await nv1.loadVolumes([{ url: selectedModel["volume"] }])
+    }
+    segmentBtn.onclick()
+  });
+}
+
+main()

package-lock.json

@@ -0,0 +1,953 @@
+{
+  "name": "niivue-tinygrad",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "niivue-tinygrad",
+      "version": "0.1.0",
+      "dependencies": {
+        "@niivue/niivue": "^0.48.1"
+      },
+      "devDependencies": {
+        "vite": "^5.2.0"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.20.2.tgz",
+      "integrity": "sha512-D+EBOJHXdNZcLJRBkhENNG8Wji2kgc9AZ9KiPr1JuZjsNtyHzrsfLRrY0tk2H2aoFu6RANO1y1iPPUCDYWkb5g==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.20.2.tgz",
+      "integrity": "sha512-t98Ra6pw2VaDhqNWO2Oph2LXbz/EJcnLmKLGBJwEwXX/JAN83Fym1rU8l0JUWK6HkIbWONCSSatf4sf2NBRx/w==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.20.2.tgz",
+      "integrity": "sha512-mRzjLacRtl/tWU0SvD8lUEwb61yP9cqQo6noDZP/O8VkwafSYwZ4yWy24kan8jE/IMERpYncRt2dw438LP3Xmg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.20.2.tgz",
+      "integrity": "sha512-btzExgV+/lMGDDa194CcUQm53ncxzeBrWJcncOBxuC6ndBkKxnHdFJn86mCIgTELsooUmwUm9FkhSp5HYu00Rg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.20.2.tgz",
+      "integrity": "sha512-4J6IRT+10J3aJH3l1yzEg9y3wkTDgDk7TSDFX+wKFiWjqWp/iCfLIYzGyasx9l0SAFPT1HwSCR+0w/h1ES/MjA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.20.2.tgz",
+      "integrity": "sha512-tBcXp9KNphnNH0dfhv8KYkZhjc+H3XBkF5DKtswJblV7KlT9EI2+jeA8DgBjp908WEuYll6pF+UStUCfEpdysA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.20.2.tgz",
+      "integrity": "sha512-d3qI41G4SuLiCGCFGUrKsSeTXyWG6yem1KcGZVS+3FYlYhtNoNgYrWcvkOoaqMhwXSMrZRl69ArHsGJ9mYdbbw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.20.2.tgz",
+      "integrity": "sha512-d+DipyvHRuqEeM5zDivKV1KuXn9WeRX6vqSqIDgwIfPQtwMP4jaDsQsDncjTDDsExT4lR/91OLjRo8bmC1e+Cw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.20.2.tgz",
+      "integrity": "sha512-VhLPeR8HTMPccbuWWcEUD1Az68TqaTYyj6nfE4QByZIQEQVWBB8vup8PpR7y1QHL3CpcF6xd5WVBU/+SBEvGTg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.20.2.tgz",
+      "integrity": "sha512-9pb6rBjGvTFNira2FLIWqDk/uaf42sSyLE8j1rnUpuzsODBq7FvpwHYZxQ/It/8b+QOS1RYfqgGFNLRI+qlq2A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.20.2.tgz",
+      "integrity": "sha512-o10utieEkNPFDZFQm9CoP7Tvb33UutoJqg3qKf1PWVeeJhJw0Q347PxMvBgVVFgouYLGIhFYG0UGdBumROyiig==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.20.2.tgz",
+      "integrity": "sha512-PR7sp6R/UC4CFVomVINKJ80pMFlfDfMQMYynX7t1tNTeivQ6XdX5r2XovMmha/VjR1YN/HgHWsVcTRIMkymrgQ==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.20.2.tgz",
+      "integrity": "sha512-4BlTqeutE/KnOiTG5Y6Sb/Hw6hsBOZapOVF6njAESHInhlQAghVVZL1ZpIctBOoTFbQyGW+LsVYZ8lSSB3wkjA==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.20.2.tgz",
+      "integrity": "sha512-rD3KsaDprDcfajSKdn25ooz5J5/fWBylaaXkuotBDGnMnDP1Uv5DLAN/45qfnf3JDYyJv/ytGHQaziHUdyzaAg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.20.2.tgz",
+      "integrity": "sha512-snwmBKacKmwTMmhLlz/3aH1Q9T8v45bKYGE3j26TsaOVtjIag4wLfWSiZykXzXuE1kbCE+zJRmwp+ZbIHinnVg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.20.2.tgz",
+      "integrity": "sha512-wcWISOobRWNm3cezm5HOZcYz1sKoHLd8VL1dl309DiixxVFoFe/o8HnwuIwn6sXre88Nwj+VwZUvJf4AFxkyrQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.20.2.tgz",
+      "integrity": "sha512-1MdwI6OOTsfQfek8sLwgyjOXAu+wKhLEoaOLTjbijk6E2WONYpH9ZU2mNtR+lZ2B4uwr+usqGuVfFT9tMtGvGw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.20.2.tgz",
+      "integrity": "sha512-K8/DhBxcVQkzYc43yJXDSyjlFeHQJBiowJ0uVL6Tor3jGQfSGHNNJcWxNbOI8v5k82prYqzPuwkzHt3J1T1iZQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.20.2.tgz",
+      "integrity": "sha512-eMpKlV0SThJmmJgiVyN9jTPJ2VBPquf6Kt/nAoo6DgHAoN57K15ZghiHaMvqjCye/uU4X5u3YSMgVBI1h3vKrQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.20.2.tgz",
+      "integrity": "sha512-2UyFtRC6cXLyejf/YEld4Hajo7UHILetzE1vsRcGL3earZEW77JxrFjH4Ez2qaTiEfMgAXxfAZCm1fvM/G/o8w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.20.2.tgz",
+      "integrity": "sha512-GRibxoawM9ZCnDxnP3usoUDO9vUkpAxIIZ6GQI+IlVmr5kP3zUq+l17xELTHMWTWzjxa2guPNyrpq1GWmPvcGQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.20.2.tgz",
+      "integrity": "sha512-HfLOfn9YWmkSKRQqovpnITazdtquEW8/SoHW7pWpuEeguaZI4QnCRW6b+oZTztdBnZOS2hqJ6im/D5cPzBTTlQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.20.2.tgz",
+      "integrity": "sha512-N49X4lJX27+l9jbLKSqZ6bKNjzQvHaT8IIFUy+YIqmXQdjYCToGWwOItDrfby14c78aDd5NHQl29xingXfCdLQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@lukeed/csprng": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@lukeed/csprng/-/csprng-1.1.0.tgz",
+      "integrity": "sha512-Z7C/xXCiGWsg0KuKsHTKJxbWhpI3Vs5GwLfOean7MGyVFGqdRgBbAjOCh6u4bbjPc/8MJ2pZmK/0DLdCbivLDA==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/@lukeed/uuid": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/@lukeed/uuid/-/uuid-2.0.1.tgz",
+      "integrity": "sha512-qC72D4+CDdjGqJvkFMMEAtancHUQ7/d/tAiHf64z8MopFDmcrtbcJuerDtFceuAfQJ2pDSfCKCtbqoGBNnwg0w==",
+      "dependencies": {
+        "@lukeed/csprng": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/@niivue/niivue": {
+      "version": "0.48.1",
+      "resolved": "https://registry.npmjs.org/@niivue/niivue/-/niivue-0.48.1.tgz",
+      "integrity": "sha512-xeSrJ/3BBWiQsI6tK8YL3DOGumnX4oMfMZPpUIji+2mIYlqlylLxBtzAKIBIttEmJcwx/PzYb4HeY6TQVUvMzw==",
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "@lukeed/uuid": "^2.0.1",
+        "@ungap/structured-clone": "^1.2.0",
+        "array-equal": "^1.0.2",
+        "daikon": "^1.2.46",
+        "fflate": "^0.8.2",
+        "gl-matrix": "^3.4.3",
+        "nifti-reader-js": "^0.6.8",
+        "rxjs": "^7.8.1"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-linux-x64-gnu": "^4.18.1"
+      }
+    },
+    "node_modules/@niivue/niivue/node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.31.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.31.0.tgz",
+      "integrity": "sha512-zSoHl356vKnNxwOWnLd60ixHNPRBglxpv2g7q0Cd3Pmr561gf0HiAcUBRL3S1vPqRC17Zo2CX/9cPkqTIiai1g==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.16.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.16.4.tgz",
+      "integrity": "sha512-GkhjAaQ8oUTOKE4g4gsZ0u8K/IHU1+2WQSgS1TwTcYvL+sjbaQjNHFXbOJ6kgqGHIO1DfUhI/Sphi9GkRT9K+Q==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.16.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.16.4.tgz",
+      "integrity": "sha512-Bvm6D+NPbGMQOcxvS1zUl8H7DWlywSXsphAeOnVeiZLQ+0J6Is8T7SrjGTH29KtYkiY9vld8ZnpV3G2EPbom+w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.16.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.16.4.tgz",
+      "integrity": "sha512-i5d64MlnYBO9EkCOGe5vPR/EeDwjnKOGGdd7zKFhU5y8haKhQZTN2DgVtpODDMxUr4t2K90wTUJg7ilgND6bXw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.16.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.16.4.tgz",
+      "integrity": "sha512-WZupV1+CdUYehaZqjaFTClJI72fjJEgTXdf4NbW69I9XyvdmztUExBtcI2yIIU6hJtYvtwS6pkTkHJz+k08mAQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.16.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.16.4.tgz",
+      "integrity": "sha512-ADm/xt86JUnmAfA9mBqFcRp//RVRt1ohGOYF6yL+IFCYqOBNwy5lbEK05xTsEoJq+/tJzg8ICUtS82WinJRuIw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.16.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.16.4.tgz",
+      "integrity": "sha512-tJfJaXPiFAG+Jn3cutp7mCs1ePltuAgRqdDZrzb1aeE3TktWWJ+g7xK9SNlaSUFw6IU4QgOxAY4rA+wZUT5Wfg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.16.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.16.4.tgz",
+      "integrity": "sha512-7dy1BzQkgYlUTapDTvK997cgi0Orh5Iu7JlZVBy1MBURk7/HSbHkzRnXZa19ozy+wwD8/SlpJnOOckuNZtJR9w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.16.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.16.4.tgz",
+      "integrity": "sha512-zsFwdUw5XLD1gQe0aoU2HVceI6NEW7q7m05wA46eUAyrkeNYExObfRFQcvA6zw8lfRc5BHtan3tBpo+kqEOxmg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-powerpc64le-gnu": {
+      "version": "4.16.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.16.4.tgz",
+      "integrity": "sha512-p8C3NnxXooRdNrdv6dBmRTddEapfESEUflpICDNKXpHvTjRRq1J82CbU5G3XfebIZyI3B0s074JHMWD36qOW6w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.16.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.16.4.tgz",
+      "integrity": "sha512-Lh/8ckoar4s4Id2foY7jNgitTOUQczwMWNYi+Mjt0eQ9LKhr6sK477REqQkmy8YHY3Ca3A2JJVdXnfb3Rrwkng==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.16.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.16.4.tgz",
+      "integrity": "sha512-1xwwn9ZCQYuqGmulGsTZoKrrn0z2fAur2ujE60QgyDpHmBbXbxLaQiEvzJWDrscRq43c8DnuHx3QorhMTZgisQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.16.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.16.4.tgz",
+      "integrity": "sha512-LuOGGKAJ7dfRtxVnO1i3qWc6N9sh0Em/8aZ3CezixSTM+E9Oq3OvTsvC4sm6wWjzpsIlOCnZjdluINKESflJLA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.16.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.16.4.tgz",
+      "integrity": "sha512-ch86i7KkJKkLybDP2AtySFTRi5fM3KXp0PnHocHuJMdZwu7BuyIKi35BE9guMlmTpwwBTB3ljHj9IQXnTCD0vA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.16.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.16.4.tgz",
+      "integrity": "sha512-Ma4PwyLfOWZWayfEsNQzTDBVW8PZ6TUUN1uFTBQbF2Chv/+sjenE86lpiEwj2FiviSmSZ4Ap4MaAfl1ciF4aSA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.16.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.16.4.tgz",
+      "integrity": "sha512-9m/ZDrQsdo/c06uOlP3W9G2ENRVzgzbSXmXHT4hwVaDQhYcRpi9bgBT0FTG9OhESxwK0WjQxYOSfv40cU+T69w==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.16.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.16.4.tgz",
+      "integrity": "sha512-YunpoOAyGLDseanENHmbFvQSfVL5BxW3k7hhy0eN4rb3gS/ct75dVD0EXOWIqFT/nE8XYW6LP6vz6ctKRi0k9A==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.5.tgz",
+      "integrity": "sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw==",
+      "dev": true
+    },
+    "node_modules/@ungap/structured-clone": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.2.0.tgz",
+      "integrity": "sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ=="
+    },
+    "node_modules/@wearemothership/dicom-character-set": {
+      "version": "1.0.4-opt.1",
+      "resolved": "https://registry.npmjs.org/@wearemothership/dicom-character-set/-/dicom-character-set-1.0.4-opt.1.tgz",
+      "integrity": "sha512-stqhnpawYHY2UZKj4RHTF71ab3q3z8S1SO9ToQKjsHQwowUdFVo6YFea93psFux3yqNbRlQjwoCdPjHcD0YQzw==",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/array-equal": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/array-equal/-/array-equal-1.0.2.tgz",
+      "integrity": "sha512-gUHx76KtnhEgB3HOuFYiCm3FIdEs6ocM2asHvNTkfu/Y09qQVrrVVaOKENmS2KkSaGoxgXNqC+ZVtR/n0MOkSA==",
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/commander": {
+      "version": "2.20.3",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
+      "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ=="
+    },
+    "node_modules/cssfilter": {
+      "version": "0.0.10",
+      "resolved": "https://registry.npmjs.org/cssfilter/-/cssfilter-0.0.10.tgz",
+      "integrity": "sha512-FAaLDaplstoRsDR8XGYH51znUN0UY7nMc6Z9/fvE8EXGwvJE9hu7W2vHwx1+bd6gCYnln9nLbzxFTrcO9YQDZw=="
+    },
+    "node_modules/daikon": {
+      "version": "1.2.46",
+      "resolved": "https://registry.npmjs.org/daikon/-/daikon-1.2.46.tgz",
+      "integrity": "sha512-S8dTTlsWYTH3LQztjTW9KnNvxDeL2mr2cau0auLdYMJe4TrocYP1PmidHizO3rXUs+gXpBWI1PQ2qvB4b21QFw==",
+      "dependencies": {
+        "@wearemothership/dicom-character-set": "^1.0.4-opt.1",
+        "fflate": "*",
+        "jpeg-lossless-decoder-js": "2.0.7",
+        "pako": "^2.1",
+        "xss": "1.0.14"
+      }
+    },
+    "node_modules/esbuild": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.20.2.tgz",
+      "integrity": "sha512-WdOOppmUNU+IbZ0PaDiTst80zjnrOkyJNHoKupIcVyU8Lvla3Ugx94VzkQ32Ijqd7UhHJy75gNWDMUekcrSJ6g==",
+      "dev": true,
+      "hasInstallScript": true,
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.20.2",
+        "@esbuild/android-arm": "0.20.2",
+        "@esbuild/android-arm64": "0.20.2",
+        "@esbuild/android-x64": "0.20.2",
+        "@esbuild/darwin-arm64": "0.20.2",
+        "@esbuild/darwin-x64": "0.20.2",
+        "@esbuild/freebsd-arm64": "0.20.2",
+        "@esbuild/freebsd-x64": "0.20.2",
+        "@esbuild/linux-arm": "0.20.2",
+        "@esbuild/linux-arm64": "0.20.2",
+        "@esbuild/linux-ia32": "0.20.2",
+        "@esbuild/linux-loong64": "0.20.2",
+        "@esbuild/linux-mips64el": "0.20.2",
+        "@esbuild/linux-ppc64": "0.20.2",
+        "@esbuild/linux-riscv64": "0.20.2",
+        "@esbuild/linux-s390x": "0.20.2",
+        "@esbuild/linux-x64": "0.20.2",
+        "@esbuild/netbsd-x64": "0.20.2",
+        "@esbuild/openbsd-x64": "0.20.2",
+        "@esbuild/sunos-x64": "0.20.2",
+        "@esbuild/win32-arm64": "0.20.2",
+        "@esbuild/win32-ia32": "0.20.2",
+        "@esbuild/win32-x64": "0.20.2"
+      }
+    },
+    "node_modules/fflate": {
+      "version": "0.8.2",
+      "resolved": "https://registry.npmjs.org/fflate/-/fflate-0.8.2.tgz",
+      "integrity": "sha512-cPJU47OaAoCbg0pBvzsgpTPhmhqI5eJjh/JIu8tPj5q+T7iLvW/JAYUqmE7KOB4R1ZyEhzBaIQpQpardBF5z8A=="
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/gl-matrix": {
+      "version": "3.4.3",
+      "resolved": "https://registry.npmjs.org/gl-matrix/-/gl-matrix-3.4.3.tgz",
+      "integrity": "sha512-wcCp8vu8FT22BnvKVPjXa/ICBWRq/zjFfdofZy1WSpQZpphblv12/bOQLBC1rMM7SGOFS9ltVmKOHil5+Ml7gA=="
+    },
+    "node_modules/jpeg-lossless-decoder-js": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/jpeg-lossless-decoder-js/-/jpeg-lossless-decoder-js-2.0.7.tgz",
+      "integrity": "sha512-tbZlhFkKmx+JaqVMkq47SKWGuXLkIaV8fTbnhO39dYEnQrSShLGuLCGb0n6ntXjtmk6oAWGiIriWOLwj9od0yQ=="
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.7",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.7.tgz",
+      "integrity": "sha512-eSRppjcPIatRIMC1U6UngP8XFcz8MQWGQdt1MTBQ7NaAmvXDfvNxbvWV3x2y6CdEUciCSsDHDQZbhYaB8QEo2g==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/nifti-reader-js": {
+      "version": "0.6.8",
+      "resolved": "https://registry.npmjs.org/nifti-reader-js/-/nifti-reader-js-0.6.8.tgz",
+      "integrity": "sha512-yIKNVzYFiUcSHazoR+sd6Ka7sUmZTabaVqJRFxbdlAKR1hnPBuNP71g3AyApo37nJ3k41c632QPij5q7gF1YPQ==",
+      "dependencies": {
+        "fflate": "*"
+      }
+    },
+    "node_modules/pako": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/pako/-/pako-2.1.0.tgz",
+      "integrity": "sha512-w+eufiZ1WuJYgPXbV/PO3NCMEc3xqylkKHzp8bxp1uW4qaSNQUkwmLLEc3kKsfz8lpV1F8Ht3U1Cm+9Srog2ug=="
+    },
+    "node_modules/picocolors": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz",
+      "integrity": "sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==",
+      "dev": true
+    },
+    "node_modules/postcss": {
+      "version": "8.4.38",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.38.tgz",
+      "integrity": "sha512-Wglpdk03BSfXkHoQa3b/oulrotAkwrlLDRSOb9D0bN86FdRyE9lppSp33aHNPgBa0JKCoB+drFLZkQoRRYae5A==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "dependencies": {
+        "nanoid": "^3.3.7",
+        "picocolors": "^1.0.0",
+        "source-map-js": "^1.2.0"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.16.4",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.16.4.tgz",
+      "integrity": "sha512-kuaTJSUbz+Wsb2ATGvEknkI12XV40vIiHmLuFlejoo7HtDok/O5eDDD0UpCVY5bBX5U5RYo8wWP83H7ZsqVEnA==",
+      "dev": true,
+      "dependencies": {
+        "@types/estree": "1.0.5"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.16.4",
+        "@rollup/rollup-android-arm64": "4.16.4",
+        "@rollup/rollup-darwin-arm64": "4.16.4",
+        "@rollup/rollup-darwin-x64": "4.16.4",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.16.4",
+        "@rollup/rollup-linux-arm-musleabihf": "4.16.4",
+        "@rollup/rollup-linux-arm64-gnu": "4.16.4",
+        "@rollup/rollup-linux-arm64-musl": "4.16.4",
+        "@rollup/rollup-linux-powerpc64le-gnu": "4.16.4",
+        "@rollup/rollup-linux-riscv64-gnu": "4.16.4",
+        "@rollup/rollup-linux-s390x-gnu": "4.16.4",
+        "@rollup/rollup-linux-x64-gnu": "4.16.4",
+        "@rollup/rollup-linux-x64-musl": "4.16.4",
+        "@rollup/rollup-win32-arm64-msvc": "4.16.4",
+        "@rollup/rollup-win32-ia32-msvc": "4.16.4",
+        "@rollup/rollup-win32-x64-msvc": "4.16.4",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/rxjs": {
+      "version": "7.8.1",
+      "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.8.1.tgz",
+      "integrity": "sha512-AA3TVj+0A2iuIoQkWEK/tqFjBq2j+6PO6Y0zJcvzLAFhEFIO3HL0vls9hWLncZbAAbK0mar7oZ4V079I/qPMxg==",
+      "dependencies": {
+        "tslib": "^2.1.0"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.0.tgz",
+      "integrity": "sha512-itJW8lvSA0TXEphiRoawsCksnlf8SyvmFzIhltqAHluXd88pkCd+cXJVHTDwdCr0IzwptSm035IHQktUu1QUMg==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/tslib": {
+      "version": "2.6.2",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.2.tgz",
+      "integrity": "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q=="
+    },
+    "node_modules/vite": {
+      "version": "5.2.10",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-5.2.10.tgz",
+      "integrity": "sha512-PAzgUZbP7msvQvqdSD+ErD5qGnSFiGOoWmV5yAKUEI0kdhjbH6nMWVyZQC/hSc4aXwc0oJ9aEdIiF9Oje0JFCw==",
+      "dev": true,
+      "dependencies": {
+        "esbuild": "^0.20.1",
+        "postcss": "^8.4.38",
+        "rollup": "^4.13.0"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || >=20.0.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.4.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/xss": {
+      "version": "1.0.14",
+      "resolved": "https://registry.npmjs.org/xss/-/xss-1.0.14.tgz",
+      "integrity": "sha512-og7TEJhXvn1a7kzZGQ7ETjdQVS2UfZyTlsEdDOqvQF7GoxNfY+0YLCzBy1kPdsDDx4QuNAonQPddpsn6Xl/7sw==",
+      "dependencies": {
+        "commander": "^2.20.3",
+        "cssfilter": "0.0.10"
+      },
+      "bin": {
+        "xss": "bin/xss"
+      },
+      "engines": {
+        "node": ">= 0.10.0"
+      }
+    }
+  }
+}

package.json

@@ -0,0 +1,17 @@
+{
+  "name": "niivue-tinygrad",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@niivue/niivue": "^0.48.1"
+  },
+  "devDependencies": {
+    "vite": "^5.2.0"
+  }
+}

public/colormap_mindgrab.json

@@ -0,0 +1,6 @@
+{
+    "R": [0, 255],
+    "G": [0, 0],
+    "B": [0, 0],
+    "labels": ["background", "brain"]
+}

public/net_mindgrab.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ff5dc4075c10687a2023236248c1d3ba3d5adfa4a4a0b2150bcdd1e21b5d0554
+size 587188

public/net_mindgrab_tta_axial.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36045f90556ed4969339654f7c6256c5af61ba8fa78e77dc6a67e064ca961f54
+size 849596

public/net_mindgrab_tta_coronal.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36045f90556ed4969339654f7c6256c5af61ba8fa78e77dc6a67e064ca961f54
+size 849596

public/net_mindgrab_tta_sagittal.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36045f90556ed4969339654f7c6256c5af61ba8fa78e77dc6a67e064ca961f54
+size 849596

public/niivue.css

@@ -0,0 +1,109 @@
+html {
+  height: auto;
+  min-height: 100%;
+  margin: 0;
+}
+body {
+  display: flex;
+  flex-direction: column;
+  margin: 0;
+  min-height: 100%;
+  width: 100%;
+  position: absolute;
+  font-family: system-ui, Arial, Helvetica, sans-serif;
+  user-select: none; /* Standard syntax */
+  color: white;
+  background: #303030;
+}
+header {
+  margin: 10px;
+}
+main {
+  flex: 1;
+  background: #000000;
+  position: relative;
+}
+footer {
+  margin: 10px;
+}
+canvas {
+  position: absolute;
+  cursor: crosshair;
+}
+canvas:focus {
+  outline: 0px;
+}
+div {
+  display: table-row;
+  background-color: blue;
+}
+.dropdown {
+  float: left;
+  overflow: hidden;
+}
+.dropdown .dropbtn {
+  font-size: 16px;
+  border: none;
+  outline: none;
+  color: white;
+  padding: 12px 12px;
+  background-color: #303030;
+  font-family: inherit;
+  margin: 0;
+}
+.dropdown:hover .dropbtn {
+  background-color: #9a9;
+}
+.dropdown-content {
+  display: none;
+  position: absolute;
+  background-color: #303030;
+  min-width: 160px;
+  border-radius: 5px;
+  box-shadow: 0px 8px 16px 0px rgba(0, 0, 0, 0.2);
+  z-index: 1;
+}
+.dropdown-content a {
+  float: none;
+  color: white;
+  padding: 12px 16px;
+  text-decoration: none;
+  display: block;
+  text-align: left;
+  line-height: 6px;
+}
+.dropdown-content a:hover {
+  background-color: #aba;
+}
+.dropdown:hover .dropdown-content {
+  display: block;
+}
+.dropdown-item-checked::before {
+  position: absolute;
+  left: 0.2rem;
+  content: "\2022"; /* or '✓' */
+  font-weight: 600;
+}
+.divider {
+  border-top: 1px solid grey;
+}
+.vertical-divider {
+  border-left: 1px solid grey;
+  height: 40px;
+}
+.help-text {
+  margin: auto;
+  max-width: 150px;
+  padding: 0 10px;
+}
+.slidecontainer {
+  padding: 10px 10px;
+  white-space: normal;
+  word-break: break-word;
+  display: flex;
+  align-items: center;
+  flex: 0 0 auto;
+}
+
+div.footer { width: 100%; display: block; background: #303030;}
+table.footer { width: 100%;height: 100%; table-layout: fixed;}

public/t1_crop.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f5708dd1980fe0017ad70f63d895bae66bd9f5487eb1c38d129591116113613
+size 3068922

style.css

@@ -1,28 +0,0 @@
-body {
-	padding: 2rem;
-	font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
-}
-
-h1 {
-	font-size: 16px;
-	margin-top: 0;
-}
-
-p {
-	color: rgb(107, 114, 128);
-	font-size: 15px;
-	margin-bottom: 10px;
-	margin-top: 5px;
-}
-
-.card {
-	max-width: 620px;
-	margin: 0 auto;
-	padding: 16px;
-	border: 1px solid lightgray;
-	border-radius: 16px;
-}
-
-.card p:last-child {
-	margin-bottom: 0;
-}

tensor-utils.js

@@ -0,0 +1,613 @@
+import * as tf from '@tensorflow/tfjs'
+import { BWLabeler } from './bwlabels.js'
+
+export async function addZeroPaddingTo3dTensor(tensor3d, rowPadArr = [1, 1], colPadArr = [1, 1], depthPadArr = [1, 1]) {
+  if (tensor3d.rank !== 3) {
+    throw new Error('Tensor must be 3D')
+  }
+  return tensor3d.pad([rowPadArr, colPadArr, depthPadArr])
+}
+
+export async function applyMriThreshold(tensor, percentage) {
+  // Perform asynchronous operations outside of tf.tidy
+  const maxTensor = tensor.max()
+  const thresholdTensor = maxTensor.mul(percentage)
+  const threshold = await thresholdTensor.data() // Extracts the threshold value
+
+  // Dispose tensors not needed anymore
+  maxTensor.dispose()
+  thresholdTensor.dispose()
+
+  // Use tf.tidy for synchronous operations
+  return tf.tidy(() => {
+    const dataForProcessing = tensor.clone()
+
+    // Thresholding (assuming background has very low values compared to the head)
+    const mask = dataForProcessing.greater(threshold[0])
+    // -- const denoisedMriData = dataForProcessing.mul(mask)
+
+    // No need to  manually dispose dataForProcessing and mask, as tf.tidy() will dispose them auto.
+    return mask
+  })
+
+  // -- return denoisedMriData
+}
+
+export async function binarizeVolumeDataTensor(volumeDataTensor) {
+  const alpha = 0
+  // element-wise: (x > 0 ? 1 : alpha * x );  e.g. Tenosr [0, 0.9, 0.8, -3] => Tensor [0, 1, 1, 0]
+  return volumeDataTensor.step(alpha)
+}
+
+async function calculateQuantiles(tensor, lowerQuantile = 0.01, upperQuantile = 0.99) {
+  // Flatten the tensor
+  const flatTensor = tensor.flatten()
+
+  // Convert the flattened tensor to an array to sort it
+  const flatArray = await flatTensor.array()
+  flatArray.sort((a, b) => a - b) // Sort the array in ascending order
+
+  // Convert the sorted array back to a tensor
+  const sortedTensor = tf.tensor1d(flatArray)
+
+  // Calculate the indices for the quantiles
+  const numElements = sortedTensor.shape[0]
+  const lowIndex = Math.floor(numElements * lowerQuantile)
+  const highIndex = Math.ceil(numElements * upperQuantile) - 1 // Subtract 1 because indices are 0-based
+
+  // Slice the sorted tensor to get qmin and qmax
+  const qmin = sortedTensor.slice(lowIndex, 1) // Get the value at the low index
+  const qmax = sortedTensor.slice(highIndex, 1) // Get the value at the high index
+
+  // Get the actual values from the tensors
+  const qminValue = (await qmin.array())[0]
+  const qmaxValue = (await qmax.array())[0]
+
+  // Clean up tensors to free memory
+  flatTensor.dispose()
+  sortedTensor.dispose()
+  qmin.dispose()
+  qmax.dispose()
+
+  return { qmin: qminValue, qmax: qmaxValue }
+}
+
+export async function convByOutputChannelAndInputSlicing(input, filter, biases, stride, pad, dilationRate, sliceSize) {
+  const inChannels = input.shape[4]
+  const outChannels = filter.shape[4]
+
+  // Create an empty array to hold the output channels
+  let outputChannels = null
+
+  // Slice the input tensor and process one output channel at a time
+  for (let channel = 0; channel < outChannels; channel++) {
+    const numSlices = Math.ceil(inChannels / sliceSize)
+    const biasesSlice = biases.slice([channel], [1])
+    let outputChannel = null
+
+    for (let i = 0; i < numSlices; i++) {
+      const startChannel = i * sliceSize
+      const endChannel = Math.min((i + 1) * sliceSize, inChannels)
+
+      // Only proceed if there are channels to process
+      if (startChannel < inChannels) {
+        const resultSlice = tf.tidy(() => {
+          const inputSlice = input.slice([0, 0, 0, 0, startChannel], [-1, -1, -1, -1, endChannel - startChannel])
+          const filterSlice = filter.slice([0, 0, 0, startChannel, channel], [-1, -1, -1, endChannel - startChannel, 1])
+          // Perform the convolution for the current slice and output channel
+          return tf.conv3d(inputSlice, filterSlice, stride, pad, 'NDHWC', dilationRate)
+        })
+
+        if (outputChannel === null) {
+          outputChannel = resultSlice
+        } else {
+          const updatedOutputChannel = outputChannel.add(resultSlice)
+          outputChannel.dispose()
+          resultSlice.dispose()
+          outputChannel = updatedOutputChannel
+        }
+      }
+    }
+
+    // Add the biases to the accumulated convolutions for this channel
+    const biasedOutputChannel = outputChannel.add(biasesSlice)
+    outputChannel.dispose()
+    biasesSlice.dispose()
+
+    // Accumulate the channel to the output array
+    if (outputChannels == null) {
+      outputChannels = biasedOutputChannel
+    } else {
+      const updatedOutputChannels = await tf.concat([outputChannels, biasedOutputChannel], 4)
+      biasedOutputChannel.dispose()
+      outputChannels.dispose()
+      outputChannels = updatedOutputChannels
+    }
+  }
+
+  return outputChannels
+}
+
+export async function draw3dObjBoundingVolume(unstackOutVolumeTensor, opts, modelEntry, callbackImg) {
+  const allOutputSlices3DCC = []
+
+  // dataSync() using to flatten array. Takes around 1.5 s
+  for (let sliceTensorIdx = 0; sliceTensorIdx < unstackOutVolumeTensor.length; sliceTensorIdx++) {
+    allOutputSlices3DCC[sliceTensorIdx] = Array.from(unstackOutVolumeTensor[sliceTensorIdx].dataSync())
+  }
+
+  // Use this conversion to download output slices as nii file. Takes around 30 ms
+  // does not use `push` to avoid stack overflows. In future: consider .set() with typed arrays
+  const allOutputSlices3DCC1DimArray = new Array(allOutputSlices3DCC[0].length * allOutputSlices3DCC.length)
+  let index = 0
+  for (let sliceIdx = 0; sliceIdx < allOutputSlices3DCC.length; sliceIdx++) {
+    for (let i = 0; i < allOutputSlices3DCC[sliceIdx].length; i++) {
+      allOutputSlices3DCC1DimArray[index++] = allOutputSlices3DCC[sliceIdx][i]
+    }
+  }
+  console.log('Done with allOutputSlices3DCC1DimArray ')
+  const brainMaskTensor1d = await binarizeVolumeDataTensor(tf.tensor1d(allOutputSlices3DCC1DimArray))
+  const brainOut = Array.from(brainMaskTensor1d.dataSync())
+  callbackImg(brainOut, opts, modelEntry)
+}
+// return first and last non-zero voxel in row (dim = 0), column (1) or slice (2) dimension
+async function firstLastNonZero(tensor3D, dim = 0) {
+  let mxs = []
+  if (dim === 0) {
+    mxs = await tensor3D.max(2).max(1).arraySync()
+  } else if (dim === 1) {
+    mxs = await tensor3D.max(2).max(0).arraySync()
+  } else {
+    mxs = await tensor3D.max(1).max(0).arraySync()
+  }
+  let mn = mxs.length
+  let mx = 0
+  for (let i = 0; i < mxs.length; i++) {
+    if (mxs[i] > 0) {
+      mn = i
+      break
+    }
+  }
+  for (let i = mxs.length - 1; i >= 0; i--) {
+    if (mxs[i] > 0) {
+      mx = i
+      break
+    }
+  }
+  return [mn, mx]
+}
+
+export async function firstLastNonZero3D(tensor3D) {
+  const [row_min, row_max] = await firstLastNonZero(tensor3D, 0)
+  const [col_min, col_max] = await firstLastNonZero(tensor3D, 1)
+  const [depth_min, depth_max] = await firstLastNonZero(tensor3D, 2)
+  console.log('row min and max  :', row_min, row_max)
+  console.log('col min and max  :', col_min, col_max)
+  console.log('depth min and max  :', depth_min, depth_max)
+  return [row_min, row_max, col_min, col_max, depth_min, depth_max]
+}
+
+/*
+//simpler function, but x4 slower
+export async function firstLastNonZero3D(tensor3D) {
+  const coords = await tf.whereAsync(tensor3D)
+  const row_min = coords.min(0).arraySync()[0]
+  const row_max = coords.max(0).arraySync()[0]
+  const col_min = coords.min(0).arraySync()[1]
+  const col_max = coords.max(0).arraySync()[1]
+  const depth_min = coords.min(0).arraySync()[2]
+  const depth_max = coords.max(0).arraySync()[2]
+  coords.dispose()
+  return [row_min, row_max, col_min, col_max, depth_min, depth_max]
+}
+*/
+
+export async function generateBrainMask(
+  unstackOutVolumeTensor,
+  num_of_slices,
+  slice_height,
+  slice_width,
+  modelEntry,
+  opts,
+  callbackUI,
+  callbackImg,
+  isFinalImage = true
+) {
+  if (unstackOutVolumeTensor[0].dtype !== 'int32') {
+    callbackUI('', -1, 'generateBrainMask assumes int32')
+  }
+  if (modelEntry.preModelPostProcess) {
+    callbackUI('', -1, 'generateBrainMask assumes BWLabeler instead of preModelPostProcess')
+  }
+  const numSlices = unstackOutVolumeTensor.length
+  const numPixels2D = unstackOutVolumeTensor[0].size
+  const numVox3D = numSlices * numPixels2D
+  // preallocate to reduce heap usage
+  const brainOut = new Int32Array(numVox3D)
+  let offset = 0
+  for (let i = 0; i < numSlices; i++) {
+    brainOut.set(unstackOutVolumeTensor[i].dataSync(), offset)
+    offset += numPixels2D
+  }
+  for (let i = 0; i < numVox3D; i++) {
+    brainOut[i] = brainOut[i] !== 0 ? 1 : 0
+  }
+  if (isFinalImage || opts.showPhase1Output) {
+    // all done
+    callbackImg(brainOut, opts, modelEntry)
+    callbackUI('Segmentation finished', 0)
+  }
+  return tf.tensor(brainOut, [num_of_slices, slice_height, slice_width])
+}
+
+export async function generateOutputSlicesV2(
+  img,
+  OutVolumeTensorShape,
+  OutVolumeTensorType,
+  num_of_slices,
+  numSegClasses,
+  slice_height,
+  slice_width,
+  modelEntry,
+  opts,
+  niftiImage
+) {
+  // Convert all slices into 1 Dim array
+  if (opts.isPostProcessEnable) {
+    const BWInstance = new BWLabeler()
+    const dim = new Uint32Array(OutVolumeTensorShape)
+    const conn = 26 // Example connectivity
+    const binarize = true
+    const onlyLargestClusterPerClass = true
+    const [_labelCount, labeledImage] = BWInstance.bwlabel(img, dim, conn, binarize, onlyLargestClusterPerClass)
+    for (let i = 0; i < img.length; i++) {
+      img[i] *= labeledImage[i]
+    }
+  } // if isPostProcessEnable
+  const typedArrayConstructor = {
+    float32: Float32Array,
+    int32: Int32Array
+    // Add other cases as needed for different dtypes
+  }[OutVolumeTensorType]
+  // Create a new TypedArray from img with the same type as outLabelVolume
+  const allOutputSlices3DCC1DimArray = new Uint8Array(img)
+  switch (modelEntry.type) {
+    case 'Brain_Masking': {
+      const brainMask = new Uint8Array(allOutputSlices3DCC1DimArray.length)
+      for (let i = 0; i < allOutputSlices3DCC1DimArray.length; i++) {
+        brainMask[i] = allOutputSlices3DCC1DimArray[i] !== 0 ? 1 : 0
+      }
+      return brainMask
+    }
+    case 'Brain_Extraction': {
+      const maskedData = new Uint8Array(allOutputSlices3DCC1DimArray.length)
+      for (let i = 0; i < allOutputSlices3DCC1DimArray.length; i++) {
+        // Create the mask - 1 where the value is non-zero, 0 where it is zero.
+        const maskValue = allOutputSlices3DCC1DimArray[i] !== 0 ? 1 : 0
+        // Apply the mask to the data - multiply by the mask value.
+        maskedData[i] = niftiImage[i] * maskValue
+      }
+      return maskedData
+    }
+  }
+  return img
+}
+
+export async function getAllSlicesDataAsTF3D(num_of_slices, niftiHeader, niftiImage) {
+  // Get nifti dimensions
+  const cols = niftiHeader.dims[1] // Slice width
+  const rows = niftiHeader.dims[2] // Slice height
+  let typedData
+  if (niftiHeader.datatypeCode === 2) {
+    // enum from nvimage/utils DT_UINT8 = 2
+    typedData = new Uint8Array(niftiImage)
+  } else if (niftiHeader.datatypeCode === 4) {
+    // DT_INT16 = 4
+    typedData = new Int16Array(niftiImage)
+  } else if (niftiHeader.datatypeCode === 8) {
+    // DT_INT32 = 8
+    typedData = new Int32Array(niftiImage)
+  } else if (niftiHeader.datatypeCode === 16) {
+    // DT_FLOAT32 = 16
+    typedData = new Float32Array(niftiImage)
+  } else if (niftiHeader.datatypeCode === 64) {
+    // DT_FLOAT64 = 64
+    typedData = new Float64Array(niftiImage)
+  } else if (niftiHeader.datatypeCode === 256) {
+    // DT_INT8 = 256
+    typedData = new Int8Array(niftiImage)
+  } else if (niftiHeader.datatypeCode === 512) {
+    // DT_UINT16 = 512
+    typedData = new Uint16Array(niftiImage)
+  } else if (niftiHeader.datatypeCode === 768) {
+    // DT_UINT32 = 768
+    typedData = new Uint32Array(niftiImage)
+  } else {
+    return
+  }
+  const allSlices_2D = []
+  let offset3D = 0
+  // Draw pixels
+  for (let slice = 0; slice < num_of_slices; slice++) {
+    const slice = new Array(rows * cols)
+    let offset2D = 0
+    for (let row = 0; row < rows; row++) {
+      for (let col = 0; col < cols; col++) {
+        const value = typedData[offset3D++]
+        // Create 1Dim Array of pixel value, this 1 dim represents one channel
+        slice[offset2D++] = value & 0xff
+      }
+    }
+    allSlices_2D.push(tf.tensor(slice, [rows, cols])) // slice_height, slice_width
+  }
+  const allSlices_3D = tf.stack(allSlices_2D)
+  tf.dispose(allSlices_2D)
+  return allSlices_3D
+}
+
+export async function getModelNumLayers(modelObj) {
+  return modelObj.layers.length
+}
+
+export async function getModelNumParameters(modelObj) {
+  let numParameters = 0
+  for (let layerIdx = 0; layerIdx < modelObj.layers.length; layerIdx++) {
+    numParameters += modelObj.layers[layerIdx].countParams()
+  }
+  return numParameters
+}
+
+export async function isModelChnlLast(modelObj) {
+  for (let layerIdx = 0; layerIdx < modelObj.layers.length; layerIdx++) {
+    if (modelObj.layersByDepth[layerIdx][0].dataFormat) {
+      return modelObj.layersByDepth[layerIdx][0].dataFormat === 'channelsLast'
+    }
+  }
+}
+
+export async function load_model(modelUrl) {
+  return await tf.loadLayersModel(modelUrl)
+}
+
+export async function minMaxNormalizeVolumeData(volumeData) {
+  // Normalize the data to the range 0 - 1 using min-max scaling
+  const volumeData_Max = volumeData.max()
+  const volumeData_Min = volumeData.min()
+  const normalizedSlices_3d = await volumeData.sub(volumeData_Min).div(volumeData_Max.sub(volumeData_Min))
+  return normalizedSlices_3d
+}
+
+function processTensorInChunks(inputTensor, filterWeights, chunkSize) {
+  // Assuming inputTensor's shape: [batch, depth, height, width, inChannels]
+  // and filterWeights's shape: [filterDepth, filterHeight, filterWidth, inChannels, outChannels]
+  const stride = 1
+  const pad = 0
+  const dilationRate = 1
+  const inChannels = inputTensor.shape[4]
+  const numSlices = Math.ceil(inChannels / chunkSize)
+
+  let accumulatedResult = null
+  for (let i = 0; i < numSlices; i++) {
+    const startChannel = i * chunkSize
+    const endChannel = Math.min((i + 1) * chunkSize, inChannels)
+    const channels = endChannel - startChannel
+
+    const inputSlice = tf.tidy(() => {
+      // Slice the input tensor to get the current chunk
+      return inputTensor.slice([0, 0, 0, 0, startChannel], [-1, -1, -1, -1, channels])
+    })
+    const filterSlice = tf.tidy(() => {
+      // Slice the filter weights to match the input tensor's current chunk
+      return filterWeights.slice([0, 0, 0, startChannel, 0], [-1, -1, -1, channels, -1])
+    })
+
+    const resultSlice = tf.conv3d(inputSlice, filterSlice, stride, pad, 'NDHWC', dilationRate)
+    // Clean up the slices to free memory
+    inputSlice.dispose()
+    filterSlice.dispose()
+
+    // Squeeze the result slice to remove dimensions of size 1
+    const squeezedResultSlice = tf.squeeze(resultSlice)
+    resultSlice.dispose() // Dispose of the original resultSlice after squeezing
+
+    if (accumulatedResult === null) {
+      accumulatedResult = squeezedResultSlice
+    } else {
+      // Accumulate the result by adding the new result slice to it
+      const newAccumulatedResult = accumulatedResult.add(squeezedResultSlice)
+
+      // Dispose of the previous accumulatedResult and squeezedResultSlice
+      accumulatedResult.dispose()
+      // Dispose of squeezedResultSlice only if it wasn't assigned to accumulatedResult
+      if (accumulatedResult !== squeezedResultSlice) {
+        squeezedResultSlice.dispose()
+      }
+      // Update accumulatedResult with the new result
+      accumulatedResult = newAccumulatedResult
+    }
+
+    tf.tidy(() => {
+      tf.matMul(tf.zeros([1, 1]), tf.zeros([1, 1]))
+    })
+  }
+
+  return accumulatedResult
+}
+
+export async function quantileNormalizeVolumeData(tensor, lowerQuantile = 0.05, upperQuantile = 0.95) {
+  // Call calculateQuantiles and wait for the result
+  const { qmin, qmax } = await calculateQuantiles(tensor, lowerQuantile, upperQuantile)
+
+  // Convert qmin and qmax back to scalars
+  const qminScalar = tf.scalar(qmin)
+  const qmaxScalar = tf.scalar(qmax)
+
+  // Perform the operation: (tensor - qmin) / (qmax - qmin)
+  const resultTensor = tensor.sub(qminScalar).div(qmaxScalar.sub(qminScalar))
+
+  // Dispose of the created scalars to free memory
+  qminScalar.dispose()
+  qmaxScalar.dispose()
+
+  // Return the resulting tensor
+  return resultTensor
+}
+
+export async function removeZeroPaddingFrom3dTensor(tensor3d, rowPad = 1, colPad = 1, depthPad = 1) {
+  if (tensor3d.rank !== 3) {
+    throw new Error('Tensor must be 3D')
+  }
+  const [h, w, d] = tensor3d.shape
+  return tensor3d.slice([rowPad, colPad, depthPad], [h - 2 * rowPad, w - 2 * colPad, d - 2 * depthPad])
+}
+
+export async function resizeWithZeroPadding(croppedTensor3d, newDepth, newHeight, newWidth, refVoxel, boundVolSizeArr) {
+  const row_pad_befor = refVoxel[0]
+  const col_pad_befor = refVoxel[1]
+  const depth_pad_befor = refVoxel[2]
+  // last and lower volume voxel
+  const row_max = row_pad_befor + boundVolSizeArr[0] - 1 // size [2, 2, 2] means 2 voxels total in each dim
+  const col_max = col_pad_befor + boundVolSizeArr[1] - 1
+  const depth_max = depth_pad_befor + boundVolSizeArr[2] - 1
+
+  const row_pad_after = newHeight - row_max - 1 > 0 ? newHeight - row_max - 1 : 0
+  const col_pad_after = newWidth - col_max - 1 > 0 ? newWidth - col_max - 1 : 0
+  const depth_pad_after = newDepth - depth_max - 1 > 0 ? newDepth - depth_max - 1 : 0
+
+  return croppedTensor3d.pad([
+    [row_pad_befor, row_pad_after],
+    [col_pad_befor, col_pad_after],
+    [depth_pad_befor, depth_pad_after]
+  ])
+}
+
+export class SequentialConvLayer {
+  constructor(model, chunkSize, isChannelLast, callbackUI, isWebWorker = true) {
+    this.model = model
+    this.outChannels = model.outputLayers[0].kernel.shape[4]
+    this.chunkSize = chunkSize
+    this.isChannelLast = isChannelLast
+    this.callbackUI = callbackUI
+    this.isWebWorker = isWebWorker
+  }
+
+  /**
+   * Apply sequential convolution layer
+   * @since 3.0.0
+   * @member SequentialConvLayer
+   * @param {tf.Tensor}  inputTensor  e.g.  [ 1, 256, 256, 256, 5 ]
+   * @return {outC}
+   */
+
+  async apply(inputTensor) {
+    const oldDeleteTextureThreshold = tf.ENV.get('WEBGL_DELETE_TEXTURE_THRESHOLD')
+    tf.ENV.set('WEBGL_DELETE_TEXTURE_THRESHOLD', 0)
+
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this
+    // Important to avoid "undefined" class var members inside the timer.
+    // "this" has another meaning inside the timer.
+
+    // document.getElementById("progressBarChild").parentElement.style.visibility = "visible"
+    const startTime = performance.now()
+
+    const convLayer = self.model.layers[self.model.layers.length - 1]
+    const weights = convLayer.getWeights()[0] //
+    const biases = convLayer.getWeights()[1]
+    const outputShape = self.isChannelLast ? inputTensor.shape.slice(1, -1) : inputTensor.shape.slice(2)
+    // -- e.g.  outputShape : [256,256,256] or cropped Dim
+    // -- if inputTensor [ 1, D, H, W, 50 ], channelLast true ->   outputShape : outputShape [D, H, W]
+    // -- if inputTensor [ 1, 50, D, H, W ], channelLast false ->   outputShape : outputShape [D, H, W]
+
+    let outB = tf.mul(tf.ones(outputShape), -10000)
+    // -- e.g. outB.shape  [256,256,256]
+    let outC = tf.zeros(outputShape)
+    // -- e.g. outC.shape  [256,256,256]
+    let chIdx = 0
+
+    // console.log("---------------------------------------------------------")
+    console.log(' channel loop')
+
+    while (true) {
+      tf.engine().startScope() // Start TensorFlow.js scope
+      /* console.log('=======================')
+      const memoryInfo0 = await tf.memory()
+      console.log(`| Number of Tensors: ${memoryInfo0.numTensors}`)
+      console.log(`| Number of Data Buffers: ${memoryInfo0.numDataBuffers}`) */
+
+      const result = await tf.tidy(() => {
+        const filterWeights = weights.slice([0, 0, 0, 0, chIdx], [-1, -1, -1, -1, 1])
+        // -- e.g. filterWeights.shape [ 1, 1, 1, 5, 1 ]
+        const filterBiases = biases.slice([chIdx], [1])
+        // -- e.g. filterBiases.shape [1] -> Tensor  [-0.7850812]
+        const outA = processTensorInChunks(inputTensor, filterWeights, Math.min(self.chunkSize, self.outChannels)).add(
+          filterBiases
+        )
+        const greater = tf.greater(outA, outB)
+        const newoutB = tf.where(greater, outA, outB)
+        const newoutC = tf.where(greater, tf.fill(outC.shape, chIdx), outC)
+        // Dispose the old tensors before reassigning
+        tf.dispose([outB, outC, filterWeights, filterBiases, outA, greater])
+        // Dummy operation to trigger cleanup
+        tf.tidy(() => tf.matMul(tf.ones([1, 1]), tf.ones([1, 1])))
+        return [newoutC, newoutB]
+      })
+      console.log('=======================')
+      self.callbackUI(`Iteration ${chIdx}`, chIdx / self.outChannels)
+      if (!self.isWebWorker) {
+        // allow user interface to refresh
+        await new Promise((resolve) => setTimeout(resolve, 17))
+      }
+      const memoryInfo = await tf.memory()
+      console.log(`Number of Tensors: ${memoryInfo.numTensors}`)
+      console.log(`Number of Data Buffers: ${memoryInfo.numDataBuffers}`)
+      console.log(`Megabytes In Use: ${(memoryInfo.numBytes / 1048576).toFixed(3)} MB`)
+      if (memoryInfo.unreliable) {
+        console.log(`Unreliable: ${memoryInfo.unreliable}`)
+      }
+      // Dispose of previous values before assigning new tensors to outC and outB
+      if (typeof outC !== 'undefined') {
+        outC.dispose()
+      }
+      if (typeof outB !== 'undefined') {
+        outB.dispose()
+      }
+      // Assign the new values to outC and outB
+      outC = tf.keep(result[0])
+      outB = tf.keep(result[1])
+      // // Assign the new values to outC and outB
+      // outC = result[0]
+      // outB = result[1]
+      tf.engine().endScope()
+
+      if (chIdx === self.outChannels - 1) {
+        // document.getElementById("progressBarChild").style.width = 0 + "%"
+        tf.dispose(outB)
+        const endTime = performance.now()
+        const executionTime = endTime - startTime
+        console.log(`Execution time for output layer: ${executionTime} milliseconds`)
+        tf.ENV.set('WEBGL_DELETE_TEXTURE_THRESHOLD', oldDeleteTextureThreshold)
+        return outC
+      } else {
+        chIdx++
+
+        // the seemingly strange sequence of operations
+        // below prevents tfjs from uncontrolably
+        // grabbing buffers, even when all tensors have
+        // already been disposed
+
+        const outCShape = outC.shape
+        const outCdata = outC.dataSync()
+        const outBShape = outC.shape
+        const outBdata = outB.dataSync()
+        outC.dispose()
+        outB.dispose()
+        // tf.disposeVariables()
+        outC = tf.tensor(outCdata, outCShape)
+        outB = tf.tensor(outBdata, outBShape)
+
+        // document.getElementById("progressBarChild").style.width = (chIdx + 1) * 100 / self.outChannels + "%"
+      }
+    }
+  }
+} // <<<< End of class

vite.config.js

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vite'
+
+export default defineConfig({
+  root: '.',
+  base: '/niivue-tinygrad/',
+  server: {
+    open: 'index.html',
+  },
+})