@niivue/niivue 0.52.0 → 0.53.0

package/build/index.js

@@ -14,10 +14,10 @@ var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 
 // src/niivue/index.ts
-import { mat4 as mat46, vec2, vec3 as vec311, vec4 as vec48 } from "gl-matrix";
+import { mat4 as mat49, vec2, vec3 as vec314, vec4 as vec49 } from "gl-matrix";
 
 // package.json
-var version = "0.52.0";
+var version = "0.53.0";
 
 // src/logger.ts
 var _Log = class _Log {
@@ -1161,7 +1161,7 @@ void main(void) {
 	//https://stackoverflow.com/questions/5879403/opengl-texture-coordinates-in-pixel-space
 	float nlayer = float(textureSize(colormap, 0).y);
 	//each volume has two color maps:
-	// (layer*2) = negative and (layer * 2) + 1 = postive
+	// (layer*2) = negative and (layer * 2) + 1 = positive
 	float y = ((2.0 * layer) + 1.5)/nlayer;
 	FragColor = texture(colormap, vec2(txl, y)).rgba;
 	//negative colors
@@ -3377,10 +3377,10 @@ __publicField(_NiivueObject3D, "makeCylinder", function(vertices, indices, start
   const idx0 = Math.floor(vertices.length / 3);
   const idx = new Uint32Array(num_f * 3);
   const vtx = new Float32Array(num_v * 3);
-  function setV(i, vec312) {
-    vtx[i * 3 + 0] = vec312[0];
-    vtx[i * 3 + 1] = vec312[1];
-    vtx[i * 3 + 2] = vec312[2];
+  function setV(i, vec315) {
+    vtx[i * 3 + 0] = vec315[0];
+    vtx[i * 3 + 1] = vec315[1];
+    vtx[i * 3 + 2] = vec315[2];
   }
   function setI(i, a, b, c) {
     idx[i * 3 + 0] = a + idx0;
@@ -3448,7 +3448,7 @@ __publicField(_NiivueObject3D, "makeColoredSphere", function(vertices, indices,
 var NiivueObject3D = _NiivueObject3D;
 
 // src/nvmesh.ts
-import { vec3 as vec38, vec4 as vec46 } from "gl-matrix";
+import { vec3 as vec310, vec4 as vec47 } from "gl-matrix";
 import { v4 as uuidv42 } from "@lukeed/uuid";
 
 // src/cmaps/index.js
@@ -11984,7 +11984,7 @@ var NVUtilities = class _NVUtilities {
     const decompressed = await _NVUtilities.decompress(data);
     return decompressed.buffer.slice(decompressed.byteOffset, decompressed.byteOffset + decompressed.byteLength);
   }
-  static async readMatV4(buffer) {
+  static async readMatV4(buffer, isReplaceDots = false) {
     let len = buffer.byteLength;
     if (len < 40) {
       throw new Error("File too small to be MAT v4: bytes = " + buffer.byteLength);
@@ -12040,7 +12040,10 @@ var NVUtilities = class _NVUtilities {
         throw new Error("mrows * ncols must be greater than one");
       }
       const byteArray = new Uint8Array(bytes.subarray(pos, pos + namlen));
-      const tagName = textDecoder.decode(byteArray).trim().replaceAll("\0", "");
+      let tagName = textDecoder.decode(byteArray).trim().replaceAll("\0", "");
+      if (isReplaceDots) {
+        tagName = tagName.replaceAll(".", "_");
+      }
       const tagDataType = getTensDigit(mtype);
       let tagBytesPerItem = 8;
       if (tagDataType >= 1 && tagDataType <= 2) {
@@ -15726,18 +15729,11 @@ var NVMeshLoaders = class _NVMeshLoaders {
 
 // src/nvdocument.ts
 import { serialize, deserialize } from "@ungap/structured-clone";
-import { vec3 as vec37, vec4 as vec45 } from "gl-matrix";
+import { vec3 as vec39, vec4 as vec46 } from "gl-matrix";
 
 // src/nvimage/index.ts
-import {
-  NIFTI1,
-  NIFTIEXTENSION,
-  isCompressed,
-  decompressAsync,
-  readImage,
-  readHeaderAsync
-} from "nifti-reader-js";
-import { mat3, mat4 as mat44, vec3 as vec36, vec4 as vec44 } from "gl-matrix";
+import { NIFTI1 as NIFTI14, NIFTIEXTENSION, readHeaderAsync as readHeaderAsync2 } from "nifti-reader-js";
+import { mat3 as mat32, mat4 as mat46, vec3 as vec38, vec4 as vec45 } from "gl-matrix";
 import { v4 as uuidv4 } from "@lukeed/uuid";
 import { Gunzip } from "fflate";
 
@@ -15769,6 +15765,9 @@ var ImageType = /* @__PURE__ */ ((ImageType3) => {
   ImageType3[ImageType3["SRC"] = 17] = "SRC";
   ImageType3[ImageType3["FIB"] = 18] = "FIB";
   ImageType3[ImageType3["BMP"] = 19] = "BMP";
+  ImageType3[ImageType3["ZARR"] = 20] = "ZARR";
+  ImageType3[ImageType3["NPY"] = 21] = "NPY";
+  ImageType3[ImageType3["NPZ"] = 22] = "NPZ";
   return ImageType3;
 })(ImageType || {});
 var NVIMAGE_TYPE = Object.freeze({
@@ -15783,6 +15782,9 @@ var NVIMAGE_TYPE = Object.freeze({
       case "TXT":
         imageType = 3 /* DCM_MANIFEST */;
         break;
+      case "FZ":
+      case "GQI":
+      case "QSDR":
       case "FIB":
         imageType = 18 /* FIB */;
         break;
@@ -15813,6 +15815,12 @@ var NVIMAGE_TYPE = Object.freeze({
       case "MGZ":
         imageType = 11 /* MGZ */;
         break;
+      case "NPY":
+        imageType = 21 /* NPY */;
+        break;
+      case "NPZ":
+        imageType = 22 /* NPZ */;
+        break;
       case "SRC":
         imageType = 17 /* SRC */;
         break;
@@ -15835,6 +15843,9 @@ var NVIMAGE_TYPE = Object.freeze({
       case "JPEG":
         imageType = 19 /* BMP */;
         break;
+      case "ZARR":
+        imageType = 20 /* ZARR */;
+        break;
     }
     return imageType;
   }
@@ -16073,6 +16084,882 @@ async function uncompressStream(stream) {
   return uncompressedStream;
 }
 
+// src/nvimage/ImageWriter.ts
+import { NIFTI1 } from "nifti-reader-js";
+function createNiftiHeader(dims = [256, 256, 256], pixDims = [1, 1, 1], affine = [1, 0, 0, -128, 0, 1, 0, -128, 0, 0, 1, -128, 0, 0, 0, 1], datatypeCode = 2 /* DT_UINT8 */) {
+  const hdr = new NIFTI1();
+  hdr.littleEndian = true;
+  hdr.dims = [3, 1, 1, 1, 0, 0, 0, 0];
+  hdr.dims[0] = Math.max(3, dims.length);
+  for (let i = 0; i < dims.length; i++) {
+    hdr.dims[i + 1] = dims[i];
+  }
+  hdr.pixDims = [1, 1, 1, 1, 1, 0, 0, 0];
+  for (let i = 0; i < dims.length; i++) {
+    hdr.pixDims[i + 1] = pixDims[i];
+  }
+  if (affine.length === 16) {
+    let k = 0;
+    for (let i = 0; i < 4; i++) {
+      for (let j = 0; j < 4; j++) {
+        hdr.affine[i][j] = affine[k];
+        k++;
+      }
+    }
+  }
+  let bpv = 8;
+  if (datatypeCode === 256 /* DT_INT8 */ || datatypeCode === 2 /* DT_UINT8 */) {
+    bpv = 8;
+  } else if (datatypeCode === 512 /* DT_UINT16 */ || datatypeCode === 4 /* DT_INT16 */) {
+    bpv = 16;
+  } else if (datatypeCode === 16 /* DT_FLOAT32 */ || datatypeCode === 768 /* DT_UINT32 */ || datatypeCode === 8 /* DT_INT32 */ || datatypeCode === 2304 /* DT_RGBA32 */) {
+    bpv = 32;
+  } else if (datatypeCode === 64 /* DT_FLOAT64 */) {
+    bpv = 64;
+  } else {
+    log.warn("Unsupported NIfTI datatypeCode for header creation: " + datatypeCode);
+  }
+  hdr.datatypeCode = datatypeCode;
+  hdr.numBitsPerVoxel = bpv;
+  hdr.scl_inter = 0;
+  hdr.scl_slope = 1;
+  hdr.sform_code = 2;
+  hdr.magic = "n+1";
+  hdr.vox_offset = 352;
+  return hdr;
+}
+function createNiftiArray(dims = [256, 256, 256], pixDims = [1, 1, 1], affine = [1, 0, 0, -128, 0, 1, 0, -128, 0, 0, 1, -128, 0, 0, 0, 1], datatypeCode = 2 /* DT_UINT8 */, img = new Uint8Array()) {
+  const hdr = createNiftiHeader(dims, pixDims, affine, datatypeCode);
+  const hdrBytes = hdrToArrayBuffer(hdr, false);
+  hdr.vox_offset = Math.max(352, hdrBytes.length);
+  const finalHdrBytes = hdrToArrayBuffer(hdr, false);
+  if (img.length < 1) {
+    return finalHdrBytes;
+  }
+  const paddingSize = Math.max(0, hdr.vox_offset - finalHdrBytes.length);
+  const padding = new Uint8Array(paddingSize);
+  const imgBytes = new Uint8Array(img.buffer, img.byteOffset, img.byteLength);
+  const totalLength = hdr.vox_offset + imgBytes.length;
+  const outputData = new Uint8Array(totalLength);
+  outputData.set(finalHdrBytes, 0);
+  outputData.set(padding, finalHdrBytes.length);
+  outputData.set(imgBytes, hdr.vox_offset);
+  return outputData;
+}
+function toUint8Array(nvImage, drawingBytes = null) {
+  if (!nvImage.hdr) {
+    throw new Error("NVImage header is not defined for toUint8Array");
+  }
+  if (!nvImage.img && drawingBytes === null) {
+    throw new Error("NVImage image data is not defined for toUint8Array");
+  }
+  const isDrawing = drawingBytes !== null;
+  const hdrCopy = JSON.parse(JSON.stringify(nvImage.hdr));
+  hdrCopy.vox_offset = Math.max(352, hdrCopy.vox_offset);
+  if (isDrawing) {
+    hdrCopy.datatypeCode = 2 /* DT_UINT8 */;
+    hdrCopy.numBitsPerVoxel = 8;
+    hdrCopy.scl_slope = 1;
+    hdrCopy.scl_inter = 0;
+  }
+  const hdrBytes = hdrToArrayBuffer(hdrCopy, isDrawing);
+  let imageBytesToSave;
+  if (isDrawing) {
+    const drawingBytesCurrent = drawingBytes;
+    const perm = nvImage.permRAS;
+    if (perm && (perm[0] !== 1 || perm[1] !== 2 || perm[2] !== 3)) {
+      log.debug("Reorienting drawing bytes back to native space for saving...");
+      const dims = nvImage.hdr.dims;
+      const nVox = dims[1] * dims[2] * dims[3];
+      const nVoxRAS = nvImage.dimsRAS ? nvImage.dimsRAS[1] * nvImage.dimsRAS[2] * nvImage.dimsRAS[3] : nVox;
+      if (drawingBytesCurrent.length !== nVoxRAS) {
+        console.warn(
+          `Drawing length (${drawingBytesCurrent.length}) does not match expected RAS voxel count (${nVoxRAS}). Cannot reorient drawing reliably.`
+        );
+        imageBytesToSave = drawingBytesCurrent;
+      } else if (!nvImage.img2RASstep || !nvImage.img2RASstart || !nvImage.dimsRAS) {
+        console.warn(
+          `Missing RAS transformation info (img2RASstep, img2RASstart, dimsRAS). Cannot reorient drawing reliably.`
+        );
+        imageBytesToSave = drawingBytesCurrent;
+      } else {
+        const step = nvImage.img2RASstep;
+        const start = nvImage.img2RASstart;
+        const dimsRAS = nvImage.dimsRAS;
+        const nativeData = new Uint8Array(nVox);
+        nativeData.fill(0);
+        const inputDrawingRAS = drawingBytesCurrent;
+        let rasIndex = 0;
+        for (let rz = 0; rz < dimsRAS[3]; rz++) {
+          const zi = start[2] + rz * step[2];
+          for (let ry = 0; ry < dimsRAS[2]; ry++) {
+            const yi = start[1] + ry * step[1];
+            for (let rx = 0; rx < dimsRAS[1]; rx++) {
+              const xi = start[0] + rx * step[0];
+              const nativeIndex = xi + yi + zi;
+              if (nativeIndex >= 0 && nativeIndex < nVox) {
+                nativeData[nativeIndex] = inputDrawingRAS[rasIndex];
+              } else if (rasIndex < inputDrawingRAS.length) {
+                console.warn(
+                  `Calculated native index ${nativeIndex} is out of bounds [0..${nVox - 1}] during drawing reorientation.`
+                );
+              }
+              rasIndex++;
+            }
+          }
+        }
+        imageBytesToSave = nativeData;
+      }
+    } else {
+      imageBytesToSave = drawingBytesCurrent;
+    }
+  } else {
+    if (!nvImage.img) {
+      throw new Error("NVImage image data is null when trying to save non-drawing.");
+    }
+    imageBytesToSave = new Uint8Array(nvImage.img.buffer, nvImage.img.byteOffset, nvImage.img.byteLength);
+  }
+  const headerSize = hdrBytes.length;
+  const paddingSize = Math.max(0, hdrCopy.vox_offset - headerSize);
+  const padding = new Uint8Array(paddingSize);
+  const totalLength = hdrCopy.vox_offset + imageBytesToSave.length;
+  const outputData = new Uint8Array(totalLength);
+  outputData.set(hdrBytes, 0);
+  outputData.set(padding, headerSize);
+  outputData.set(imageBytesToSave, hdrCopy.vox_offset);
+  return outputData;
+}
+async function saveToUint8Array(nvImage, fnm, drawing8 = null) {
+  const odata = toUint8Array(nvImage, drawing8);
+  const compress = fnm.toLowerCase().endsWith(".gz");
+  if (compress) {
+    try {
+      const compressedData = await NVUtilities.compress(odata, "gzip");
+      return new Uint8Array(compressedData);
+    } catch (error) {
+      log.error("Compression failed:", error);
+      log.warn("Returning uncompressed data due to compression error.");
+      return odata;
+    }
+  } else {
+    return odata;
+  }
+}
+async function saveToDisk(nvImage, fnm = "", drawing8 = null) {
+  const saveData = await saveToUint8Array(nvImage, fnm, drawing8);
+  if (!fnm) {
+    log.debug("saveToDisk: empty file name, returning data as Uint8Array rather than triggering download");
+    return saveData;
+  }
+  try {
+    const blob = new Blob([saveData.buffer], {
+      type: "application/octet-stream"
+      // Standard type for binary download
+    });
+    const blobUrl = URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.setAttribute("href", blobUrl);
+    link.setAttribute("download", fnm);
+    link.style.visibility = "hidden";
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    setTimeout(() => URL.revokeObjectURL(blobUrl), 100);
+  } catch (e) {
+    log.error("Failed to trigger download:", e);
+  }
+  return saveData;
+}
+
+// src/nvimage/VolumeUtils.ts
+function getValue(nvImage, x, y, z, frame4D = 0, isReadImaginary = false) {
+  if (!nvImage.hdr) {
+    throw new Error("getValue: NVImage header is not defined.");
+  }
+  if (!isReadImaginary && !nvImage.img) {
+    throw new Error("getValue: NVImage image data is not defined.");
+  }
+  if (isReadImaginary && !nvImage.imaginary) {
+    log.warn("getValue: Attempted to read imaginary data, but none exists.");
+    return 0;
+  }
+  const nx = nvImage.hdr.dims[1];
+  const ny = nvImage.hdr.dims[2];
+  const nz = nvImage.hdr.dims[3];
+  x = Math.max(0, Math.min(Math.round(x), nx - 1));
+  y = Math.max(0, Math.min(Math.round(y), ny - 1));
+  z = Math.max(0, Math.min(Math.round(z), nz - 1));
+  frame4D = Math.max(0, frame4D);
+  let vx = x + y * nx + z * nx * ny;
+  if (nvImage.hdr.datatypeCode === 2304 /* DT_RGBA32 */) {
+    if (!nvImage.img) {
+      return 0;
+    }
+    vx *= 4;
+    if (vx + 2 >= nvImage.img.length) {
+      log.warn(`getValue: Calculated index ${vx} out of bounds for RGBA data.`);
+      return 0;
+    }
+    const lum = nvImage.img[vx] * 0.2126 + nvImage.img[vx + 1] * 0.7152 + nvImage.img[vx + 2] * 0.0722;
+    return Math.round(lum);
+  }
+  if (nvImage.hdr.datatypeCode === 128 /* DT_RGB24 */) {
+    if (!nvImage.img) {
+      return 0;
+    }
+    vx *= 3;
+    if (vx + 2 >= nvImage.img.length) {
+      log.warn(`getValue: Calculated index ${vx} out of bounds for RGB data.`);
+      return 0;
+    }
+    const lum = nvImage.img[vx] * 0.2126 + nvImage.img[vx + 1] * 0.7152 + nvImage.img[vx + 2] * 0.0722;
+    return Math.round(lum);
+  }
+  const nVox3D = nx * ny * nz;
+  const volOffset = frame4D * nVox3D;
+  const finalVxIndex = vx + volOffset;
+  const dataArray = isReadImaginary ? nvImage.imaginary : nvImage.img;
+  if (finalVxIndex < 0 || finalVxIndex >= dataArray.length) {
+    return 0;
+  }
+  const rawValue = dataArray[finalVxIndex];
+  const slope = isNaN(nvImage.hdr.scl_slope) || nvImage.hdr.scl_slope === 0 ? 1 : nvImage.hdr.scl_slope;
+  const inter = isNaN(nvImage.hdr.scl_inter) ? 0 : nvImage.hdr.scl_inter;
+  return slope * rawValue + inter;
+}
+function getVolumeData(nvImage, voxStartRAS = [-1, 0, 0], voxEndRAS = [0, 0, 0], dataType = "same") {
+  const defaultResult = [new Uint8Array(), [0, 0, 0]];
+  if (!nvImage.hdr || !nvImage.img || !nvImage.dimsRAS || !nvImage.img2RASstep || !nvImage.img2RASstart) {
+    log.error("getVolumeData: Missing required NVImage properties (hdr, img, dimsRAS, img2RASstep/start).");
+    return defaultResult;
+  }
+  voxStartRAS = voxStartRAS.slice(0, 3);
+  voxEndRAS = voxEndRAS.slice(0, 3);
+  if (Math.min(...voxStartRAS) < 0 || Math.min(...voxEndRAS) < 0) {
+    log.warn("getVolumeData: Invalid start or end coordinates provided.");
+    return defaultResult;
+  }
+  const dimsRAS = nvImage.dimsRAS.slice(1, 4);
+  for (let i = 0; i < 3; i++) {
+    voxStartRAS[i] = Math.max(0, Math.min(Math.round(voxStartRAS[i]), dimsRAS[i] - 1));
+    voxEndRAS[i] = Math.max(0, Math.min(Math.round(voxEndRAS[i]), dimsRAS[i] - 1));
+    if (voxEndRAS[i] < voxStartRAS[i]) {
+      const tmp = voxEndRAS[i];
+      voxEndRAS[i] = voxStartRAS[i];
+      voxStartRAS[i] = tmp;
+    }
+  }
+  const slabDims = [
+    voxEndRAS[0] - voxStartRAS[0] + 1,
+    voxEndRAS[1] - voxStartRAS[1] + 1,
+    voxEndRAS[2] - voxStartRAS[2] + 1
+  ];
+  const slabNVox = slabDims[0] * slabDims[1] * slabDims[2];
+  if (slabNVox <= 0) {
+    log.warn("getVolumeData: Calculated slab size is zero or negative.");
+    return defaultResult;
+  }
+  let OutputArrayConstructor = nvImage.img.constructor;
+  if (dataType === "uint8") {
+    OutputArrayConstructor = Uint8Array;
+  } else if (dataType === "int16") {
+    OutputArrayConstructor = Int16Array;
+  } else if (dataType === "uint16") {
+    OutputArrayConstructor = Uint16Array;
+  } else if (dataType === "float32" || dataType === "scaled" || dataType === "normalized" || dataType === "windowed") {
+    OutputArrayConstructor = Float32Array;
+  } else if (dataType === "float64") {
+    OutputArrayConstructor = Float64Array;
+  } else if (dataType !== "same") {
+    log.warn(`getVolumeData: Unsupported dataType '${dataType}'. Using 'same'.`);
+  }
+  let outputImg;
+  try {
+    outputImg = new OutputArrayConstructor(slabNVox);
+  } catch (e) {
+    log.error(`getVolumeData: Failed to create output array for dataType '${dataType}'.`, e);
+    return defaultResult;
+  }
+  const step = nvImage.img2RASstep;
+  const start = nvImage.img2RASstart;
+  const sourceImg = nvImage.img;
+  let outputIndex = 0;
+  for (let rz = voxStartRAS[2]; rz <= voxEndRAS[2]; rz++) {
+    const zi = start[2] + rz * step[2];
+    for (let ry = voxStartRAS[1]; ry <= voxEndRAS[1]; ry++) {
+      const yi = start[1] + ry * step[1];
+      for (let rx = voxStartRAS[0]; rx <= voxEndRAS[0]; rx++) {
+        const xi = start[0] + rx * step[0];
+        const nativeIndex = xi + yi + zi;
+        let value = 0;
+        if (nativeIndex >= 0 && nativeIndex < sourceImg.length) {
+          value = sourceImg[nativeIndex];
+        } else {
+        }
+        outputImg[outputIndex++] = value;
+      }
+    }
+  }
+  const slope = isNaN(nvImage.hdr.scl_slope) || nvImage.hdr.scl_slope === 0 ? 1 : nvImage.hdr.scl_slope;
+  const inter = isNaN(nvImage.hdr.scl_inter) ? 0 : nvImage.hdr.scl_inter;
+  if (dataType === "scaled" || dataType === "normalized" || dataType === "windowed") {
+    if (!(outputImg instanceof Float32Array)) {
+      log.warn(`getVolumeData: Converting output to Float32 for scaling type '${dataType}'.`);
+      outputImg = Float32Array.from(outputImg);
+    }
+    for (let i = 0; i < outputImg.length; i++) {
+      outputImg[i] = outputImg[i] * slope + inter;
+    }
+  }
+  if (dataType === "normalized" || dataType === "windowed") {
+    let minVal = nvImage.cal_min;
+    let maxVal = nvImage.cal_max;
+    if (dataType === "normalized") {
+      minVal = nvImage.global_min;
+      maxVal = nvImage.global_max;
+    }
+    const range = maxVal - minVal;
+    const scale = range === 0 ? 0 : 1 / range;
+    for (let i = 0; i < outputImg.length; i++) {
+      outputImg[i] = (outputImg[i] - minVal) * scale;
+      outputImg[i] = Math.max(0, Math.min(outputImg[i], 1));
+    }
+  }
+  return [outputImg, slabDims];
+}
+function setVolumeData(nvImage, voxStartRAS = [-1, 0, 0], voxEndRAS = [0, 0, 0], slabData = new Uint8Array()) {
+  if (!nvImage.hdr || !nvImage.img || !nvImage.dimsRAS || !nvImage.img2RASstep || !nvImage.img2RASstart) {
+    log.error("setVolumeData: Missing required NVImage properties (hdr, img, dimsRAS, img2RASstep/start).");
+    return;
+  }
+  if (slabData.length < 1) {
+    log.warn("setVolumeData: Input slabData is empty.");
+    return;
+  }
+  voxStartRAS = voxStartRAS.slice(0, 3);
+  voxEndRAS = voxEndRAS.slice(0, 3);
+  if (Math.min(...voxStartRAS) < 0 || Math.min(...voxEndRAS) < 0) {
+    log.warn("setVolumeData: Invalid start or end coordinates provided.");
+    return;
+  }
+  const dimsRAS = nvImage.dimsRAS.slice(1, 4);
+  for (let i = 0; i < 3; i++) {
+    voxStartRAS[i] = Math.max(0, Math.min(Math.round(voxStartRAS[i]), dimsRAS[i] - 1));
+    voxEndRAS[i] = Math.max(0, Math.min(Math.round(voxEndRAS[i]), dimsRAS[i] - 1));
+    if (voxEndRAS[i] < voxStartRAS[i]) {
+      const tmp = voxEndRAS[i];
+      voxEndRAS[i] = voxStartRAS[i];
+      voxStartRAS[i] = tmp;
+    }
+  }
+  const slabDims = [
+    voxEndRAS[0] - voxStartRAS[0] + 1,
+    voxEndRAS[1] - voxStartRAS[1] + 1,
+    voxEndRAS[2] - voxStartRAS[2] + 1
+  ];
+  const slabNVox = slabDims[0] * slabDims[1] * slabDims[2];
+  if (slabNVox <= 0) {
+    log.warn("setVolumeData: Calculated slab size is zero or negative.");
+    return;
+  }
+  if (slabData.length < slabNVox) {
+    log.error(
+      `setVolumeData: Input slabData length (${slabData.length}) is less than the calculated slab size (${slabNVox}).`
+    );
+    return;
+  }
+  const step = nvImage.img2RASstep;
+  const start = nvImage.img2RASstart;
+  const targetImg = nvImage.img;
+  let sourceIndex = 0;
+  for (let rz = voxStartRAS[2]; rz <= voxEndRAS[2]; rz++) {
+    const zi = start[2] + rz * step[2];
+    for (let ry = voxStartRAS[1]; ry <= voxEndRAS[1]; ry++) {
+      const yi = start[1] + ry * step[1];
+      for (let rx = voxStartRAS[0]; rx <= voxEndRAS[0]; rx++) {
+        const xi = start[0] + rx * step[0];
+        const nativeIndex = xi + yi + zi;
+        if (nativeIndex >= 0 && nativeIndex < targetImg.length) {
+          targetImg[nativeIndex] = slabData[sourceIndex];
+        } else {
+        }
+        sourceIndex++;
+      }
+    }
+  }
+}
+
+// src/nvimage/ImageReaders/mgh.ts
+var mgh_exports = {};
+__export(mgh_exports, {
+  readMgh: () => readMgh
+});
+import { NIFTI1 as NIFTI12 } from "nifti-reader-js";
+import { mat4 as mat44, vec4 as vec44, vec3 as vec36 } from "gl-matrix";
+async function readMgh(nvImage, buffer) {
+  if (!nvImage.hdr) {
+    log.warn("readMgh called before nvImage.hdr was initialized. Creating default.");
+    nvImage.hdr = new NIFTI12();
+  }
+  const hdr = nvImage.hdr;
+  hdr.littleEndian = false;
+  let raw = buffer;
+  let reader = new DataView(raw);
+  if (raw.byteLength >= 2 && reader.getUint8(0) === 31 && reader.getUint8(1) === 139) {
+    try {
+      raw = await NVUtilities.decompressToBuffer(new Uint8Array(buffer));
+      reader = new DataView(raw);
+    } catch (err) {
+      log.error("Failed to decompress MGZ file.", err);
+      return null;
+    }
+  }
+  if (raw.byteLength < 284) {
+    log.error("File too small to be a valid MGH/MGZ header.");
+    return null;
+  }
+  const version2 = reader.getInt32(0, false);
+  const width = reader.getInt32(4, false);
+  const height = reader.getInt32(8, false);
+  const depth = reader.getInt32(12, false);
+  const nframes = reader.getInt32(16, false);
+  const mtype = reader.getInt32(20, false);
+  const spacingX = reader.getFloat32(30, false);
+  const spacingY = reader.getFloat32(34, false);
+  const spacingZ = reader.getFloat32(38, false);
+  const xr = reader.getFloat32(42, false);
+  const xa = reader.getFloat32(46, false);
+  const xs = reader.getFloat32(50, false);
+  const yr = reader.getFloat32(54, false);
+  const ya = reader.getFloat32(58, false);
+  const ys = reader.getFloat32(62, false);
+  const zr = reader.getFloat32(66, false);
+  const za = reader.getFloat32(70, false);
+  const zs = reader.getFloat32(74, false);
+  const cr = reader.getFloat32(78, false);
+  const ca = reader.getFloat32(82, false);
+  const cs = reader.getFloat32(86, false);
+  if (version2 !== 1) {
+    log.warn(`Unexpected MGH version: ${version2}.`);
+  }
+  if (width <= 0 || height <= 0 || depth <= 0) {
+    log.error(`Invalid MGH dimensions: ${width}x${height}x${depth}`);
+    return null;
+  }
+  switch (mtype) {
+    case 0:
+      hdr.numBitsPerVoxel = 8;
+      hdr.datatypeCode = 2 /* DT_UINT8 */;
+      break;
+    case 4:
+      hdr.numBitsPerVoxel = 16;
+      hdr.datatypeCode = 4 /* DT_INT16 */;
+      break;
+    case 1:
+      hdr.numBitsPerVoxel = 32;
+      hdr.datatypeCode = 8 /* DT_INT32 */;
+      break;
+    case 3:
+      hdr.numBitsPerVoxel = 32;
+      hdr.datatypeCode = 16 /* DT_FLOAT32 */;
+      break;
+    default:
+      log.error(`Unsupported MGH data type: ${mtype}`);
+      return null;
+  }
+  hdr.dims[1] = width;
+  hdr.dims[2] = height;
+  hdr.dims[3] = depth;
+  hdr.dims[4] = Math.max(1, nframes);
+  hdr.dims[0] = hdr.dims[4] > 1 ? 4 : 3;
+  hdr.pixDims[1] = Math.abs(spacingX);
+  hdr.pixDims[2] = Math.abs(spacingY);
+  hdr.pixDims[3] = Math.abs(spacingZ);
+  hdr.pixDims[4] = 0;
+  hdr.sform_code = 1;
+  hdr.qform_code = 0;
+  const rot44 = mat44.fromValues(
+    xr * hdr.pixDims[1],
+    yr * hdr.pixDims[2],
+    zr * hdr.pixDims[3],
+    0,
+    xa * hdr.pixDims[1],
+    ya * hdr.pixDims[2],
+    za * hdr.pixDims[3],
+    0,
+    xs * hdr.pixDims[1],
+    ys * hdr.pixDims[2],
+    zs * hdr.pixDims[3],
+    0,
+    0,
+    0,
+    0,
+    1
+  );
+  const PcrsVec = vec44.fromValues(hdr.dims[1] / 2, hdr.dims[2] / 2, hdr.dims[3] / 2, 1);
+  const PxyzOffsetVec = vec44.create();
+  vec44.transformMat4(PxyzOffsetVec, PcrsVec, rot44);
+  const translation = vec36.fromValues(cr - PxyzOffsetVec[0], ca - PxyzOffsetVec[1], cs - PxyzOffsetVec[2]);
+  hdr.affine = [
+    [rot44[0], rot44[1], rot44[2], translation[0]],
+    [rot44[4], rot44[5], rot44[6], translation[1]],
+    [rot44[8], rot44[9], rot44[10], translation[2]],
+    [0, 0, 0, 1]
+  ];
+  hdr.vox_offset = 284;
+  hdr.magic = "n+1";
+  const nBytesPerVoxel = hdr.numBitsPerVoxel / 8;
+  const nVoxels = width * height * depth * hdr.dims[4];
+  const expectedBytes = nVoxels * nBytesPerVoxel;
+  const remainingBytes = raw.byteLength - hdr.vox_offset;
+  if (remainingBytes < expectedBytes) {
+    log.error(`MGH image data size mismatch: expected ${expectedBytes}, found ${remainingBytes}`);
+    return null;
+  } else if (remainingBytes > expectedBytes) {
+    log.warn(`MGH file has extra ${remainingBytes - expectedBytes} bytes after image data. Truncating.`);
+  }
+  const imgRaw = raw.slice(hdr.vox_offset, hdr.vox_offset + expectedBytes);
+  return imgRaw;
+}
+
+// src/nvimage/ImageReaders/nii.ts
+var nii_exports = {};
+__export(nii_exports, {
+  readNifti: () => readNifti
+});
+import { isCompressed, decompressAsync, readHeaderAsync, readImage } from "nifti-reader-js";
+async function readNifti(nvImage, buffer) {
+  let dataBuffer = buffer;
+  let imgRaw = null;
+  try {
+    if (isCompressed(dataBuffer)) {
+      log.debug(`Decompressing NIfTI file: ${nvImage.name}`);
+      dataBuffer = await decompressAsync(dataBuffer);
+      log.debug(`Decompression complete for: ${nvImage.name}`);
+    }
+    if (!dataBuffer || dataBuffer.byteLength === 0) {
+      throw new Error("Buffer became invalid after decompression attempt.");
+    }
+    nvImage.hdr = await readHeaderAsync(dataBuffer);
+    if (nvImage.hdr === null) {
+      throw new Error(`Failed to read NIfTI header: ${nvImage.name}`);
+    }
+    if (nvImage.hdr.cal_min === 0 && nvImage.hdr.cal_max === 255 && nvImage.hdr.datatypeCode !== 2 /* DT_UINT8 */) {
+      log.debug(`Resetting suspicious cal_min/max (0/255) for non-uint8 NIfTI: ${nvImage.name}`);
+      nvImage.hdr.cal_min = 0;
+      nvImage.hdr.cal_max = 0;
+    }
+    imgRaw = readImage(nvImage.hdr, dataBuffer);
+    if (imgRaw === null) {
+      throw new Error(`nifti-reader-js readImage returned null for ${nvImage.name}`);
+    }
+    return imgRaw;
+  } catch (err) {
+    log.error(`Error processing NIfTI file ${nvImage.name}:`, err);
+    nvImage.hdr = null;
+    return null;
+  }
+}
+
+// src/nvimage/ImageReaders/nrrd.ts
+var nrrd_exports = {};
+__export(nrrd_exports, {
+  readNrrd: () => readNrrd
+});
+import { NIFTI1 as NIFTI13 } from "nifti-reader-js";
+import { mat3, mat4 as mat45, vec3 as vec37 } from "gl-matrix";
+async function readNrrd(nvImage, dataBuffer, pairedImgData = null) {
+  if (!nvImage.hdr) {
+    log.warn("readNrrd called before nvImage.hdr was initialized. Creating default.");
+    nvImage.hdr = new NIFTI13();
+  }
+  const hdr = nvImage.hdr;
+  hdr.pixDims = [1, 1, 1, 1, 1, 0, 0, 0];
+  const len = dataBuffer.byteLength;
+  let txt = null;
+  const bytes = new Uint8Array(dataBuffer);
+  for (let i = 1; i < len; i++) {
+    if (bytes[i - 1] === 10 && bytes[i] === 10) {
+      const v = dataBuffer.slice(0, i - 1);
+      txt = new TextDecoder().decode(v);
+      hdr.vox_offset = i + 1;
+      break;
+    }
+  }
+  if (txt === null) {
+    log.error("readNrrd: could not extract txt");
+    return null;
+  }
+  const lines = txt.split("\n");
+  if (!lines[0].startsWith("NRRD")) {
+    log.error("Invalid NRRD image (magic signature missing)");
+    return null;
+  }
+  const n = lines.length;
+  let isGz = false;
+  let isMicron = false;
+  let isDetached = false;
+  const mat33 = mat3.fromValues(NaN, 0, 0, 0, 1, 0, 0, 0, 1);
+  const offset = vec37.fromValues(0, 0, 0);
+  let rot33 = mat3.create();
+  for (let i = 1; i < n; i++) {
+    let str = lines[i];
+    if (str.length === 0 || str[0] === "#") {
+      if (str.startsWith("#")) {
+        continue;
+      }
+      if (str.trim().length === 0) {
+        continue;
+      }
+    }
+    str = str.toLowerCase();
+    const items = str.split(":");
+    if (items.length < 2) {
+      continue;
+    }
+    const key = items[0].trim();
+    let value = items[1].trim();
+    value = value.replaceAll(")", " ");
+    value = value.replaceAll("(", " ");
+    value = value.trim();
+    switch (key) {
+      case "data file":
+        isDetached = true;
+        break;
+      case "encoding":
+        if (value.includes("raw")) {
+          isGz = false;
+        } else if (value.includes("gz")) {
+          isGz = true;
+        } else {
+          log.error("Unsupported NRRD encoding");
+          return null;
+        }
+        break;
+      case "type":
+        switch (value) {
+          case "uchar":
+          case "unsigned char":
+          case "uint8":
+          case "uint8_t":
+            hdr.numBitsPerVoxel = 8;
+            hdr.datatypeCode = 2 /* DT_UINT8 */;
+            break;
+          case "signed char":
+          case "int8":
+          case "int8_t":
+            hdr.numBitsPerVoxel = 8;
+            hdr.datatypeCode = 256 /* DT_INT8 */;
+            break;
+          case "short":
+          case "short int":
+          case "signed short":
+          case "signed short int":
+          case "int16":
+          case "int16_t":
+            hdr.numBitsPerVoxel = 16;
+            hdr.datatypeCode = 4 /* DT_INT16 */;
+            break;
+          case "ushort":
+          case "unsigned short":
+          case "unsigned short int":
+          case "uint16":
+          case "uint16_t":
+            hdr.numBitsPerVoxel = 16;
+            hdr.datatypeCode = 512 /* DT_UINT16 */;
+            break;
+          case "int":
+          case "signed int":
+          case "int32":
+          case "int32_t":
+            hdr.numBitsPerVoxel = 32;
+            hdr.datatypeCode = 8 /* DT_INT32 */;
+            break;
+          case "uint":
+          case "unsigned int":
+          case "uint32":
+          case "uint32_t":
+            hdr.numBitsPerVoxel = 32;
+            hdr.datatypeCode = 768 /* DT_UINT32 */;
+            break;
+          case "float":
+            hdr.numBitsPerVoxel = 32;
+            hdr.datatypeCode = 16 /* DT_FLOAT32 */;
+            break;
+          case "double":
+            hdr.numBitsPerVoxel = 64;
+            hdr.datatypeCode = 64 /* DT_FLOAT64 */;
+            break;
+          default:
+            log.error("Unsupported NRRD data type: " + value);
+            return null;
+        }
+        break;
+      case "spacings":
+        {
+          const values = value.split(/[ ,]+/);
+          for (let d = 0; d < values.length; d++) {
+            hdr.pixDims[d + 1] = parseFloat(values[d]);
+          }
+        }
+        break;
+      case "sizes":
+        {
+          const dims = value.split(/[ ,]+/);
+          hdr.dims[0] = dims.length;
+          for (let d = 0; d < dims.length; d++) {
+            hdr.dims[d + 1] = parseInt(dims[d]);
+          }
+        }
+        break;
+      case "endian":
+        if (value.includes("little")) {
+          hdr.littleEndian = true;
+        } else if (value.includes("big")) {
+          hdr.littleEndian = false;
+        }
+        break;
+      case "space directions":
+        {
+          const vs = value.split(/[ ,]+/);
+          if (vs.length === 9) {
+            for (let d = 0; d < 9; d++) {
+              mat33[d] = parseFloat(vs[d]);
+            }
+          }
+        }
+        break;
+      case "space origin":
+        {
+          const ts = value.split(/[ ,]+/);
+          if (ts.length === 3) {
+            offset[0] = parseFloat(ts[0]);
+            offset[1] = parseFloat(ts[1]);
+            offset[2] = parseFloat(ts[2]);
+          }
+        }
+        break;
+      case "space units":
+        if (value.includes("microns")) {
+          isMicron = true;
+        }
+        break;
+      case "space":
+        if (value.includes("right-anterior-superior") || value.includes("ras")) {
+          rot33 = mat3.fromValues(1, 0, 0, 0, 1, 0, 0, 0, 1);
+        } else if (value.includes("left-anterior-superior") || value.includes("las")) {
+          rot33 = mat3.fromValues(-1, 0, 0, 0, 1, 0, 0, 0, 1);
+        } else if (value.includes("left-posterior-superior") || value.includes("lps")) {
+          rot33 = mat3.fromValues(-1, 0, 0, 0, -1, 0, 0, 0, 1);
+        } else {
+          log.warn("Unsupported NRRD space value:", value);
+        }
+        break;
+      default:
+        log.warn("Unknown:", key);
+        break;
+    }
+  }
+  if (!isNaN(mat33[0])) {
+    hdr.sform_code = 2;
+    if (isMicron) {
+      mat45.multiplyScalar(mat33, mat33, 1e-3);
+      offset[0] *= 1e-3;
+      offset[1] *= 1e-3;
+      offset[2] *= 1e-3;
+    }
+    if (rot33[0] < 0) {
+      offset[0] = -offset[0];
+    }
+    if (rot33[4] < 0) {
+      offset[1] = -offset[1];
+    }
+    if (rot33[8] < 0) {
+      offset[2] = -offset[2];
+    }
+    mat3.multiply(mat33, rot33, mat33);
+    const mat = mat45.fromValues(
+      mat33[0],
+      mat33[3],
+      mat33[6],
+      offset[0],
+      mat33[1],
+      mat33[4],
+      mat33[7],
+      offset[1],
+      mat33[2],
+      mat33[5],
+      mat33[8],
+      offset[2],
+      0,
+      0,
+      0,
+      1
+    );
+    if (!nvImage.vox2mm) {
+      return null;
+    }
+    const mm000 = nvImage.vox2mm([0, 0, 0], mat);
+    const mm100 = nvImage.vox2mm([1, 0, 0], mat);
+    vec37.subtract(mm100, mm100, mm000);
+    const mm010 = nvImage.vox2mm([0, 1, 0], mat);
+    vec37.subtract(mm010, mm010, mm000);
+    const mm001 = nvImage.vox2mm([0, 0, 1], mat);
+    vec37.subtract(mm001, mm001, mm000);
+    hdr.pixDims[1] = vec37.length(mm100);
+    hdr.pixDims[2] = vec37.length(mm010);
+    hdr.pixDims[3] = vec37.length(mm001);
+    hdr.affine = [
+      [mat[0], mat[1], mat[2], mat[3]],
+      [mat[4], mat[5], mat[6], mat[7]],
+      [mat[8], mat[9], mat[10], mat[11]],
+      [0, 0, 0, 1]
+    ];
+  }
+  let imgRaw = null;
+  const sourceBuffer = isDetached ? pairedImgData : dataBuffer;
+  const sourceOffset = isDetached ? 0 : hdr.vox_offset;
+  if (isDetached && !sourceBuffer) {
+    log.warn("Missing data: NRRD header describes detached data file but only one URL provided");
+    return null;
+  }
+  if (!sourceBuffer || sourceOffset >= sourceBuffer.byteLength) {
+    log.error(`NRRD data offset (${sourceOffset}) invalid for buffer length (${sourceBuffer?.byteLength ?? 0})`);
+    return null;
+  }
+  let dataSection = sourceBuffer.slice(sourceOffset);
+  if (isGz) {
+    try {
+      log.debug("Decompressing NRRD data...");
+      dataSection = await NVUtilities.decompressToBuffer(new Uint8Array(dataSection));
+      log.debug("Decompression complete.");
+    } catch (err) {
+      log.error("Failed to decompress NRRD data.", err);
+      return null;
+    }
+  }
+  const nBytesPerVoxel = hdr.numBitsPerVoxel / 8;
+  const nVoxels = hdr.dims.slice(1, hdr.dims[0] + 1).reduce((acc, dim) => acc * Math.max(1, dim), 1);
+  const expectedBytes = nVoxels * nBytesPerVoxel;
+  if (dataSection.byteLength < expectedBytes) {
+    log.error(`NRRD image data size mismatch: expected ${expectedBytes}, found ${dataSection.byteLength}`);
+    return null;
+  } else if (dataSection.byteLength > expectedBytes) {
+    log.warn(`NRRD has extra ${dataSection.byteLength - expectedBytes} bytes after expected image data. Truncating.`);
+    dataSection = dataSection.slice(0, expectedBytes);
+  }
+  imgRaw = dataSection;
+  if (!hdr.datatypeCode) {
+    log.error("NRRD parsing failed to set datatypeCode.");
+    return null;
+  }
+  if (!hdr.numBitsPerVoxel) {
+    log.error("NRRD parsing failed to set numBitsPerVoxel.");
+    return null;
+  }
+  return imgRaw;
+}
+
 // src/nvimage/index.ts
 var NVImage = class _NVImage {
   /**
@@ -16248,7 +17135,7 @@ var NVImage = class _NVImage {
       this.nFrame4D = nVol4D;
     }
     if ((this.hdr.intent_code === 1007 /* NIFTI_INTENT_VECTOR */ || this.hdr.intent_code === 2003 /* NIFTI_INTENT_RGB_VECTOR */) && this.nFrame4D === 3 && this.hdr.datatypeCode === 16 /* DT_FLOAT32 */) {
-      imgRaw = this.float32V1asRGBA(new Float32Array(imgRaw));
+      imgRaw = this.float32V1asRGBA(new Float32Array(imgRaw)).buffer;
     }
     if (this.hdr.pixDims[1] === 0 || this.hdr.pixDims[2] === 0 || this.hdr.pixDims[3] === 0) {
       log.error("pixDims not plausible", this.hdr);
@@ -16486,7 +17373,10 @@ var NVImage = class _NVImage {
         break;
       case NVIMAGE_TYPE.NHDR:
       case NVIMAGE_TYPE.NRRD:
-        imgRaw = await newImg.readNRRD(dataBuffer, pairedImgData);
+        imgRaw = await nrrd_exports.readNrrd(newImg, dataBuffer);
+        if (imgRaw === null) {
+          throw new Error(`Failed to parse NHDR/NRRD file ${name}`);
+        }
         break;
       case NVIMAGE_TYPE.MHD:
       case NVIMAGE_TYPE.MHA:
@@ -16494,7 +17384,10 @@ var NVImage = class _NVImage {
         break;
       case NVIMAGE_TYPE.MGH:
       case NVIMAGE_TYPE.MGZ:
-        imgRaw = await newImg.readMGH(dataBuffer);
+        imgRaw = await mgh_exports.readMgh(newImg, dataBuffer);
+        if (imgRaw === null) {
+          throw new Error(`Failed to parse MGH/MGZ file ${name}`);
+        }
         break;
       case NVIMAGE_TYPE.SRC:
         imgRaw = await newImg.readSRC(dataBuffer);
@@ -16514,20 +17407,18 @@ var NVImage = class _NVImage {
       case NVIMAGE_TYPE.BMP:
         imgRaw = await newImg.readBMP(dataBuffer);
         break;
+      case NVIMAGE_TYPE.NPY:
+        imgRaw = await newImg.readNPY(dataBuffer);
+        break;
+      case NVIMAGE_TYPE.NPZ:
+        imgRaw = await newImg.readNPZ(dataBuffer);
+        break;
+      case NVIMAGE_TYPE.ZARR:
+        throw new Error("Image type ZARR not (yet) supported");
       case NVIMAGE_TYPE.NII:
-        if (isCompressed(dataBuffer)) {
-          dataBuffer = await decompressAsync(dataBuffer);
-        }
-        newImg.hdr = await readHeaderAsync(dataBuffer);
-        if (newImg.hdr !== null) {
-          if (newImg.hdr.cal_min === 0 && newImg.hdr.cal_max === 255) {
-            newImg.hdr.cal_max = 0;
-          }
-          if (isCompressed(dataBuffer)) {
-            imgRaw = readImage(newImg.hdr, await decompressAsync(dataBuffer));
-          } else {
-            imgRaw = readImage(newImg.hdr, dataBuffer);
-          }
+        imgRaw = await nii_exports.readNifti(newImg, dataBuffer);
+        if (imgRaw === null) {
+          throw new Error(`Failed to parse NIfTI file ${name}.`);
         }
         break;
       default:
@@ -16561,8 +17452,8 @@ var NVImage = class _NVImage {
   // detect difference between voxel grid and world space
   // https://github.com/afni/afni/blob/25e77d564f2c67ff480fa99a7b8e48ec2d9a89fc/src/thd_coords.c#L717
   computeObliqueAngle(mtx44) {
-    const mtx = mat44.clone(mtx44);
-    mat44.transpose(mtx, mtx44);
+    const mtx = mat46.clone(mtx44);
+    mat46.transpose(mtx, mtx44);
     const dxtmp = Math.sqrt(mtx[0] * mtx[0] + mtx[1] * mtx[1] + mtx[2] * mtx[2]);
     const xmax = Math.max(Math.max(Math.abs(mtx[0]), Math.abs(mtx[1])), Math.abs(mtx[2])) / dxtmp;
     const dytmp = Math.sqrt(mtx[4] * mtx[4] + mtx[5] * mtx[5] + mtx[6] * mtx[6]);
@@ -16664,10 +17555,10 @@ var NVImage = class _NVImage {
     const X1mm = this.vox2mm([1 / this.pixDimsRAS[1], 0, 0], this.matRAS);
     const Y1mm = this.vox2mm([0, 1 / this.pixDimsRAS[2], 0], this.matRAS);
     const Z1mm = this.vox2mm([0, 0, 1 / this.pixDimsRAS[3]], this.matRAS);
-    vec36.subtract(X1mm, X1mm, LPI);
-    vec36.subtract(Y1mm, Y1mm, LPI);
-    vec36.subtract(Z1mm, Z1mm, LPI);
-    const oblique = mat44.fromValues(
+    vec38.subtract(X1mm, X1mm, LPI);
+    vec38.subtract(Y1mm, Y1mm, LPI);
+    vec38.subtract(Z1mm, Z1mm, LPI);
+    const oblique = mat46.fromValues(
       X1mm[0],
       X1mm[1],
       X1mm[2],
@@ -16685,19 +17576,19 @@ var NVImage = class _NVImage {
       0,
       1
     );
-    this.obliqueRAS = mat44.clone(oblique);
-    const XY = Math.abs(90 - vec36.angle(X1mm, Y1mm) * (180 / Math.PI));
-    const XZ = Math.abs(90 - vec36.angle(X1mm, Z1mm) * (180 / Math.PI));
-    const YZ = Math.abs(90 - vec36.angle(Y1mm, Z1mm) * (180 / Math.PI));
+    this.obliqueRAS = mat46.clone(oblique);
+    const XY = Math.abs(90 - vec38.angle(X1mm, Y1mm) * (180 / Math.PI));
+    const XZ = Math.abs(90 - vec38.angle(X1mm, Z1mm) * (180 / Math.PI));
+    const YZ = Math.abs(90 - vec38.angle(Y1mm, Z1mm) * (180 / Math.PI));
     this.maxShearDeg = Math.max(Math.max(XY, XZ), YZ);
     if (this.maxShearDeg > 0.1) {
       log.warn("Warning: voxels are rhomboidal, maximum shear is %f degrees.", this.maxShearDeg);
     }
-    const dim = vec44.fromValues(this.dimsRAS[1], this.dimsRAS[2], this.dimsRAS[3], 1);
-    const sform = mat44.clone(this.matRAS);
-    mat44.transpose(sform, sform);
-    const shim = vec44.fromValues(-0.5, -0.5, -0.5, 0);
-    mat44.translate(sform, sform, vec36.fromValues(shim[0], shim[1], shim[2]));
+    const dim = vec45.fromValues(this.dimsRAS[1], this.dimsRAS[2], this.dimsRAS[3], 1);
+    const sform = mat46.clone(this.matRAS);
+    mat46.transpose(sform, sform);
+    const shim = vec45.fromValues(-0.5, -0.5, -0.5, 0);
+    mat46.translate(sform, sform, vec38.fromValues(shim[0], shim[1], shim[2]));
     sform[0] *= dim[0];
     sform[1] *= dim[0];
     sform[2] *= dim[0];
@@ -16707,11 +17598,11 @@ var NVImage = class _NVImage {
     sform[8] *= dim[2];
     sform[9] *= dim[2];
     sform[10] *= dim[2];
-    this.frac2mm = mat44.clone(sform);
+    this.frac2mm = mat46.clone(sform);
     const pixdimX = this.pixDimsRAS[1];
     const pixdimY = this.pixDimsRAS[2];
     const pixdimZ = this.pixDimsRAS[3];
-    const oform = mat44.clone(sform);
+    const oform = mat46.clone(sform);
     oform[0] = pixdimX * dim[0];
     oform[1] = 0;
     oform[2] = 0;
@@ -16725,11 +17616,11 @@ var NVImage = class _NVImage {
     oform[12] = (-originVoxel[0] - 0.5) * pixdimX;
     oform[13] = (-originVoxel[1] - 0.5) * pixdimY;
     oform[14] = (-originVoxel[2] - 0.5) * pixdimZ;
-    this.frac2mmOrtho = mat44.clone(oform);
+    this.frac2mmOrtho = mat46.clone(oform);
     this.extentsMinOrtho = [oform[12], oform[13], oform[14]];
     this.extentsMaxOrtho = [oform[0] + oform[12], oform[5] + oform[13], oform[10] + oform[14]];
-    this.mm2ortho = mat44.create();
-    mat44.invert(this.mm2ortho, oblique);
+    this.mm2ortho = mat46.create();
+    mat46.invert(this.mm2ortho, oblique);
   }
   // not included in public docs
   // convert AFNI head/brik space to NIfTI format
@@ -16788,7 +17679,7 @@ var NVImage = class _NVImage {
       throw new Error("hdr not defined");
     }
     const m = this.hdr.affine;
-    const mat = mat44.fromValues(
+    const mat = mat46.fromValues(
       m[0][0],
       m[0][1],
       m[0][2],
@@ -16808,14 +17699,14 @@ var NVImage = class _NVImage {
     );
     const mm000 = this.vox2mm([0, 0, 0], mat);
     const mm100 = this.vox2mm([1, 0, 0], mat);
-    vec36.subtract(mm100, mm100, mm000);
+    vec38.subtract(mm100, mm100, mm000);
     const mm010 = this.vox2mm([0, 1, 0], mat);
-    vec36.subtract(mm010, mm010, mm000);
+    vec38.subtract(mm010, mm010, mm000);
     const mm001 = this.vox2mm([0, 0, 1], mat);
-    vec36.subtract(mm001, mm001, mm000);
-    this.hdr.pixDims[1] = vec36.length(mm100);
-    this.hdr.pixDims[2] = vec36.length(mm010);
-    this.hdr.pixDims[3] = vec36.length(mm001);
+    vec38.subtract(mm001, mm001, mm000);
+    this.hdr.pixDims[1] = vec38.length(mm100);
+    this.hdr.pixDims[2] = vec38.length(mm010);
+    this.hdr.pixDims[3] = vec38.length(mm001);
   }
   // not included in public docs
   // read DICOM format image and treat it like a NIfTI
@@ -16950,7 +17841,7 @@ var NVImage = class _NVImage {
   // read ECAT7 format image
   // https://github.com/openneuropet/PET2BIDS/tree/28aae3fab22309047d36d867c624cd629c921ca6/ecat_validation/ecat_info
   readECAT(buffer) {
-    this.hdr = new NIFTI1();
+    this.hdr = new NIFTI14();
     const hdr = this.hdr;
     hdr.dims = [3, 1, 1, 1, 0, 0, 0, 0];
     hdr.pixDims = [1, 1, 1, 1, 1, 0, 0, 0];
@@ -17046,11 +17937,11 @@ var NVImage = class _NVImage {
     ];
     hdr.numBitsPerVoxel = 32;
     hdr.datatypeCode = 16 /* DT_FLOAT32 */;
-    return rawImg;
+    return rawImg.buffer;
   }
   // readECAT()
   readV16(buffer) {
-    this.hdr = new NIFTI1();
+    this.hdr = new NIFTI14();
     const hdr = this.hdr;
     hdr.dims = [3, 1, 1, 1, 0, 0, 0, 0];
     hdr.pixDims = [1, 1, 1, 1, 1, 0, 0, 0];
@@ -17075,6 +17966,101 @@ var NVImage = class _NVImage {
     return buffer.slice(6);
   }
   // readV16()
+  async readNPY(buffer) {
+    function getTypeSize(dtype2) {
+      const typeMap = {
+        "|b1": 1,
+        // Boolean
+        "<i1": 1,
+        // Int8
+        "<u1": 1,
+        // UInt8
+        "<i2": 2,
+        // Int16
+        "<u2": 2,
+        // UInt16
+        "<i4": 4,
+        // Int32
+        "<u4": 4,
+        // UInt32
+        "<f4": 4,
+        // Float32
+        "<f8": 8
+        // Float64
+      };
+      return typeMap[dtype2] ?? 1;
+    }
+    function getDataTypeCode(dtype2) {
+      const typeMap = {
+        "|b1": 2,
+        // DT_BINARY
+        "<i1": 256,
+        // DT_INT8
+        "<u1": 2,
+        // DT_UINT8
+        "<i2": 4,
+        // DT_INT16
+        "<u2": 512,
+        // DT_UINT16
+        "<i4": 8,
+        // DT_INT32
+        "<u4": 768,
+        // DT_UINT32
+        "<f4": 16,
+        // DT_FLOAT32
+        "<f8": 64
+        // DT_FLOAT64
+      };
+      return typeMap[dtype2] ?? 16;
+    }
+    const dv = new DataView(buffer);
+    const magicBytes = [dv.getUint8(0), dv.getUint8(1), dv.getUint8(2), dv.getUint8(3), dv.getUint8(4), dv.getUint8(5)];
+    const expectedMagic = [147, 78, 85, 77, 80, 89];
+    if (!magicBytes.every((byte, i) => byte === expectedMagic[i])) {
+      throw new Error("Not a valid NPY file: Magic number mismatch");
+    }
+    const headerLen = dv.getUint16(8, true);
+    const headerText = new TextDecoder("utf-8").decode(buffer.slice(10, 10 + headerLen));
+    const shapeMatch = headerText.match(/'shape': \((.*?)\)/);
+    if (!shapeMatch) {
+      throw new Error("Invalid NPY header: Shape not found");
+    }
+    const shape = shapeMatch[1].split(",").map((s) => s.trim()).filter((s) => s !== "").map(Number);
+    const dtypeMatch = headerText.match(/'descr': '([^']+)'/);
+    if (!dtypeMatch) {
+      throw new Error("Invalid NPY header: Data type not found");
+    }
+    const dtype = dtypeMatch[1];
+    const numElements = shape.reduce((a, b) => a * b, 1);
+    const dataStart = 10 + headerLen;
+    const dataBuffer = buffer.slice(dataStart, dataStart + numElements * getTypeSize(dtype));
+    const width = shape.length > 0 ? shape[shape.length - 1] : 1;
+    const height = shape.length > 1 ? shape[shape.length - 2] : 1;
+    const slices = shape.length > 2 ? shape[shape.length - 3] : 1;
+    this.hdr = new NIFTI14();
+    const hdr = this.hdr;
+    hdr.dims = [3, width, height, slices, 0, 0, 0, 0];
+    hdr.pixDims = [1, 1, 1, 1, 1, 0, 0, 0];
+    hdr.affine = [
+      [hdr.pixDims[1], 0, 0, -(hdr.dims[1] - 2) * 0.5 * hdr.pixDims[1]],
+      [0, -hdr.pixDims[2], 0, (hdr.dims[2] - 2) * 0.5 * hdr.pixDims[2]],
+      [0, 0, -hdr.pixDims[3], (hdr.dims[3] - 2) * 0.5 * hdr.pixDims[3]],
+      [0, 0, 0, 1]
+    ];
+    hdr.numBitsPerVoxel = getTypeSize(dtype) * 8;
+    hdr.datatypeCode = getDataTypeCode(dtype);
+    return dataBuffer;
+  }
+  async readNPZ(buffer) {
+    const zip = new Zip(buffer);
+    for (let i = 0; i < zip.entries.length; i++) {
+      const entry = zip.entries[i];
+      if (entry.fileName.toLowerCase().endsWith(".npy")) {
+        const data = await entry.extract();
+        return await this.readNPY(data.buffer);
+      }
+    }
+  }
   async imageDataFromArrayBuffer(buffer) {
     return new Promise((resolve, reject) => {
       const blob = new Blob([buffer]);
@@ -17104,7 +18090,7 @@ var NVImage = class _NVImage {
   async readBMP(buffer) {
     const imageData = await this.imageDataFromArrayBuffer(buffer);
     const { width, height, data } = imageData;
-    this.hdr = new NIFTI1();
+    this.hdr = new NIFTI14();
     const hdr = this.hdr;
     hdr.dims = [3, width, height, 1, 0, 0, 0, 0];
     hdr.pixDims = [1, 1, 1, 1, 1, 0, 0, 0];
@@ -17116,13 +18102,28 @@ var NVImage = class _NVImage {
     ];
     hdr.numBitsPerVoxel = 8;
     hdr.datatypeCode = 2304 /* DT_RGBA32 */;
+    let isGrayscale = true;
+    for (let i = 0; i < data.length; i += 4) {
+      if (data[i] !== data[i + 1] || data[i] !== data[i + 2]) {
+        isGrayscale = false;
+        break;
+      }
+    }
+    if (isGrayscale) {
+      hdr.datatypeCode = 2 /* DT_UINT8 */;
+      const grayscaleData = new Uint8Array(width * height);
+      for (let i = 0, j = 0; i < data.length; i += 4, j++) {
+        grayscaleData[j] = data[i];
+      }
+      return grayscaleData.buffer;
+    }
     return data.buffer;
   }
   // not included in public docs
   // read brainvoyager format VMR image
   // https://support.brainvoyager.com/brainvoyager/automation-development/84-file-formats/343-developer-guide-2-6-the-format-of-vmr-files
   readVMR(buffer) {
-    this.hdr = new NIFTI1();
+    this.hdr = new NIFTI14();
     const hdr = this.hdr;
     hdr.dims = [3, 1, 1, 1, 0, 0, 0, 0];
     hdr.pixDims = [1, 1, 1, 1, 1, 0, 0, 0];
@@ -17176,119 +18177,20 @@ var NVImage = class _NVImage {
   }
   // readVMR()
   // not included in public docs
-  // read FreeSurfer MGH format image
-  async readMGH(buffer) {
-    this.hdr = new NIFTI1();
-    const hdr = this.hdr;
-    hdr.littleEndian = false;
-    hdr.dims = [3, 1, 1, 1, 0, 0, 0, 0];
-    hdr.pixDims = [1, 1, 1, 1, 1, 0, 0, 0];
-    let raw = buffer;
-    let reader = new DataView(raw);
-    if (reader.getUint8(0) === 31 && reader.getUint8(1) === 139) {
-      raw = await NVUtilities.decompressToBuffer(new Uint8Array(buffer));
-      reader = new DataView(raw);
-    }
-    const version2 = reader.getInt32(0, false);
-    const width = reader.getInt32(4, false);
-    const height = reader.getInt32(8, false);
-    const depth = reader.getInt32(12, false);
-    const nframes = reader.getInt32(16, false);
-    const mtype = reader.getInt32(20, false);
-    const spacingX = reader.getFloat32(30, false);
-    const spacingY = reader.getFloat32(34, false);
-    const spacingZ = reader.getFloat32(38, false);
-    const xr = reader.getFloat32(42, false);
-    const xa = reader.getFloat32(46, false);
-    const xs = reader.getFloat32(50, false);
-    const yr = reader.getFloat32(54, false);
-    const ya = reader.getFloat32(58, false);
-    const ys = reader.getFloat32(62, false);
-    const zr = reader.getFloat32(66, false);
-    const za = reader.getFloat32(70, false);
-    const zs = reader.getFloat32(74, false);
-    const cr = reader.getFloat32(78, false);
-    const ca = reader.getFloat32(82, false);
-    const cs = reader.getFloat32(86, false);
-    if (version2 !== 1 || mtype < 0 || mtype > 4) {
-      log.warn("Not a valid MGH file");
-    }
-    if (mtype === 0) {
-      hdr.numBitsPerVoxel = 8;
-      hdr.datatypeCode = 2 /* DT_UINT8 */;
-    } else if (mtype === 4) {
-      hdr.numBitsPerVoxel = 16;
-      hdr.datatypeCode = 4 /* DT_INT16 */;
-    } else if (mtype === 1) {
-      hdr.numBitsPerVoxel = 32;
-      hdr.datatypeCode = 8 /* DT_INT32 */;
-    } else if (mtype === 3) {
-      hdr.numBitsPerVoxel = 32;
-      hdr.datatypeCode = 16 /* DT_FLOAT32 */;
-    }
-    hdr.dims[1] = width;
-    hdr.dims[2] = height;
-    hdr.dims[3] = depth;
-    hdr.dims[4] = nframes;
-    if (nframes > 1) {
-      hdr.dims[0] = 4;
-    }
-    hdr.pixDims[1] = spacingX;
-    hdr.pixDims[2] = spacingY;
-    hdr.pixDims[3] = spacingZ;
-    hdr.vox_offset = 284;
-    hdr.sform_code = 1;
-    const rot44 = mat44.fromValues(
-      xr * hdr.pixDims[1],
-      yr * hdr.pixDims[2],
-      zr * hdr.pixDims[3],
-      0,
-      xa * hdr.pixDims[1],
-      ya * hdr.pixDims[2],
-      za * hdr.pixDims[3],
-      0,
-      xs * hdr.pixDims[1],
-      ys * hdr.pixDims[2],
-      zs * hdr.pixDims[3],
-      0,
-      0,
-      0,
-      0,
-      1
-    );
-    const Pcrs = [hdr.dims[1] / 2, hdr.dims[2] / 2, hdr.dims[3] / 2, 1];
-    const PxyzOffset = [0, 0, 0, 0];
-    for (let i = 0; i < 3; i++) {
-      PxyzOffset[i] = 0;
-      for (let j = 0; j < 3; j++) {
-        PxyzOffset[i] = PxyzOffset[i] + rot44[j + i * 4] * Pcrs[j];
-      }
-    }
-    hdr.affine = [
-      [rot44[0], rot44[1], rot44[2], cr - PxyzOffset[0]],
-      [rot44[4], rot44[5], rot44[6], ca - PxyzOffset[1]],
-      [rot44[8], rot44[9], rot44[10], cs - PxyzOffset[2]],
-      [0, 0, 0, 1]
-    ];
-    const nBytes = hdr.dims[1] * hdr.dims[2] * hdr.dims[3] * hdr.dims[4] * (hdr.numBitsPerVoxel / 8);
-    return raw.slice(hdr.vox_offset, hdr.vox_offset + nBytes);
-  }
-  // readMGH()
-  // not included in public docs
   // read DSI-Studio FIB format image
   // https://dsi-studio.labsolver.org/doc/cli_data.html
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async readFIB(buffer) {
-    this.hdr = new NIFTI1();
+    this.hdr = new NIFTI14();
     const hdr = this.hdr;
     hdr.littleEndian = false;
     hdr.dims = [3, 1, 1, 1, 0, 0, 0, 0];
     hdr.pixDims = [1, 1, 1, 1, 1, 0, 0, 0];
-    const mat = await NVUtilities.readMatV4(buffer);
+    const mat = await NVUtilities.readMatV4(buffer, true);
     if (!("dimension" in mat) || !("dti_fa" in mat)) {
       throw new Error("Not a valid DSIstudio FIB file");
     }
-    const hasV1 = "index0" in mat && "index1" in mat && "index2" in mat;
+    const hasV1 = "index0" in mat && "index1" in mat && "index2" in mat && "odf_vertices" in mat;
     hdr.numBitsPerVoxel = 32;
     hdr.datatypeCode = 16 /* DT_FLOAT32 */;
     hdr.dims[1] = mat.dimension[0];
@@ -17330,13 +18232,35 @@ var NVImage = class _NVImage {
       buff8v1.set(new Uint8Array(dir1.buffer, dir1.byteOffset, dir1.byteLength), 1 * nBytes3D);
       buff8v1.set(new Uint8Array(dir2.buffer, dir2.byteOffset, dir2.byteLength), 2 * nBytes3D);
     }
+    if ("report" in mat) {
+      hdr.description = new TextDecoder().decode(mat.report.subarray(0, Math.min(79, mat.report.byteLength)));
+    }
     const buff8 = new Uint8Array(new ArrayBuffer(nBytes));
     const arrFA = Float32Array.from(mat.dti_fa);
+    if ("mask" in mat) {
+      console.log(mat);
+      let slope = 1;
+      if ("dti_fa_slope" in mat) {
+        slope = mat.dti_fa_slope[0];
+      }
+      let inter = 1;
+      if ("dti_fa_inter" in mat) {
+        inter = mat.dti_fa_inter[0];
+      }
+      const nvox = hdr.dims[1] * hdr.dims[2] * hdr.dims[3];
+      const mask = mat.mask;
+      const f32 = new Float32Array(nvox);
+      let j = 0;
+      for (let i = 0; i < nvox; i++) {
+        if (mask[i] !== 0) {
+          f32[i] = arrFA[j] * slope + inter;
+          j++;
+        }
+      }
+      return [f32.buffer, new Float32Array(buff8v1.buffer)];
+    }
     const imgFA = new Uint8Array(arrFA.buffer, arrFA.byteOffset, arrFA.byteLength);
     buff8.set(imgFA, 0);
-    if ("report" in mat) {
-      hdr.description = new TextDecoder().decode(mat.report.subarray(0, Math.min(79, mat.report.byteLength)));
-    }
     return [buff8.buffer, new Float32Array(buff8v1.buffer)];
   }
   // readFIB()
@@ -17345,7 +18269,7 @@ var NVImage = class _NVImage {
   // https://dsi-studio.labsolver.org/doc/cli_data.html
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async readSRC(buffer) {
-    this.hdr = new NIFTI1();
+    this.hdr = new NIFTI14();
     const hdr = this.hdr;
     hdr.littleEndian = false;
     hdr.dims = [3, 1, 1, 1, 0, 0, 0, 0];
@@ -17415,7 +18339,7 @@ var NVImage = class _NVImage {
   // not included in public docs
   // read AFNI head/brik format image
   async readHEAD(dataBuffer, pairedImgData) {
-    this.hdr = new NIFTI1();
+    this.hdr = new NIFTI14();
     const hdr = this.hdr;
     hdr.dims[0] = 3;
     hdr.pixDims = [1, 1, 1, 1, 1, 0, 0, 0];
@@ -17427,9 +18351,8 @@ var NVImage = class _NVImage {
     const mod = (dataBuffer.byteLength + 8) % 16;
     const len = dataBuffer.byteLength + (16 - mod);
     log.debug(dataBuffer.byteLength, "len", len);
-    const extBuffer = new Uint8Array(len);
-    extBuffer.fill(0);
-    extBuffer.set(new Uint8Array(dataBuffer));
+    const extBuffer = new ArrayBuffer(len);
+    new Uint8Array(extBuffer).set(new Uint8Array(dataBuffer));
     const newExtension = new NIFTIEXTENSION(len + 8, 42, extBuffer, true);
     hdr.addExtension(newExtension);
     hdr.extensionCode = 42;
@@ -17509,7 +18432,7 @@ var NVImage = class _NVImage {
           hdr.affine = [
             [-items[0], -items[1], -items[2], -items[3]],
             [-items[4], -items[5], -items[6], -items[7]],
-            // TODO don't re-use items for numeric values
+            // TODO don't reuse items for numeric values
             [items[8], items[9], items[10], items[11]],
             [0, 0, 0, 1]
           ];
@@ -17577,15 +18500,15 @@ var NVImage = class _NVImage {
       return new TextDecoder().decode(buffer.slice(startPos, pos));
     }
     let line = readStr();
-    this.hdr = new NIFTI1();
+    this.hdr = new NIFTI14();
     const hdr = this.hdr;
     hdr.pixDims = [1, 1, 1, 1, 1, 0, 0, 0];
     hdr.dims = [1, 1, 1, 1, 1, 1, 1, 1];
     hdr.littleEndian = true;
     let isGz = false;
     let isDetached = false;
-    const mat33 = mat3.fromValues(NaN, 0, 0, 0, 1, 0, 0, 0, 1);
-    const offset = vec36.fromValues(0, 0, 0);
+    const mat33 = mat32.fromValues(NaN, 0, 0, 0, 1, 0, 0, 0, 1);
+    const offset = vec38.fromValues(0, 0, 0);
     while (line !== "") {
       let items = line.split(" ");
       if (items.length > 2) {
@@ -17670,8 +18593,8 @@ var NVImage = class _NVImage {
       }
       line = readStr();
     }
-    const mmMat = mat3.fromValues(hdr.pixDims[1], 0, 0, 0, hdr.pixDims[2], 0, 0, 0, hdr.pixDims[3]);
-    mat3.multiply(mat33, mat33, mmMat);
+    const mmMat = mat32.fromValues(hdr.pixDims[1], 0, 0, 0, hdr.pixDims[2], 0, 0, 0, hdr.pixDims[3]);
+    mat32.multiply(mat33, mat33, mmMat);
     hdr.affine = [
       [-mat33[0], -mat33[3], -mat33[6], -offset[0]],
       [-mat33[1], -mat33[4], -mat33[7], -offset[1]],
@@ -17698,7 +18621,7 @@ var NVImage = class _NVImage {
   // read mrtrix MIF format image
   // https://mrtrix.readthedocs.io/en/latest/getting_started/image_data.html#mrtrix-image-formats
   async readMIF(buffer, pairedImgData) {
-    this.hdr = new NIFTI1();
+    this.hdr = new NIFTI14();
     const hdr = this.hdr;
     hdr.pixDims = [1, 1, 1, 1, 1, 0, 0, 0];
     hdr.dims = [1, 1, 1, 1, 1, 1, 1, 1];
@@ -17986,290 +18909,10 @@ var NVImage = class _NVImage {
         }
       }
     }
-    return outVs;
+    return outVs.buffer;
   }
   // readMIF()
   // not included in public docs
-  // read NRRD format image
-  // http://teem.sourceforge.net/nrrd/format.html
-  async readNRRD(dataBuffer, pairedImgData) {
-    this.hdr = new NIFTI1();
-    const hdr = this.hdr;
-    hdr.pixDims = [1, 1, 1, 1, 1, 0, 0, 0];
-    const len = dataBuffer.byteLength;
-    let txt = null;
-    const bytes = new Uint8Array(dataBuffer);
-    for (let i = 1; i < len; i++) {
-      if (bytes[i - 1] === 10 && bytes[i] === 10) {
-        const v = dataBuffer.slice(0, i - 1);
-        txt = new TextDecoder().decode(v);
-        hdr.vox_offset = i + 1;
-        break;
-      }
-    }
-    if (txt === null) {
-      throw new Error("could not extract txt");
-    }
-    const lines = txt.split("\n");
-    if (!lines[0].startsWith("NRRD")) {
-      alert("Invalid NRRD image");
-    }
-    const n = lines.length;
-    let isGz = false;
-    let isMicron = false;
-    let isDetached = false;
-    const mat33 = mat3.fromValues(NaN, 0, 0, 0, 1, 0, 0, 0, 1);
-    const offset = vec36.fromValues(0, 0, 0);
-    let rot33 = mat3.create();
-    for (let i = 1; i < n; i++) {
-      let str = lines[i];
-      if (str[0] === "#") {
-        continue;
-      }
-      str = str.toLowerCase();
-      const items = str.split(":");
-      if (items.length < 2) {
-        continue;
-      }
-      const key = items[0].trim();
-      let value = items[1].trim();
-      value = value.replaceAll(")", " ");
-      value = value.replaceAll("(", " ");
-      value = value.trim();
-      switch (key) {
-        case "data file":
-          isDetached = true;
-          break;
-        case "encoding":
-          if (value.includes("raw")) {
-            isGz = false;
-          } else if (value.includes("gz")) {
-            isGz = true;
-          } else {
-            alert("Unsupported NRRD encoding");
-          }
-          break;
-        case "type":
-          switch (value) {
-            case "uchar":
-            case "unsigned char":
-            case "uint8":
-            case "uint8_t":
-              hdr.numBitsPerVoxel = 8;
-              hdr.datatypeCode = 2 /* DT_UINT8 */;
-              break;
-            case "signed char":
-            case "int8":
-            case "int8_t":
-              hdr.numBitsPerVoxel = 8;
-              hdr.datatypeCode = 256 /* DT_INT8 */;
-              break;
-            case "short":
-            case "short int":
-            case "signed short":
-            case "signed short int":
-            case "int16":
-            case "int16_t":
-              hdr.numBitsPerVoxel = 16;
-              hdr.datatypeCode = 4 /* DT_INT16 */;
-              break;
-            case "ushort":
-            case "unsigned short":
-            case "unsigned short int":
-            case "uint16":
-            case "uint16_t":
-              hdr.numBitsPerVoxel = 16;
-              hdr.datatypeCode = 512 /* DT_UINT16 */;
-              break;
-            case "int":
-            case "signed int":
-            case "int32":
-            case "int32_t":
-              hdr.numBitsPerVoxel = 32;
-              hdr.datatypeCode = 8 /* DT_INT32 */;
-              break;
-            case "uint":
-            case "unsigned int":
-            case "uint32":
-            case "uint32_t":
-              hdr.numBitsPerVoxel = 32;
-              hdr.datatypeCode = 768 /* DT_UINT32 */;
-              break;
-            case "float":
-              hdr.numBitsPerVoxel = 32;
-              hdr.datatypeCode = 16 /* DT_FLOAT32 */;
-              break;
-            case "double":
-              hdr.numBitsPerVoxel = 64;
-              hdr.datatypeCode = 64 /* DT_FLOAT64 */;
-              break;
-            default:
-              throw new Error("Unsupported NRRD data type: " + value);
-          }
-          break;
-        case "spacings":
-          {
-            const values = value.split(/[ ,]+/);
-            for (let d = 0; d < values.length; d++) {
-              hdr.pixDims[d + 1] = parseFloat(values[d]);
-            }
-          }
-          break;
-        case "sizes":
-          {
-            const dims = value.split(/[ ,]+/);
-            hdr.dims[0] = dims.length;
-            for (let d = 0; d < dims.length; d++) {
-              hdr.dims[d + 1] = parseInt(dims[d]);
-            }
-          }
-          break;
-        case "endian":
-          if (value.includes("little")) {
-            hdr.littleEndian = true;
-          } else if (value.includes("big")) {
-            hdr.littleEndian = false;
-          }
-          break;
-        case "space directions":
-          {
-            const vs = value.split(/[ ,]+/);
-            if (vs.length !== 9) {
-              break;
-            }
-            for (let d = 0; d < 9; d++) {
-              mat33[d] = parseFloat(vs[d]);
-            }
-          }
-          break;
-        case "space origin":
-          {
-            const ts = value.split(/[ ,]+/);
-            if (ts.length !== 3) {
-              break;
-            }
-            offset[0] = parseFloat(ts[0]);
-            offset[1] = parseFloat(ts[1]);
-            offset[2] = parseFloat(ts[2]);
-          }
-          break;
-        case "space units":
-          if (value.includes("microns")) {
-            isMicron = true;
-          }
-          break;
-        case "space":
-          if (value.includes("right-anterior-superior") || value.includes("ras")) {
-            rot33 = mat3.fromValues(
-              1,
-              0,
-              0,
-              0,
-              1,
-              0,
-              0,
-              0,
-              1
-            );
-          } else if (value.includes("left-anterior-superior") || value.includes("las")) {
-            rot33 = mat3.fromValues(
-              -1,
-              0,
-              0,
-              0,
-              1,
-              0,
-              0,
-              0,
-              1
-            );
-          } else if (value.includes("left-posterior-superior") || value.includes("lps")) {
-            rot33 = mat3.fromValues(
-              -1,
-              0,
-              0,
-              0,
-              -1,
-              0,
-              0,
-              0,
-              1
-            );
-          } else {
-            log.warn("Unsupported NRRD space value:", value);
-          }
-          break;
-        default:
-          log.warn("Unknown:", key);
-      }
-    }
-    if (!isNaN(mat33[0])) {
-      this.hdr.sform_code = 2;
-      if (isMicron) {
-        mat44.multiplyScalar(mat33, mat33, 1e-3);
-        offset[0] *= 1e-3;
-        offset[1] *= 1e-3;
-        offset[2] *= 1e-3;
-      }
-      if (rot33[0] < 0) {
-        offset[0] = -offset[0];
-      }
-      if (rot33[4] < 0) {
-        offset[1] = -offset[1];
-      }
-      if (rot33[8] < 0) {
-        offset[2] = -offset[2];
-      }
-      mat3.multiply(mat33, rot33, mat33);
-      const mat = mat44.fromValues(
-        mat33[0],
-        mat33[3],
-        mat33[6],
-        offset[0],
-        mat33[1],
-        mat33[4],
-        mat33[7],
-        offset[1],
-        mat33[2],
-        mat33[5],
-        mat33[8],
-        offset[2],
-        0,
-        0,
-        0,
-        1
-      );
-      const mm000 = this.vox2mm([0, 0, 0], mat);
-      const mm100 = this.vox2mm([1, 0, 0], mat);
-      vec36.subtract(mm100, mm100, mm000);
-      const mm010 = this.vox2mm([0, 1, 0], mat);
-      vec36.subtract(mm010, mm010, mm000);
-      const mm001 = this.vox2mm([0, 0, 1], mat);
-      vec36.subtract(mm001, mm001, mm000);
-      hdr.pixDims[1] = vec36.length(mm100);
-      hdr.pixDims[2] = vec36.length(mm010);
-      hdr.pixDims[3] = vec36.length(mm001);
-      hdr.affine = [
-        [mat[0], mat[1], mat[2], mat[3]],
-        [mat[4], mat[5], mat[6], mat[7]],
-        [mat[8], mat[9], mat[10], mat[11]],
-        [0, 0, 0, 1]
-      ];
-    }
-    if (isDetached && pairedImgData) {
-      return pairedImgData.slice(0);
-    }
-    if (isDetached) {
-      log.warn("Missing data: NRRD header describes detached data file but only one URL provided");
-    }
-    if (isGz) {
-      return await NVUtilities.decompressToBuffer(new Uint8Array(dataBuffer.slice(hdr.vox_offset)));
-    } else {
-      return dataBuffer.slice(hdr.vox_offset);
-    }
-  }
-  // readNRRD()
-  // not included in public docs
   // Transform to orient NIfTI image to Left->Right,Posterior->Anterior,Inferior->Superior (48 possible permutations)
   calculateRAS() {
     if (!this.hdr) {
@@ -18277,7 +18920,7 @@ var NVImage = class _NVImage {
     }
     const a = this.hdr.affine;
     const header = this.hdr;
-    const absR = mat3.fromValues(
+    const absR = mat32.fromValues(
       Math.abs(a[0][0]),
       Math.abs(a[0][1]),
       Math.abs(a[0][2]),
@@ -18320,7 +18963,7 @@ var NVImage = class _NVImage {
     perm[ixyz[0] - 1] = 1;
     perm[ixyz[1] - 1] = 2;
     perm[ixyz[2] - 1] = 3;
-    let rotM = mat44.fromValues(
+    let rotM = mat46.fromValues(
       a[0][0],
       a[0][1],
       a[0][2],
@@ -18342,8 +18985,8 @@ var NVImage = class _NVImage {
     this.mm100 = this.vox2mm([header.dims[1] - 0.5, -0.5, -0.5], rotM);
     this.mm010 = this.vox2mm([-0.5, header.dims[2] - 0.5, -0.5], rotM);
     this.mm001 = this.vox2mm([-0.5, -0.5, header.dims[3] - 0.5], rotM);
-    const R = mat44.create();
-    mat44.copy(R, rotM);
+    const R = mat46.create();
+    mat46.copy(R, rotM);
     for (let i = 0; i < 3; i++) {
       for (let j = 0; j < 3; j++) {
         R[i * 4 + j] = rotM[i * 4 + perm[j] - 1];
@@ -18368,32 +19011,32 @@ var NVImage = class _NVImage {
       }
     }
     if (this.arrayEquals(perm, [1, 2, 3]) && this.arrayEquals(flip, [0, 0, 0])) {
-      this.toRAS = mat44.create();
-      this.matRAS = mat44.clone(rotM);
+      this.toRAS = mat46.create();
+      this.matRAS = mat46.clone(rotM);
       this.calculateOblique();
       this.img2RASstep = [1, this.dimsRAS[1], this.dimsRAS[1] * this.dimsRAS[2]];
       this.img2RASstart = [0, 0, 0];
       return;
     }
-    mat44.identity(rotM);
+    mat46.identity(rotM);
     rotM[0 + 0 * 4] = 1 - flip[0] * 2;
     rotM[1 + 1 * 4] = 1 - flip[1] * 2;
     rotM[2 + 2 * 4] = 1 - flip[2] * 2;
     rotM[3 + 0 * 4] = (header.dims[perm[0]] - 1) * flip[0];
     rotM[3 + 1 * 4] = (header.dims[perm[1]] - 1) * flip[1];
     rotM[3 + 2 * 4] = (header.dims[perm[2]] - 1) * flip[2];
-    const residualR = mat44.create();
-    mat44.invert(residualR, rotM);
-    mat44.multiply(residualR, residualR, R);
-    this.matRAS = mat44.clone(residualR);
-    rotM = mat44.fromValues(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1);
+    const residualR = mat46.create();
+    mat46.invert(residualR, rotM);
+    mat46.multiply(residualR, residualR, R);
+    this.matRAS = mat46.clone(residualR);
+    rotM = mat46.fromValues(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1);
     rotM[perm[0] - 1 + 0 * 4] = -flip[0] * 2 + 1;
     rotM[perm[1] - 1 + 1 * 4] = -flip[1] * 2 + 1;
     rotM[perm[2] - 1 + 2 * 4] = -flip[2] * 2 + 1;
     rotM[3 + 0 * 4] = flip[0];
     rotM[3 + 1 * 4] = flip[1];
     rotM[3 + 2 * 4] = flip[2];
-    this.toRAS = mat44.clone(rotM);
+    this.toRAS = mat46.clone(rotM);
     rotM[3] = 0;
     rotM[7] = 0;
     rotM[11] = 0;
@@ -18409,7 +19052,7 @@ var NVImage = class _NVImage {
     if (this.permRAS[0] === -3 || this.permRAS[1] === -3 || this.permRAS[2] === -3) {
       rotM[14] = header.dims[3] - 1;
     }
-    this.toRASvox = mat44.clone(rotM);
+    this.toRASvox = mat46.clone(rotM);
     log.debug(this.hdr.dims);
     log.debug(this.dimsRAS);
     const hdr = this.hdr;
@@ -18439,7 +19082,7 @@ var NVImage = class _NVImage {
       throw new Error("hdr undefined");
     }
     const hdrBytes = hdrToArrayBuffer({ ...this.hdr, vox_offset: 352 }, false);
-    const hdr = await readHeaderAsync(hdrBytes.buffer, true);
+    const hdr = await readHeaderAsync2(hdrBytes.buffer, true);
     if (nVolumes === 1) {
       hdr.dims[0] = 3;
       hdr.dims[4] = 1;
@@ -18521,11 +19164,11 @@ var NVImage = class _NVImage {
   // not included in public docs
   // convert voxel location (row, column slice, indexed from 0) to world space
   vox2mm(XYZ, mtx) {
-    const sform = mat44.clone(mtx);
-    mat44.transpose(sform, sform);
-    const pos = vec44.fromValues(XYZ[0], XYZ[1], XYZ[2], 1);
-    vec44.transformMat4(pos, pos, sform);
-    const pos3 = vec36.fromValues(pos[0], pos[1], pos[2]);
+    const sform = mat46.clone(mtx);
+    mat46.transpose(sform, sform);
+    const pos = vec45.fromValues(XYZ[0], XYZ[1], XYZ[2], 1);
+    vec45.transformMat4(pos, pos, sform);
+    const pos3 = vec38.fromValues(pos[0], pos[1], pos[2]);
     return pos3;
   }
   // vox2mm()
@@ -18535,13 +19178,13 @@ var NVImage = class _NVImage {
     if (!this.matRAS) {
       throw new Error("matRAS undefined");
     }
-    const sform = mat44.clone(this.matRAS);
-    const out = mat44.clone(sform);
-    mat44.transpose(out, sform);
-    mat44.invert(out, out);
-    const pos = vec44.fromValues(mm[0], mm[1], mm[2], 1);
-    vec44.transformMat4(pos, pos, out);
-    const pos3 = vec36.fromValues(pos[0], pos[1], pos[2]);
+    const sform = mat46.clone(this.matRAS);
+    const out = mat46.clone(sform);
+    mat46.transpose(out, sform);
+    mat46.invert(out, out);
+    const pos = vec45.fromValues(mm[0], mm[1], mm[2], 1);
+    vec45.transformMat4(pos, pos, out);
+    const pos3 = vec38.fromValues(pos[0], pos[1], pos[2]);
     if (frac) {
       return pos3;
     }
@@ -18836,58 +19479,26 @@ var NVImage = class _NVImage {
     }
     return (scaled - this.hdr.scl_inter) / this.hdr.scl_slope;
   }
-  // not included in public docs
-  // see niivue.saveImage() for wrapper of this function
+  /**
+   * Converts NVImage to NIfTI compliant byte array, potentially compressed.
+   * Delegates to ImageWriter.saveToUint8Array.
+   * @param fnm - Filename (determines if compression is needed via .gz suffix)
+   * @param drawing8 - Optional Uint8Array drawing overlay
+   * @returns Promise<Uint8Array>
+   */
   async saveToUint8Array(fnm, drawing8 = null) {
-    if (!this.hdr) {
-      throw new Error("hdr undefined");
-    }
-    if (!this.img) {
-      throw new Error("img undefined");
-    }
-    const isDrawing8 = drawing8 !== null;
-    const hdrBytes = hdrToArrayBuffer(this.hdr, isDrawing8);
-    const opad = new Uint8Array(4);
-    let img8 = new Uint8Array(this.img.buffer);
-    if (isDrawing8) {
-      img8 = new Uint8Array(drawing8.buffer);
-    }
-    const odata = new Uint8Array(hdrBytes.length + opad.length + img8.length);
-    odata.set(hdrBytes);
-    odata.set(opad, hdrBytes.length);
-    odata.set(img8, hdrBytes.length + opad.length);
-    let saveData = null;
-    const compress = fnm.endsWith(".gz");
-    if (compress) {
-      saveData = new Uint8Array(await NVUtilities.compress(odata, "gzip"));
-    } else {
-      saveData = odata;
-    }
-    return saveData;
+    return saveToUint8Array(this, fnm, drawing8);
   }
-  // not included in public docs
-  // save image as NIfTI volume
-  // if fnm is empty, data is returned
+  /**
+   * save image as NIfTI volume and trigger download.
+   * Delegates to ImageWriter.saveToDisk.
+   * @param fnm - Filename for download. If empty, returns data without download.
+   * @param drawing8 - Optional Uint8Array drawing overlay
+   * @returns Promise<Uint8Array>
+   */
   async saveToDisk(fnm = "", drawing8 = null) {
-    const saveData = await this.saveToUint8Array(fnm, drawing8);
-    if (fnm === "") {
-      log.debug("saveToDisk: empty file name, returning data as Uint8Array rather than triggering download");
-      return saveData;
-    }
-    const blob = new Blob([saveData.buffer], {
-      type: "application/octet-stream"
-    });
-    const blobUrl = URL.createObjectURL(blob);
-    const link = document.createElement("a");
-    link.setAttribute("href", blobUrl);
-    link.setAttribute("download", fnm);
-    link.style.visibility = "hidden";
-    document.body.appendChild(link);
-    link.click();
-    document.body.removeChild(link);
-    return saveData;
+    return saveToDisk(this, fnm, drawing8);
   }
-  // saveToDisk()
   static async fetchDicomData(url, headers = {}) {
     if (url === "") {
       throw Error("url must not be empty");
@@ -19007,7 +19618,7 @@ var NVImage = class _NVImage {
     if (!isNifti1) {
       return null;
     }
-    const hdr = await readHeaderAsync(hdrU8s.buffer);
+    const hdr = await readHeaderAsync2(hdrU8s.buffer);
     if (!hdr) {
       throw new Error("Could not read NIfTI header");
     }
@@ -19064,7 +19675,7 @@ var NVImage = class _NVImage {
       }
       hdrU8s = concatU8s(hdrU8s, value2);
     }
-    const hdr = await readHeaderAsync(hdrU8s.buffer);
+    const hdr = await readHeaderAsync2(hdrU8s.buffer);
     if (!hdr) {
       throw new Error("Could not read NIfTI header");
     }
@@ -19346,7 +19957,7 @@ var NVImage = class _NVImage {
           if (!isNifti1) {
             dataBuffer = await this.readFileAsync(file);
           } else {
-            const hdr = await readHeaderAsync(headerBuffer);
+            const hdr = await readHeaderAsync2(headerBuffer);
             if (!hdr) {
               throw new Error("could not read nifti header");
             }
@@ -19393,70 +20004,19 @@ var NVImage = class _NVImage {
     return nvimage;
   }
   /**
-   * factory function to load and return a new NVImage instance from a base64 encoded string
-   *
-   * @returns NVImage instance
-   * @example
-   * myImage = NVImage.loadFromBase64('SomeBase64String')
+   * Creates a Uint8Array representing a NIFTI file (header + optional image data).
+   * Delegates to ImageWriter.createNiftiArray.
    */
-  static createNiftiArray(dims = [256, 256, 256], pixDims = [1, 1, 1], affine = [1, 0, 0, -128, 0, 1, 0, -128, 0, 0, 1, -128, 0, 0, 0, 1], datatypeCode = 2, img = new Uint8Array()) {
-    const hdr = this.createNiftiHeader(dims, pixDims, affine, datatypeCode);
-    const hdrBytes = hdrToArrayBuffer(hdr, false);
-    if (img.length < 1) {
-      return hdrBytes;
-    }
-    const opad = new Uint8Array(4);
-    const img8 = new Uint8Array(img.buffer);
-    const odata = new Uint8Array(hdrBytes.length + opad.length + img8.length);
-    odata.set(hdrBytes);
-    odata.set(opad, hdrBytes.length);
-    odata.set(img8, hdrBytes.length + opad.length);
-    return odata;
+  static createNiftiArray(dims = [256, 256, 256], pixDims = [1, 1, 1], affine = [1, 0, 0, -128, 0, 1, 0, -128, 0, 0, 1, -128, 0, 0, 0, 1], datatypeCode = 2 /* DT_UINT8 */, img = new Uint8Array()) {
+    return createNiftiArray(dims, pixDims, affine, datatypeCode, img);
   }
-  // createNiftiFile()
-  static createNiftiHeader(dims = [256, 256, 256], pixDims = [1, 1, 1], affine = [1, 0, 0, -128, 0, 1, 0, -128, 0, 0, 1, -128, 0, 0, 0, 1], datatypeCode = 2) {
-    const hdr = new NIFTI1();
-    hdr.littleEndian = true;
-    hdr.dims = [3, 1, 1, 1, 0, 0, 0, 0];
-    hdr.dims[0] = Math.max(3, dims.length);
-    for (let i = 0; i < dims.length; i++) {
-      hdr.dims[i + 1] = dims[i];
-    }
-    hdr.pixDims = [1, 1, 1, 1, 1, 0, 0, 0];
-    for (let i = 0; i < dims.length; i++) {
-      hdr.pixDims[i + 1] = pixDims[i];
-    }
-    if (affine.length === 16) {
-      let k = 0;
-      for (let i = 0; i < 4; i++) {
-        for (let j = 0; j < 4; j++) {
-          hdr.affine[i][j] = affine[k];
-          k++;
-        }
-      }
-    }
-    let bpv = 8;
-    if (datatypeCode === 256 || datatypeCode === 2) {
-      bpv = 8;
-    } else if (datatypeCode === 512 || datatypeCode === 4) {
-      bpv = 16;
-    } else if (datatypeCode === 16 || datatypeCode === 768 || datatypeCode === 8 || datatypeCode === 2304) {
-      bpv = 32;
-    } else if (datatypeCode === 64) {
-      bpv = 64;
-    } else {
-      log.warn("Unsupported NIfTI datatypeCode: " + datatypeCode);
-    }
-    hdr.datatypeCode = datatypeCode;
-    hdr.numBitsPerVoxel = bpv;
-    hdr.scl_inter = 0;
-    hdr.scl_slope = 0;
-    hdr.sform_code = 2;
-    hdr.magic = "n+1";
-    hdr.vox_offset = 352;
-    return hdr;
+  /**
+   * Creates a NIFTI1 header object with basic properties.
+   * Delegates to ImageWriter.createNiftiHeader.
+   */
+  static createNiftiHeader(dims = [256, 256, 256], pixDims = [1, 1, 1], affine = [1, 0, 0, -128, 0, 1, 0, -128, 0, 0, 1, -128, 0, 0, 0, 1], datatypeCode = 2 /* DT_UINT8 */) {
+    return createNiftiHeader(dims, pixDims, affine, datatypeCode);
   }
-  // loadFromHeader
   /**
    * read a 3D slab of voxels from a volume
    * @param voxStart - first row, column and slice (RAS order) for selection
@@ -19465,77 +20025,17 @@ var NVImage = class _NVImage {
    * @returns the an array where ret[0] is the voxel values and ret[1] is dimension of selection
    * @see {@link https://niivue.github.io/niivue/features/slab_selection.html | live demo usage}
    */
+  /**
+   * read a 3D slab of voxels from a volume, specified in RAS coordinates.
+   * Delegates to VolumeUtils.getVolumeData.
+   * @param voxStart - first row, column and slice (RAS order) for selection
+   * @param voxEnd - final row, column and slice (RAS order) for selection
+   * @param dataType - array data type. Options: 'same' (default), 'uint8', 'float32', 'scaled', 'normalized', 'windowed'
+   * @returns the an array where ret[0] is the voxel values and ret[1] is dimension of selection
+   */
   getVolumeData(voxStart = [-1, 0, 0], voxEnd = [0, 0, 0], dataType = "same") {
-    let img = new Uint8Array();
-    if (Math.min(...voxStart) < 0 || Math.min(...voxEnd) < 0) {
-      return [img, [0, 0, 0]];
-    }
-    const dims = this.dimsRAS.slice(1, 4);
-    for (let i2 = 0; i2 < 3; i2++) {
-      voxStart[i2] = Math.min(voxStart[i2], dims[i2] - 1);
-      voxEnd[i2] = Math.min(voxEnd[i2], dims[i2] - 1);
-      if (voxEnd[i2] < voxStart[i2]) {
-        const tmp = voxEnd[i2];
-        voxEnd[i2] = voxStart[i2];
-        voxStart[i2] = tmp;
-      }
-    }
-    const slabDims = [voxEnd[0] - voxStart[0] + 1, voxEnd[1] - voxStart[1] + 1, voxEnd[2] - voxStart[2] + 1];
-    const slabNVox = slabDims[0] * slabDims[1] * slabDims[2];
-    let dt = this.hdr.datatypeCode;
-    if (dataType === "uint8") {
-      dt = 2 /* DT_UINT8 */;
-    } else if (dataType === "float32" || dataType === "scaled" || dataType === "normalized" || dataType === "windowed") {
-      dt = 16 /* DT_FLOAT32 */;
-    }
-    if (dt === 2 /* DT_UINT8 */) {
-      img = new Uint8Array(slabNVox);
-    } else if (dt === 4 /* DT_INT16 */) {
-      img = new Int16Array(slabNVox);
-    } else if (dt === 512 /* DT_UINT16 */) {
-      img = new Uint16Array(slabNVox);
-    } else if (dt === 16 /* DT_FLOAT32 */) {
-      img = new Float32Array(slabNVox);
-    } else if (dt === 64 /* DT_FLOAT64 */) {
-      img = new Float64Array(slabNVox);
-    } else {
-      log.error("getVolumeData unsupported datatype");
-      return [img, [0, 0, 0]];
-    }
-    const outStep = this.img2RASstep;
-    const outStart = this.img2RASstart;
-    let i = 0;
-    for (let z = voxStart[2]; z <= voxEnd[2]; z++) {
-      const zi = outStart[2] + z * outStep[2];
-      for (let y = voxStart[1]; y <= voxEnd[1]; y++) {
-        const yizi = zi + outStart[1] + y * outStep[1];
-        for (let x = voxStart[0]; x <= voxEnd[0]; x++) {
-          const xi = outStart[0] + x * outStep[0];
-          img[i++] = this.img[xi + yizi];
-        }
-      }
-    }
-    if (dataType === "scaled" || dataType === "normalized" || dataType === "windowed") {
-      for (let i2 = 0; i2 < img.length; i2++) {
-        img[i2] = img[i2] * this.hdr.scl_slope + this.hdr.scl_inter;
-      }
-    }
-    if (dataType === "normalized" || dataType === "windowed") {
-      let mn = this.cal_min;
-      let mx = this.cal_max;
-      if (dataType === "normalized") {
-        mn = this.global_min;
-        mx = this.global_max;
-      }
-      const scale = 1 / (mx - mn);
-      for (let i2 = 0; i2 < img.length; i2++) {
-        img[i2] = (img[i2] - mn) * scale;
-        img[i2] = Math.max(Math.min(img[i2], 1), 0);
-      }
-    }
-    return [img, slabDims];
+    return getVolumeData(this, voxStart, voxEnd, dataType);
   }
-  // getVolumeData()
   /**
    * write a 3D slab of voxels from a volume
    * @param voxStart - first row, column and slice (RAS order) for selection
@@ -19543,41 +20043,17 @@ var NVImage = class _NVImage {
    * @param img - array of voxel values to insert (RAS order)
    * @see {@link https://niivue.github.io/niivue/features/slab_selection.html | live demo usage}
    */
+  /**
+   * write a 3D slab of voxels from a volume, specified in RAS coordinates.
+   * Delegates to VolumeUtils.setVolumeData.
+   * Input slabData is assumed to be in the correct raw data type for the target image.
+   * @param voxStart - first row, column and slice (RAS order) for selection
+   * @param voxEnd - final row, column and slice (RAS order) for selection
+   * @param img - array of voxel values to insert (RAS order, raw data type)
+   */
   setVolumeData(voxStart = [-1, 0, 0], voxEnd = [0, 0, 0], img = new Uint8Array()) {
-    if (img.length < 1 || Math.min(...voxStart) < 0 || Math.min(...voxEnd) < 0) {
-      return;
-    }
-    const dims = this.dimsRAS.slice(1, 4);
-    for (let i2 = 0; i2 < 3; i2++) {
-      voxStart[i2] = Math.min(voxStart[i2], dims[i2] - 1);
-      voxEnd[i2] = Math.min(voxEnd[i2], dims[i2] - 1);
-      if (voxEnd[i2] < voxStart[i2]) {
-        const tmp = voxEnd[i2];
-        voxEnd[i2] = voxStart[i2];
-        voxStart[i2] = tmp;
-      }
-    }
-    const slabDims = [voxEnd[0] - voxStart[0] + 1, voxEnd[1] - voxStart[1] + 1, voxEnd[2] - voxStart[2] + 1];
-    const slabNVox = slabDims[0] * slabDims[1] * slabDims[2];
-    if (img.length < slabNVox) {
-      log.error("setVolumeData image does not have enough voxels");
-      return;
-    }
-    const outStep = this.img2RASstep;
-    const outStart = this.img2RASstart;
-    let i = 0;
-    for (let z = voxStart[2]; z <= voxEnd[2]; z++) {
-      const zi = outStart[2] + z * outStep[2];
-      for (let y = voxStart[1]; y <= voxEnd[1]; y++) {
-        const yizi = zi + outStart[1] + y * outStep[1];
-        for (let x = voxStart[0]; x <= voxEnd[0]; x++) {
-          const xi = outStart[0] + x * outStep[0];
-          this.img[xi + yizi] = img[i++];
-        }
-      }
-    }
+    setVolumeData(this, voxStart, voxEnd, img);
   }
-  // setVolumeData()
   /**
    * factory function to load and return a new NVImage instance from a base64 encoded string
    *
@@ -19728,155 +20204,18 @@ var NVImage = class _NVImage {
     }
     return zeroClone;
   }
-  // not included in public docs
-  // return voxel intensity at specific coordinates (xyz are zero indexed column row, slice)
-  getValue(x, y, z, frame4D = 0, isReadImaginary = false) {
-    if (!this.hdr) {
-      throw new Error("hdr undefined");
-    }
-    if (!this.img) {
-      throw new Error("img undefined");
-    }
-    const nx = this.hdr.dims[1];
-    const ny = this.hdr.dims[2];
-    const nz = this.hdr.dims[3];
-    const perm = this.permRAS.slice();
-    if (perm[0] !== 1 || perm[1] !== 2 || perm[2] !== 3) {
-      const pos = vec44.fromValues(x, y, z, 1);
-      vec44.transformMat4(pos, pos, this.toRASvox);
-      x = pos[0];
-      y = pos[1];
-      z = pos[2];
-    }
-    let vx = x + y * nx + z * nx * ny;
-    if (this.hdr.datatypeCode === 2304 /* DT_RGBA32 */) {
-      vx *= 4;
-      return Math.round(this.img[vx] * 0.21 + this.img[vx + 1] * 0.72 + this.img[vx + 2] * 0.07);
-    }
-    if (this.hdr.datatypeCode === 128 /* DT_RGB24 */) {
-      vx *= 3;
-      return Math.round(this.img[vx] * 0.21 + this.img[vx + 1] * 0.72 + this.img[vx + 2] * 0.07);
-    }
-    const vol = frame4D * nx * ny * nz;
-    let i = this.img[vx + vol];
-    if (isReadImaginary) {
-      i = this.imaginary[vx + vol];
-    }
-    return this.hdr.scl_slope * i + this.hdr.scl_inter;
-  }
   /**
-   * @param id - id of 3D Object (is this the base volume or an overlay?)
-   * @param gl - WebGL rendering context
-   * @returns new 3D object in model space
+   * Returns voxel intensity at specific native coordinates.
+   * Delegates to VolumeUtils.getValue.
+   * @param x - Native X coordinate (0-indexed)
+   * @param y - Native Y coordinate (0-indexed)
+   * @param z - Native Z coordinate (0-indexed)
+   * @param frame4D - 4D frame index (0-indexed)
+   * @param isReadImaginary - Flag to read from imaginary data array
+   * @returns Scaled voxel intensity
    */
-  toNiivueObject3D(id, gl) {
-    const dimsRAS = this.dimsRAS;
-    const matRAS = this.matRAS;
-    const pixDimsRAS = this.pixDimsRAS;
-    const L = -0.5;
-    const P = -0.5;
-    const I = -0.5;
-    const R = dimsRAS[1] - 1 + 0.5;
-    const A = dimsRAS[2] - 1 + 0.5;
-    const S = dimsRAS[3] - 1 + 0.5;
-    const LPI = this.vox2mm([L, P, I], matRAS);
-    const LAI = this.vox2mm([L, A, I], matRAS);
-    const LPS = this.vox2mm([L, P, S], matRAS);
-    const LAS = this.vox2mm([L, A, S], matRAS);
-    const RPI = this.vox2mm([R, P, I], matRAS);
-    const RAI = this.vox2mm([R, A, I], matRAS);
-    const RPS = this.vox2mm([R, P, S], matRAS);
-    const RAS = this.vox2mm([R, A, S], matRAS);
-    const posTex = [
-      // spatial position (XYZ), texture coordinates UVW
-      // Superior face
-      ...LPS,
-      ...[0, 0, 1],
-      ...RPS,
-      ...[1, 0, 1],
-      ...RAS,
-      ...[1, 1, 1],
-      ...LAS,
-      ...[0, 1, 1],
-      // Inferior face
-      ...LPI,
-      ...[0, 0, 0],
-      ...LAI,
-      ...[0, 1, 0],
-      ...RAI,
-      ...[1, 1, 0],
-      ...RPI,
-      ...[1, 0, 0]
-    ];
-    const indexBuffer = gl.createBuffer();
-    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuffer);
-    const indices = [
-      // six faces of cube: each has 2 triangles (6 indices)
-      0,
-      3,
-      2,
-      2,
-      1,
-      0,
-      // Top
-      4,
-      7,
-      6,
-      6,
-      5,
-      4,
-      // Bottom
-      5,
-      6,
-      2,
-      2,
-      3,
-      5,
-      // Front
-      4,
-      0,
-      1,
-      1,
-      7,
-      4,
-      // Back
-      7,
-      1,
-      2,
-      2,
-      6,
-      7,
-      // Right
-      4,
-      5,
-      3,
-      3,
-      0,
-      4
-      // Left
-    ];
-    gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(indices), gl.STATIC_DRAW);
-    const posTexBuffer = gl.createBuffer();
-    gl.bindBuffer(gl.ARRAY_BUFFER, posTexBuffer);
-    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(posTex), gl.STATIC_DRAW);
-    const vao = gl.createVertexArray();
-    gl.bindVertexArray(vao);
-    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuffer);
-    gl.bindBuffer(gl.ARRAY_BUFFER, posTexBuffer);
-    gl.enableVertexAttribArray(0);
-    gl.vertexAttribPointer(0, 3, gl.FLOAT, false, 24, 0);
-    gl.enableVertexAttribArray(1);
-    gl.vertexAttribPointer(1, 3, gl.FLOAT, false, 24, 12);
-    gl.bindVertexArray(null);
-    const obj3D = new NiivueObject3D(id, posTexBuffer, gl.TRIANGLES, indices.length, indexBuffer, vao);
-    const extents = getExtents([...LPS, ...RPS, ...RAS, ...LAS, ...LPI, ...LAI, ...RAI, ...RPI]);
-    obj3D.extentsMin = extents.min.slice();
-    obj3D.extentsMax = extents.max.slice();
-    obj3D.furthestVertexFromOrigin = extents.furthestVertexFromOrigin;
-    obj3D.originNegate = vec36.clone(extents.origin);
-    vec36.negate(obj3D.originNegate, obj3D.originNegate);
-    obj3D.fieldOfViewDeObliqueMM = [dimsRAS[1] * pixDimsRAS[1], dimsRAS[2] * pixDimsRAS[2], dimsRAS[3] * pixDimsRAS[3]];
-    return obj3D;
+  getValue(x, y, z, frame4D = 0, isReadImaginary = false) {
+    return getValue(this, x, y, z, frame4D, isReadImaginary);
   }
   /**
    * Update options for image
@@ -19920,89 +20259,18 @@ var NVImage = class _NVImage {
     return options;
   }
   /**
-   * Converts NVImage to NIfTI compliant byte array
+   * Converts NVImage to NIfTI compliant byte array.
+   * Handles potential re-orientation of drawing data.
+   * Delegates to ImageWriter.toUint8Array.
+   * @param drawingBytes - Optional Uint8Array drawing overlay
+   * @returns Uint8Array
    */
   toUint8Array(drawingBytes = null) {
-    const isDrawing = drawingBytes !== null;
-    const hdrBytes = hdrToArrayBuffer({ ...this.hdr, vox_offset: 352 }, isDrawing);
-    let drawingBytesToBeConverted = drawingBytes;
-    if (isDrawing) {
-      const perm = this.permRAS;
-      if (perm[0] !== 1 || perm[1] !== 2 || perm[2] !== 3) {
-        const dims = this.hdr.dims;
-        const layout = [0, 0, 0];
-        for (let i = 0; i < 3; i++) {
-          for (let j2 = 0; j2 < 3; j2++) {
-            if (Math.abs(perm[i]) - 1 !== j2) {
-              continue;
-            }
-            layout[j2] = i * Math.sign(perm[i]);
-          }
-        }
-        let stride = 1;
-        const instride = [1, 1, 1];
-        const inflip = [false, false, false];
-        for (let i = 0; i < layout.length; i++) {
-          for (let j2 = 0; j2 < layout.length; j2++) {
-            const a = Math.abs(layout[j2]);
-            if (a !== i) {
-              continue;
-            }
-            instride[j2] = stride;
-            if (layout[j2] < 0 || Object.is(layout[j2], -0)) {
-              inflip[j2] = true;
-            }
-            stride *= dims[j2 + 1];
-          }
-        }
-        let xlut = NVUtilities.range(0, dims[1] - 1, 1);
-        if (inflip[0]) {
-          xlut = NVUtilities.range(dims[1] - 1, 0, -1);
-        }
-        for (let i = 0; i < dims[1]; i++) {
-          xlut[i] *= instride[0];
-        }
-        let ylut = NVUtilities.range(0, dims[2] - 1, 1);
-        if (inflip[1]) {
-          ylut = NVUtilities.range(dims[2] - 1, 0, -1);
-        }
-        for (let i = 0; i < dims[2]; i++) {
-          ylut[i] *= instride[1];
-        }
-        let zlut = NVUtilities.range(0, dims[3] - 1, 1);
-        if (inflip[2]) {
-          zlut = NVUtilities.range(dims[3] - 1, 0, -1);
-        }
-        for (let i = 0; i < dims[3]; i++) {
-          zlut[i] *= instride[2];
-        }
-        const inVs = new Uint8Array(drawingBytes);
-        const outVs = new Uint8Array(dims[1] * dims[2] * dims[3]);
-        let j = 0;
-        for (let z = 0; z < dims[3]; z++) {
-          for (let y = 0; y < dims[2]; y++) {
-            for (let x = 0; x < dims[1]; x++) {
-              outVs[j] = inVs[xlut[x] + ylut[y] + zlut[z]];
-              j++;
-            }
-          }
-        }
-        drawingBytesToBeConverted = outVs;
-        log.debug("drawing bytes");
-        log.debug(drawingBytesToBeConverted);
-      }
-    }
-    const img8 = isDrawing ? drawingBytesToBeConverted : new Uint8Array(this.img.buffer);
-    const opad = new Uint8Array(4);
-    const odata = new Uint8Array(hdrBytes.length + opad.length + img8.length);
-    odata.set(hdrBytes);
-    odata.set(opad, hdrBytes.length);
-    odata.set(img8, hdrBytes.length + opad.length);
-    return odata;
+    return toUint8Array(this, drawingBytes);
   }
   // not included in public docs
   convertVox2Frac(vox) {
-    const frac = vec36.fromValues(
+    const frac = vec38.fromValues(
       (vox[0] + 0.5) / this.dimsRAS[1],
       (vox[1] + 0.5) / this.dimsRAS[2],
       (vox[2] + 0.5) / this.dimsRAS[3]
@@ -20011,7 +20279,7 @@ var NVImage = class _NVImage {
   }
   // not included in public docs
   convertFrac2Vox(frac) {
-    const vox = vec36.fromValues(
+    const vox = vec38.fromValues(
       Math.round(frac[0] * this.dims[1] - 0.5),
       // dims === RAS
       Math.round(frac[1] * this.dims[2] - 0.5),
@@ -20023,26 +20291,26 @@ var NVImage = class _NVImage {
   }
   // not included in public docs
   convertFrac2MM(frac, isForceSliceMM = false) {
-    const pos = vec44.fromValues(frac[0], frac[1], frac[2], 1);
+    const pos = vec45.fromValues(frac[0], frac[1], frac[2], 1);
     if (isForceSliceMM) {
-      vec44.transformMat4(pos, pos, this.frac2mm);
+      vec45.transformMat4(pos, pos, this.frac2mm);
     } else {
-      vec44.transformMat4(pos, pos, this.frac2mmOrtho);
+      vec45.transformMat4(pos, pos, this.frac2mmOrtho);
     }
     return pos;
   }
   // not included in public docs
   convertMM2Frac(mm, isForceSliceMM = false) {
-    const mm4 = vec44.fromValues(mm[0], mm[1], mm[2], 1);
+    const mm4 = vec45.fromValues(mm[0], mm[1], mm[2], 1);
     const d = this.dimsRAS;
-    const frac = vec36.fromValues(0, 0, 0);
+    const frac = vec38.fromValues(0, 0, 0);
     if (typeof d === "undefined") {
       return frac;
     }
     if (!isForceSliceMM) {
-      const xform = mat44.clone(this.frac2mmOrtho);
-      mat44.invert(xform, xform);
-      vec44.transformMat4(mm4, mm4, xform);
+      const xform = mat46.clone(this.frac2mmOrtho);
+      mat46.invert(xform, xform);
+      vec45.transformMat4(mm4, mm4, xform);
       frac[0] = mm4[0];
       frac[1] = mm4[1];
       frac[2] = mm4[2];
@@ -20051,10 +20319,10 @@ var NVImage = class _NVImage {
     if (d[1] < 1 || d[2] < 1 || d[3] < 1) {
       return frac;
     }
-    const sform = mat44.clone(this.matRAS);
-    mat44.invert(sform, sform);
-    mat44.transpose(sform, sform);
-    vec44.transformMat4(mm4, mm4, sform);
+    const sform = mat46.clone(this.matRAS);
+    mat46.invert(sform, sform);
+    mat46.transpose(sform, sform);
+    vec45.transformMat4(mm4, mm4, sform);
     frac[0] = (mm4[0] + 0.5) / d[1];
     frac[1] = (mm4[1] + 0.5) / d[2];
     frac[2] = (mm4[2] + 0.5) / d[3];
@@ -20223,17 +20491,18 @@ var DEFAULT_OPTIONS = {
   measureTextHeight: 0.03,
   isAlphaClipDark: false,
   gradientOrder: 1,
-  gradientOpacity: 0
+  gradientOpacity: 0,
+  invertScrollDirection: false
 };
 var INITIAL_SCENE_DATA = {
   gamma: 1,
   azimuth: 110,
   elevation: 10,
-  crosshairPos: vec37.fromValues(0.5, 0.5, 0.5),
+  crosshairPos: vec39.fromValues(0.5, 0.5, 0.5),
   clipPlane: [0, 0, 0, 0],
   clipPlaneDepthAziElev: [2, 0, 0],
   volScaleMultiplier: 1,
-  pan2Dxyzmm: vec45.fromValues(0, 0, 0, 1),
+  pan2Dxyzmm: vec46.fromValues(0, 0, 0, 1),
   clipThick: 2,
   clipVolumeLow: [0, 0, 0],
   clipVolumeHigh: [1, 1, 1]
@@ -20264,8 +20533,8 @@ var NVDocument = class _NVDocument {
       },
       sceneData: {
         ...INITIAL_SCENE_DATA,
-        pan2Dxyzmm: vec45.fromValues(0, 0, 0, 1),
-        crosshairPos: vec37.fromValues(0.5, 0.5, 0.5)
+        pan2Dxyzmm: vec46.fromValues(0, 0, 0, 1),
+        crosshairPos: vec39.fromValues(0.5, 0.5, 0.5)
       },
       get renderAzimuth() {
         return this.sceneData.azimuth;
@@ -20891,7 +21160,7 @@ var NVMesh3 = class _NVMesh {
   // given streamlines (which webGL renders as a single pixel), extrude to cylinders
   linesToCylinders(gl, posClrF32, indices) {
     function v4ToV3(v4) {
-      return vec38.fromValues(v4[0], v4[1], v4[2]);
+      return vec310.fromValues(v4[0], v4[1], v4[2]);
     }
     const primitiveRestart = Math.pow(2, 32) - 1;
     const n_count = indices.length;
@@ -20913,11 +21182,11 @@ var NVMesh3 = class _NVMesh {
     const f32 = new Float32Array(npt * f32PerVertex);
     const u8 = new Uint8Array(f32.buffer);
     let vtx = 0;
-    let prevV4 = vec46.create();
-    let currV4 = vec46.create();
-    let nextV4 = vec46.create();
-    const v1 = vec38.create();
-    let prevV2 = vec38.create();
+    let prevV4 = vec47.create();
+    let currV4 = vec47.create();
+    let nextV4 = vec47.create();
+    const v1 = vec310.create();
+    let prevV2 = vec310.create();
     let node = 0;
     const radius = this.fiberRadius;
     for (let i = 0; i < n_count; i++) {
@@ -20928,47 +21197,47 @@ var NVMesh3 = class _NVMesh {
       let idx2 = indices[i] * 4;
       node++;
       if (node <= 1) {
-        prevV4 = vec46.fromValues(posClrF32[idx2 + 0], posClrF32[idx2 + 1], posClrF32[idx2 + 2], posClrF32[idx2 + 3]);
-        currV4 = vec46.clone(prevV4);
+        prevV4 = vec47.fromValues(posClrF32[idx2 + 0], posClrF32[idx2 + 1], posClrF32[idx2 + 2], posClrF32[idx2 + 3]);
+        currV4 = vec47.clone(prevV4);
         if (i + 1 < n_count && indices[i + 1] !== primitiveRestart) {
           idx2 = indices[i + 1] * 4;
-          nextV4 = vec46.fromValues(posClrF32[idx2 + 0], posClrF32[idx2 + 1], posClrF32[idx2 + 2], posClrF32[idx2 + 3]);
-          vec38.subtract(v1, v4ToV3(prevV4), v4ToV3(nextV4));
-          vec38.normalize(v1, v1);
+          nextV4 = vec47.fromValues(posClrF32[idx2 + 0], posClrF32[idx2 + 1], posClrF32[idx2 + 2], posClrF32[idx2 + 3]);
+          vec310.subtract(v1, v4ToV3(prevV4), v4ToV3(nextV4));
+          vec310.normalize(v1, v1);
           prevV2 = NiivueObject3D.getFirstPerpVector(v1);
         }
         continue;
       }
       if (isLineEnd) {
-        nextV4 = vec46.clone(currV4);
+        nextV4 = vec47.clone(currV4);
       } else {
-        nextV4 = vec46.fromValues(posClrF32[idx2 + 0], posClrF32[idx2 + 1], posClrF32[idx2 + 2], posClrF32[idx2 + 3]);
-      }
-      vec38.subtract(v1, v4ToV3(prevV4), v4ToV3(nextV4));
-      vec38.normalize(v1, v1);
-      const D = vec38.create();
-      vec38.cross(D, prevV2, v1);
-      const v2 = vec38.create();
-      vec38.cross(v2, v1, D);
-      prevV2 = vec38.clone(prevV2);
-      const v3 = vec38.create();
-      vec38.cross(v3, v1, v2);
-      vec38.normalize(v3, v3);
-      const vtxXYZ = vec38.create();
+        nextV4 = vec47.fromValues(posClrF32[idx2 + 0], posClrF32[idx2 + 1], posClrF32[idx2 + 2], posClrF32[idx2 + 3]);
+      }
+      vec310.subtract(v1, v4ToV3(prevV4), v4ToV3(nextV4));
+      vec310.normalize(v1, v1);
+      const D = vec310.create();
+      vec310.cross(D, prevV2, v1);
+      const v2 = vec310.create();
+      vec310.cross(v2, v1, D);
+      prevV2 = vec310.clone(prevV2);
+      const v3 = vec310.create();
+      vec310.cross(v3, v1, v2);
+      vec310.normalize(v3, v3);
+      const vtxXYZ = vec310.create();
       for (let j = 0; j < cyl_sides; j++) {
         const c = Math.cos(j / cyl_sides * 2 * Math.PI);
         const s = Math.sin(j / cyl_sides * 2 * Math.PI);
         vtxXYZ[0] = radius * (c * v2[0] + s * v3[0]);
         vtxXYZ[1] = radius * (c * v2[1] + s * v3[1]);
         vtxXYZ[2] = radius * (c * v2[2] + s * v3[2]);
-        vec38.add(vtxXYZ, v4ToV3(currV4), vtxXYZ);
+        vec310.add(vtxXYZ, v4ToV3(currV4), vtxXYZ);
         const fidx = vtx * f32PerVertex;
         f32[fidx + 0] = vtxXYZ[0];
         f32[fidx + 1] = vtxXYZ[1];
         f32[fidx + 2] = vtxXYZ[2];
-        const n3 = vec38.create();
-        vec38.subtract(n3, vtxXYZ, v4ToV3(currV4));
-        vec38.normalize(n3, n3);
+        const n3 = vec310.create();
+        vec310.subtract(n3, vtxXYZ, v4ToV3(currV4));
+        vec310.normalize(n3, n3);
         const fidxU8 = (fidx + 3) * 4;
         u8[fidxU8 + 0] = n3[0] * 127;
         u8[fidxU8 + 1] = n3[1] * 127;
@@ -20976,8 +21245,8 @@ var NVMesh3 = class _NVMesh {
         f32[fidx + 4] = currV4[3];
         vtx++;
       }
-      prevV4 = vec46.clone(currV4);
-      currV4 = vec46.clone(nextV4);
+      prevV4 = vec47.clone(currV4);
+      currV4 = vec47.clone(nextV4);
       if (isLineEnd) {
         node = 0;
       }
@@ -21145,8 +21414,8 @@ var NVMesh3 = class _NVMesh {
         const vEnd3 = (offsetPt0[i + 1] - 1) * 3;
         let len = 0;
         for (let j = vStart3; j < vEnd3; j += 3) {
-          const v = vec38.fromValues(pts[j + 0] - pts[j + 3], pts[j + 1] - pts[j + 4], pts[j + 2] - pts[j + 5]);
-          len += vec38.len(v);
+          const v = vec310.fromValues(pts[j + 0] - pts[j + 3], pts[j + 1] - pts[j + 4], pts[j + 2] - pts[j + 5]);
+          len += vec310.len(v);
         }
         this.fiberLengths[i] = len;
       }
@@ -21173,8 +21442,8 @@ var NVMesh3 = class _NVMesh {
       return r + (g << 8) + (b << 16);
     }
     function direction2rgb(x1, y1, z1, x2, y2, z2, ditherFrac) {
-      const v = vec38.fromValues(Math.abs(x1 - x2), Math.abs(y1 - y2), Math.abs(z1 - z2));
-      vec38.normalize(v, v);
+      const v = vec310.fromValues(Math.abs(x1 - x2), Math.abs(y1 - y2), Math.abs(z1 - z2));
+      vec310.normalize(v, v);
       const r = ditherFrac - ditherHalf;
       for (let j = 0; j < 3; j++) {
         v[j] = 255 * Math.max(Math.min(Math.abs(v[j]) + r, 1), 0);
@@ -21820,9 +22089,14 @@ var NVMesh3 = class _NVMesh {
   // TODO this method is too generic
   setProperty(key, val, gl) {
     if (!(key in this)) {
-      log.warn("mesh does not have property ", key, this);
+      console.warn("Mesh does not have property:", key, this);
       return;
     }
+    if (typeof val !== "number" && typeof val !== "string" && typeof val !== "boolean") {
+      console.warn("Invalid value type. Expected number, string, or boolean but received:", typeof val);
+      return;
+    }
+    ;
     this[key] = val;
     this.updateMesh(gl);
   }
@@ -23849,7 +24123,7 @@ var NVLabel3D = class {
 };
 
 // src/nvconnectome.ts
-import { vec3 as vec39 } from "gl-matrix";
+import { vec3 as vec311 } from "gl-matrix";
 var defaultOptions = {
   name: "untitled connectome",
   nodeColormap: "warm",
@@ -24142,7 +24416,7 @@ var NVConnectome = class _NVConnectome extends NVMesh3 {
       if (isNeg) {
         rgba = [lutNeg[color], lutNeg[color + 1], lutNeg[color + 2], 255];
       }
-      const pt = vec39.fromValues(nodes[i].x, nodes[i].y, nodes[i].z);
+      const pt = vec311.fromValues(nodes[i].x, nodes[i].y, nodes[i].z);
       NiivueObject3D.makeColoredSphere(pts, tris, rgba255, radius, pt, rgba);
     }
     lut = cmapper.colormap(this.edgeColormap, this.colormapInvert);
@@ -24183,8 +24457,8 @@ var NVConnectome = class _NVConnectome extends NVMesh3 {
         if (isNeg) {
           rgba = [lutNeg[color], lutNeg[color + 1], lutNeg[color + 2], 255];
         }
-        const pti = vec39.fromValues(nodes[edge.first].x, nodes[edge.first].y, nodes[edge.first].z);
-        const ptj = vec39.fromValues(nodes[edge.second].x, nodes[edge.second].y, nodes[edge.second].z);
+        const pti = vec311.fromValues(nodes[edge.first].x, nodes[edge.first].y, nodes[edge.first].z);
+        const ptj = vec311.fromValues(nodes[edge.second].x, nodes[edge.second].y, nodes[edge.second].z);
         NiivueObject3D.makeColoredCylinder(pts, tris, rgba255, pti, ptj, radius, rgba);
       }
     }
@@ -24224,8 +24498,141 @@ var NVConnectome = class _NVConnectome extends NVMesh3 {
   }
 };
 
+// src/nvimage/RenderingUtils.ts
+import { vec3 as vec312 } from "gl-matrix";
+function toNiivueObject3D(nvImage, id, gl) {
+  if (!nvImage.dimsRAS || !nvImage.matRAS || !nvImage.pixDimsRAS || !nvImage.vox2mm) {
+    throw new Error("Cannot create NiivueObject3D: Missing required RAS properties or vox2mm access on NVImage.");
+  }
+  const dimsRAS = nvImage.dimsRAS;
+  const matRAS = nvImage.matRAS;
+  const pixDimsRAS = nvImage.pixDimsRAS;
+  const L = -0.5;
+  const P = -0.5;
+  const I = -0.5;
+  const R = dimsRAS[1] - 1 + 0.5;
+  const A = dimsRAS[2] - 1 + 0.5;
+  const S = dimsRAS[3] - 1 + 0.5;
+  const vox2mmFn = nvImage.vox2mm;
+  const LPI = vox2mmFn.call(nvImage, [L, P, I], matRAS);
+  const LAI = vox2mmFn.call(nvImage, [L, A, I], matRAS);
+  const LPS = vox2mmFn.call(nvImage, [L, P, S], matRAS);
+  const LAS = vox2mmFn.call(nvImage, [L, A, S], matRAS);
+  const RPI = vox2mmFn.call(nvImage, [R, P, I], matRAS);
+  const RAI = vox2mmFn.call(nvImage, [R, A, I], matRAS);
+  const RPS = vox2mmFn.call(nvImage, [R, P, S], matRAS);
+  const RAS = vox2mmFn.call(nvImage, [R, A, S], matRAS);
+  const posTex = [
+    // Superior face vertices (Indices 0-3)
+    ...LPS,
+    ...[0, 0, 1],
+    // 0
+    ...RPS,
+    ...[1, 0, 1],
+    // 1
+    ...RAS,
+    ...[1, 1, 1],
+    // 2
+    ...LAS,
+    ...[0, 1, 1],
+    // 3
+    // Inferior face vertices (Indices 4-7)
+    ...LPI,
+    ...[0, 0, 0],
+    // 4
+    ...LAI,
+    ...[0, 1, 0],
+    // 5
+    ...RAI,
+    ...[1, 1, 0],
+    // 6
+    ...RPI,
+    ...[1, 0, 0]
+    // 7
+  ];
+  const indexBuffer = gl.createBuffer();
+  if (!indexBuffer) {
+    throw new Error("Failed to create GL index buffer");
+  }
+  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuffer);
+  const indices = [
+    0,
+    3,
+    2,
+    2,
+    1,
+    0,
+    // Top
+    4,
+    7,
+    6,
+    6,
+    5,
+    4,
+    // Bottom
+    5,
+    6,
+    2,
+    2,
+    3,
+    5,
+    // Front -> Corresponds to LAI(5), RAI(6), RAS(2) / RAS(2), LAS(3), LAI(5)
+    4,
+    0,
+    1,
+    1,
+    7,
+    4,
+    // Back -> Corresponds to LPI(4), LPS(0), RPS(1) / RPS(1), RPI(7), LPI(4)
+    7,
+    1,
+    2,
+    2,
+    6,
+    7,
+    // Right -> Corresponds to RPI(7), RPS(1), RAS(2) / RAS(2), RAI(6), RPI(7)
+    4,
+    5,
+    3,
+    3,
+    0,
+    4
+    // Left -> Corresponds to LPI(4), LAI(5), LAS(3) / LAS(3), LPS(0), LPI(4)
+  ];
+  gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(indices), gl.STATIC_DRAW);
+  const posTexBuffer = gl.createBuffer();
+  if (!posTexBuffer) {
+    throw new Error("Failed to create GL vertex buffer");
+  }
+  gl.bindBuffer(gl.ARRAY_BUFFER, posTexBuffer);
+  gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(posTex), gl.STATIC_DRAW);
+  const vao = gl.createVertexArray();
+  if (!vao) {
+    throw new Error("Failed to create GL VAO");
+  }
+  gl.bindVertexArray(vao);
+  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuffer);
+  gl.bindBuffer(gl.ARRAY_BUFFER, posTexBuffer);
+  const stride = 24;
+  gl.enableVertexAttribArray(0);
+  gl.vertexAttribPointer(0, 3, gl.FLOAT, false, stride, 0);
+  gl.enableVertexAttribArray(1);
+  gl.vertexAttribPointer(1, 3, gl.FLOAT, false, stride, 12);
+  gl.bindVertexArray(null);
+  const obj3D = new NiivueObject3D(id, posTexBuffer, gl.TRIANGLES, indices.length, indexBuffer, vao);
+  const allCorners = [...LPS, ...RPS, ...RAS, ...LAS, ...LPI, ...LAI, ...RAI, ...RPI];
+  const extents = getExtents(allCorners);
+  obj3D.extentsMin = extents.min.slice();
+  obj3D.extentsMax = extents.max.slice();
+  obj3D.furthestVertexFromOrigin = extents.furthestVertexFromOrigin;
+  obj3D.originNegate = vec312.clone(extents.origin);
+  vec312.negate(obj3D.originNegate, obj3D.originNegate);
+  obj3D.fieldOfViewDeObliqueMM = [dimsRAS[1] * pixDimsRAS[1], dimsRAS[2] * pixDimsRAS[2], dimsRAS[3] * pixDimsRAS[3]];
+  return obj3D;
+}
+
 // src/niivue/utils.ts
-import { mat4 as mat45, vec3 as vec310, vec4 as vec47 } from "gl-matrix";
+import { mat4 as mat48, vec3 as vec313, vec4 as vec48 } from "gl-matrix";
 function readFileAsDataURL(input) {
   return new Promise((resolve, reject) => {
     let filePromise;
@@ -24382,27 +24789,27 @@ function negMinMax(min, max, minNeg, maxNeg) {
   return [mn, mx];
 }
 function swizzleVec3(vec, order = [0, 1, 2]) {
-  const vout = vec310.create();
+  const vout = vec313.create();
   vout[0] = vec[order[0]];
   vout[1] = vec[order[1]];
   vout[2] = vec[order[2]];
   return vout;
 }
 function isRadiological(mtx) {
-  const vRight = vec47.fromValues(1, 0, 0, 0);
-  const vRotated = vec47.create();
-  vec47.transformMat4(vRotated, vRight, mtx);
+  const vRight = vec48.fromValues(1, 0, 0, 0);
+  const vRotated = vec48.create();
+  vec48.transformMat4(vRotated, vRight, mtx);
   return vRotated[0];
 }
 function unProject(winX, winY, winZ, mvpMatrix) {
-  const inp = vec47.fromValues(winX, winY, winZ, 1);
-  const finalMatrix = mat45.clone(mvpMatrix);
-  mat45.invert(finalMatrix, finalMatrix);
+  const inp = vec48.fromValues(winX, winY, winZ, 1);
+  const finalMatrix = mat48.clone(mvpMatrix);
+  mat48.invert(finalMatrix, finalMatrix);
   inp[0] = inp[0] * 2 - 1;
   inp[1] = inp[1] * 2 - 1;
   inp[2] = inp[2] * 2 - 1;
-  const out = vec47.create();
-  vec47.transformMat4(out, inp, finalMatrix);
+  const out = vec48.create();
+  vec48.transformMat4(out, inp, finalMatrix);
   if (out[3] === 0) {
     return out;
   }
@@ -24674,6 +25081,8 @@ var Niivue = class {
     __publicField(this, "extentsMax");
     // ResizeObserver
     __publicField(this, "resizeObserver", null);
+    __publicField(this, "resizeEventListener", null);
+    __publicField(this, "canvasObserver", null);
     // syncOpts: Record<string, unknown> = {}
     __publicField(this, "syncOpts", {
       "3d": false,
@@ -25062,6 +25471,42 @@ var Niivue = class {
   set isAlphaClipDark(newVal) {
     this.document.opts.isAlphaClipDark = newVal;
   }
+  /**
+   * Clean up event listeners and observers
+   * Call this when the Niivue instance is no longer needed.
+   * This will be called when the canvas is detached from the DOM
+   * @example niivue.cleanup();
+   */
+  cleanup() {
+    if (this.resizeEventListener) {
+      window.removeEventListener("resize", this.resizeEventListener);
+      this.resizeEventListener = null;
+    }
+    if (this.resizeObserver) {
+      this.resizeObserver.disconnect();
+      this.resizeObserver = null;
+    }
+    if (this.canvasObserver) {
+      this.canvasObserver.disconnect();
+      this.canvasObserver = null;
+    }
+    if (this.canvas && this.opts.interactive) {
+      this.canvas.removeEventListener("mousedown", this.mouseDownListener.bind(this));
+      this.canvas.removeEventListener("mouseup", this.mouseUpListener.bind(this));
+      this.canvas.removeEventListener("mousemove", this.mouseMoveListener.bind(this));
+      this.canvas.removeEventListener("touchstart", this.touchStartListener.bind(this));
+      this.canvas.removeEventListener("touchend", this.touchEndListener.bind(this));
+      this.canvas.removeEventListener("touchmove", this.touchMoveListener.bind(this));
+      this.canvas.removeEventListener("wheel", this.wheelListener.bind(this));
+      this.canvas.removeEventListener("contextmenu", this.mouseContextMenuListener.bind(this));
+      this.canvas.removeEventListener("dblclick", this.resetBriCon.bind(this));
+      this.canvas.removeEventListener("dragenter", this.dragEnterListener.bind(this));
+      this.canvas.removeEventListener("dragover", this.dragOverListener.bind(this));
+      this.canvas.removeEventListener("drop", this.dropListener.bind(this));
+      this.canvas.removeEventListener("keyup", this.keyUpListener.bind(this));
+      this.canvas.removeEventListener("keydown", this.keyDownListener.bind(this));
+    }
+  }
   get volumes() {
     return this.document.volumes;
   }
@@ -25124,7 +25569,7 @@ var Niivue = class {
    * @param id - the id of an html canvas element
    * @param isAntiAlias - determines if anti-aliasing is requested (if not specified, AA usage depends on hardware)
    * @example niivue = new Niivue().attachTo('gl')
-   * @example niivue.attachTo('gl')
+   * @example await niivue.attachTo('gl')
    * @see {@link https://niivue.github.io/niivue/features/basic.multiplanar.html | live demo usage}
    */
   async attachTo(id, isAntiAlias = null) {
@@ -25137,7 +25582,7 @@ var Niivue = class {
    * @param canvas - the canvas element reference
    * @example
    * niivue = new Niivue()
-   * niivue.attachToCanvas(document.getElementById(id))
+   * await niivue.attachToCanvas(document.getElementById(id))
    */
   async attachToCanvas(canvas, isAntiAlias = null) {
     this.canvas = canvas;
@@ -25157,17 +25602,27 @@ var Niivue = class {
       this.canvas.style.display = "block";
       this.canvas.width = this.canvas.offsetWidth;
       this.canvas.height = this.canvas.offsetHeight;
-      window.addEventListener("resize", () => {
+      this.resizeEventListener = () => {
         requestAnimationFrame(() => {
           this.resizeListener();
         });
-      });
+      };
+      window.addEventListener("resize", this.resizeEventListener);
       this.resizeObserver = new ResizeObserver(() => {
         requestAnimationFrame(() => {
           this.resizeListener();
         });
       });
       this.resizeObserver.observe(this.canvas.parentElement);
+      this.canvasObserver = new MutationObserver((mutations) => {
+        for (const mutation of mutations) {
+          if (mutation.type === "childList" && mutation.removedNodes.length > 0 && Array.from(mutation.removedNodes).includes(this.canvas)) {
+            this.cleanup();
+            break;
+          }
+        }
+      });
+      this.canvasObserver.observe(this.canvas.parentElement, { childList: true });
     }
     if (this.opts.interactive) {
       this.registerInteractions();
@@ -25220,7 +25675,7 @@ var Niivue = class {
   doSync2d(otherNV) {
     const thisMM = this.frac2mm(this.scene.crosshairPos);
     otherNV.scene.crosshairPos = otherNV.mm2frac(thisMM);
-    otherNV.scene.pan2Dxyzmm = vec48.clone(this.scene.pan2Dxyzmm);
+    otherNV.scene.pan2Dxyzmm = vec49.clone(this.scene.pan2Dxyzmm);
   }
   doSyncGamma(otherNV) {
     const thisGamma = this.scene.gamma;
@@ -25230,7 +25685,7 @@ var Niivue = class {
     }
   }
   doSyncZoomPan(otherNV) {
-    otherNV.scene.pan2Dxyzmm = vec48.clone(this.scene.pan2Dxyzmm);
+    otherNV.scene.pan2Dxyzmm = vec49.clone(this.scene.pan2Dxyzmm);
   }
   doSyncCrosshair(otherNV) {
     const thisMM = this.frac2mm(this.scene.crosshairPos);
@@ -25467,7 +25922,7 @@ var Niivue = class {
     }
     this.setDragStart(pos.x, pos.y);
     if (!this.uiData.isDragging) {
-      this.uiData.pan2DxyzmmAtMouseDown = vec48.clone(this.scene.pan2Dxyzmm);
+      this.uiData.pan2DxyzmmAtMouseDown = vec49.clone(this.scene.pan2Dxyzmm);
     }
     this.uiData.isDragging = true;
     this.uiData.dragClipPlaneStartDepthAziElev = this.scene.clipPlaneDepthAziElev;
@@ -25483,7 +25938,7 @@ var Niivue = class {
     }
     this.setDragStart(pos.x, pos.y);
     if (!this.uiData.isDragging) {
-      this.uiData.pan2DxyzmmAtMouseDown = vec48.clone(this.scene.pan2Dxyzmm);
+      this.uiData.pan2DxyzmmAtMouseDown = vec49.clone(this.scene.pan2Dxyzmm);
     }
     this.uiData.isDragging = true;
     this.uiData.dragClipPlaneStartDepthAziElev = this.scene.clipPlaneDepthAziElev;
@@ -25574,9 +26029,9 @@ var Niivue = class {
     }
     const mmStart = this.frac2mm(fracStart);
     const mmEnd = this.frac2mm(fracEnd);
-    const v = vec311.create();
-    vec311.sub(v, vec311.fromValues(mmStart[0], mmStart[1], mmStart[2]), vec311.fromValues(mmEnd[0], mmEnd[1], mmEnd[2]));
-    const mmLength = vec311.len(v);
+    const v = vec314.create();
+    vec314.sub(v, vec314.fromValues(mmStart[0], mmStart[1], mmStart[2]), vec314.fromValues(mmEnd[0], mmEnd[1], mmEnd[2]));
+    const mmLength = vec314.len(v);
     const voxStart = this.frac2vox(fracStart);
     const voxEnd = this.frac2vox(fracEnd);
     this.onDragRelease({
@@ -25613,16 +26068,7 @@ var Niivue = class {
     this.uiData.mouseButtonLeftDown = false;
     if (this.drawPenFillPts.length > 0) {
       this.drawPenFilled();
-    } else if (this.drawPenAxCorSag >= 0) {
-      if (this.opts.clickToSegment) {
-        const sumBitmap = this.sumBitmap(this.drawBitmap);
-        const sumSeg = this.sumBitmap(this.clickToSegmentGrowingBitmap);
-        if (sumSeg > sumBitmap) {
-          this.updateBitmapFromClickToSegment();
-        }
-      }
     }
-    this.drawAddUndoBitmap();
     this.drawPenLocation = [NaN, NaN, NaN];
     this.drawPenAxCorSag = -1;
     if (isFunction(this.onMouseUp)) {
@@ -25760,6 +26206,30 @@ var Niivue = class {
     this.uiData.windowY = y;
   }
   // not included in public docs
+  // handler for mouse leaving the canvas
+  mouseLeaveListener() {
+    if (this.clickToSegmentIsGrowing) {
+      log.debug("Mouse left canvas, stopping clickToSegment preview.");
+      this.clickToSegmentIsGrowing = false;
+      this.refreshDrawing(true, false);
+    }
+    if (this.opts.drawingEnabled && !isNaN(this.drawPenLocation[0])) {
+      log.debug("Mouse left canvas during drawing, resetting pen state.");
+      this.drawPenLocation = [NaN, NaN, NaN];
+      this.drawPenAxCorSag = -1;
+      this.drawPenFillPts = [];
+    }
+    if (this.uiData.isDragging) {
+      log.debug("Mouse left canvas during drag, resetting drag state.");
+      this.uiData.isDragging = false;
+      this.uiData.mouseButtonLeftDown = false;
+      this.uiData.mouseButtonCenterDown = false;
+      this.uiData.mouseButtonRightDown = false;
+      this.uiData.mousedown = false;
+      this.drawScene();
+    }
+  }
+  // not included in public docs
   // handler for mouse move over canvas
   // note: no test yet
   mouseMoveListener(e) {
@@ -25798,7 +26268,21 @@ var Niivue = class {
       const x = pos.x * this.uiData.dpr;
       const y = pos.y * this.uiData.dpr;
       this.mousePos = [x, y];
-      this.drawScene();
+      const tileIdx = this.tileIndex(x, y);
+      if (tileIdx >= 0 && this.opts.drawingEnabled) {
+        const axCorSag = this.screenSlices[tileIdx].axCorSag;
+        if (axCorSag <= 2 /* SAGITTAL */) {
+          this.clickToSegmentXY = [x, y];
+          this.clickToSegmentIsGrowing = true;
+          this.doClickToSegment({
+            x,
+            // Screen X
+            y,
+            // Screen Y
+            tileIndex: tileIdx
+          });
+        }
+      }
     }
   }
   // not included in public docs
@@ -25869,7 +26353,7 @@ var Niivue = class {
     if (this.uiData.touchdown && e.touches.length < 2) {
       const rect = this.canvas.getBoundingClientRect();
       if (!this.uiData.isDragging) {
-        this.uiData.pan2DxyzmmAtMouseDown = vec48.clone(this.scene.pan2Dxyzmm);
+        this.uiData.pan2DxyzmmAtMouseDown = vec49.clone(this.scene.pan2Dxyzmm);
       }
       this.uiData.isDragging = true;
       if (this.uiData.doubleTouch && this.uiData.isDragging) {
@@ -26017,22 +26501,65 @@ var Niivue = class {
       this.drawScene();
       this.uiData.isDragging = false;
       const tileIdx = this.tileIndex(this.uiData.dragStart[0], this.uiData.dragStart[1]);
-      this.generateMouseUpCallback(
-        this.screenXY2TextureFrac(this.uiData.dragStart[0], this.uiData.dragStart[1], tileIdx),
-        this.screenXY2TextureFrac(this.uiData.dragEnd[0], this.uiData.dragEnd[1], tileIdx)
-      );
+      if (tileIdx >= 0) {
+        this.generateMouseUpCallback(
+          this.screenXY2TextureFrac(this.uiData.dragStart[0], this.uiData.dragStart[1], tileIdx),
+          this.screenXY2TextureFrac(this.uiData.dragEnd[0], this.uiData.dragEnd[1], tileIdx)
+        );
+      } else {
+        log.warn("Could not generate drag release callback for ROI selection: Invalid tile index.");
+      }
+      return;
+    }
+    let scrollAmount = e.deltaY < 0 ? -0.01 : 0.01;
+    if (this.opts.invertScrollDirection) {
+      scrollAmount = -scrollAmount;
+    }
+    if (this.opts.clickToSegment) {
+      if (scrollAmount < 0) {
+        this.opts.clickToSegmentPercent -= 0.01;
+        this.opts.clickToSegmentPercent = Math.max(this.opts.clickToSegmentPercent, 0);
+      } else {
+        this.opts.clickToSegmentPercent += 0.01;
+        this.opts.clickToSegmentPercent = Math.min(this.opts.clickToSegmentPercent, 1);
+      }
+      const x2 = this.clickToSegmentXY[0];
+      const y2 = this.clickToSegmentXY[1];
+      const tileIdx = this.tileIndex(x2, y2);
+      if (tileIdx >= 0 && this.screenSlices[tileIdx].axCorSag <= 2 /* SAGITTAL */) {
+        log.debug(`Adjusting clickToSegment threshold: ${this.opts.clickToSegmentPercent.toFixed(3)}`);
+        this.clickToSegmentIsGrowing = true;
+        this.doClickToSegment({ x: x2, y: y2, tileIndex: tileIdx });
+      }
       return;
     }
     const rect = this.canvas.getBoundingClientRect();
-    if (e.deltaY < 0) {
-      this.sliceScroll2D(-0.01, e.clientX - rect.left, e.clientY - rect.top);
-    } else {
-      this.sliceScroll2D(0.01, e.clientX - rect.left, e.clientY - rect.top);
+    const x = e.clientX - rect.left;
+    const y = e.clientY - rect.top;
+    if (this.opts.dragMode === 3 /* pan */ && this.inRenderTile(this.uiData.dpr * x, this.uiData.dpr * y) === -1) {
+      const zoomDirection = scrollAmount < 0 ? 1 : -1;
+      let zoom = this.scene.pan2Dxyzmm[3] * (1 + 10 * (0.01 * zoomDirection));
+      zoom = Math.round(zoom * 10) / 10;
+      const zoomChange = this.scene.pan2Dxyzmm[3] - zoom;
+      if (this.opts.yoke3Dto2DZoom) {
+        this.scene.volScaleMultiplier = zoom;
+      }
+      this.scene.pan2Dxyzmm[3] = zoom;
+      const mm = this.frac2mm(this.scene.crosshairPos);
+      this.scene.pan2Dxyzmm[0] += zoomChange * mm[0];
+      this.scene.pan2Dxyzmm[1] += zoomChange * mm[1];
+      this.scene.pan2Dxyzmm[2] += zoomChange * mm[2];
+      this.drawScene();
+      this.canvas.focus();
+      this.sync();
+      return;
     }
+    this.sliceScroll2D(scrollAmount, x, y);
   }
   // not included in public docs
   // setup interactions with the canvas. Mouse clicks and touches
   // note: no test yet
+  // note: any event listeners registered here should also be removed in `cleanup()`
   registerInteractions() {
     if (!this.canvas) {
       throw new Error("canvas undefined");
@@ -26040,6 +26567,7 @@ var Niivue = class {
     this.canvas.addEventListener("mousedown", this.mouseDownListener.bind(this));
     this.canvas.addEventListener("mouseup", this.mouseUpListener.bind(this));
     this.canvas.addEventListener("mousemove", this.mouseMoveListener.bind(this));
+    this.canvas.addEventListener("mouseleave", this.mouseLeaveListener.bind(this));
     this.canvas.addEventListener("touchstart", this.touchStartListener.bind(this));
     this.canvas.addEventListener("touchend", this.touchEndListener.bind(this));
     this.canvas.addEventListener("touchmove", this.touchMoveListener.bind(this));
@@ -26048,7 +26576,13 @@ var Niivue = class {
     this.canvas.addEventListener("dblclick", this.resetBriCon.bind(this));
     this.canvas.addEventListener("dragenter", this.dragEnterListener.bind(this), false);
     this.canvas.addEventListener("dragover", this.dragOverListener.bind(this), false);
-    this.canvas.addEventListener("drop", this.dropListener.bind(this), false);
+    this.canvas.addEventListener(
+      "drop",
+      (event) => {
+        this.dropListener(event).catch(console.error);
+      },
+      false
+    );
     this.canvas.setAttribute("tabindex", "0");
     this.canvas.addEventListener("keyup", this.keyUpListener.bind(this), false);
     this.canvas.addEventListener("keydown", this.keyDownListener.bind(this), false);
@@ -26284,9 +26818,9 @@ var Niivue = class {
     registers an external file loader for niivue to use when reading files.
   
     the loader must return an array buffer of the file contents for niivue
-    to parse and the extension of the file so niivue can infer the file type to load. 
+    to parse and the extension of the file so niivue can infer the file type to load.
   
-    example: 
+    example:
   
     const myCustomLoader = (File) => {
       // ... do parsing here ...
@@ -27578,6 +28112,14 @@ var Niivue = class {
       if (!this.drawBitmap) {
         this.createEmptyDrawing();
       }
+    } else {
+      if (this.clickToSegmentIsGrowing) {
+        this.clickToSegmentIsGrowing = false;
+        this.refreshDrawing(true, false);
+      }
+      this.drawPenLocation = [NaN, NaN, NaN];
+      this.drawPenAxCorSag = -1;
+      this.drawPenFillPts = [];
     }
     this.drawScene();
   }
@@ -27969,7 +28511,7 @@ var Niivue = class {
         }
 
         var nv1 = new Niivue();
-        nv1.attachTo("${canvasId}");
+        await nv1.attachTo("${canvasId}");
         var base64 = "${base64}";
         NVUtilities.decompressBase64String(base64).then((jsonText) => {
           var json = JSON.parse(jsonText); // string -> JSON
@@ -28544,7 +29086,10 @@ var Niivue = class {
   }
   // not included in public docs
   // set color of single voxel in drawing
-  drawPt(x, y, z, penValue) {
+  drawPt(x, y, z, penValue, drawBitmap = null) {
+    if (drawBitmap === null) {
+      drawBitmap = this.drawBitmap;
+    }
     if (!this.back?.dims) {
       throw new Error("back.dims not set");
     }
@@ -28554,7 +29099,7 @@ var Niivue = class {
     x = Math.min(Math.max(x, 0), dx - 1);
     y = Math.min(Math.max(y, 0), dy - 1);
     z = Math.min(Math.max(z, 0), dz - 1);
-    this.drawBitmap[x + y * dx + z * dx * dy] = penValue;
+    drawBitmap[x + y * dx + z * dx * dy] = penValue;
     const isAx = this.drawPenAxCorSag === 0;
     const isCor = this.drawPenAxCorSag === 1;
     const isSag = this.drawPenAxCorSag === 2;
@@ -28563,11 +29108,11 @@ var Niivue = class {
       for (let i = -halfPenSize; i <= halfPenSize; i++) {
         for (let j = -halfPenSize; j <= halfPenSize; j++) {
           if (isAx) {
-            this.drawBitmap[x + i + (y + j) * dx + z * dx * dy] = penValue;
+            drawBitmap[x + i + (y + j) * dx + z * dx * dy] = penValue;
           } else if (isCor) {
-            this.drawBitmap[x + i + y * dx + (z + j) * dx * dy] = penValue;
+            drawBitmap[x + i + y * dx + (z + j) * dx * dy] = penValue;
           } else if (isSag) {
-            this.drawBitmap[x + (y + j) * dx + (z + i) * dx * dy] = penValue;
+            drawBitmap[x + (y + j) * dx + (z + i) * dx * dy] = penValue;
           }
         }
       }
@@ -28826,9 +29371,34 @@ var Niivue = class {
   }
   // not included in public docs
   // set all connected voxels in drawing to new color
-  drawFloodFill(seedXYZ, newColor = 0, growSelectedCluster = 0, forceMin = NaN, forceMax = NaN, neighbors = 6, maxDistanceMM = Number.POSITIVE_INFINITY, is2D = false) {
+  drawFloodFill(seedXYZ, newColor = 0, growSelectedCluster = 0, forceMin = NaN, forceMax = NaN, neighbors = 6, maxDistanceMM = Number.POSITIVE_INFINITY, is2D = false, targetBitmap = null, isGrowClusterTool = false) {
     if (!this.drawBitmap) {
-      throw new Error("drawBitmap undefined");
+      log.warn("drawFloodFill called without an initialized drawBitmap.");
+      this.createEmptyDrawing();
+      if (!this.drawBitmap) {
+        log.error("Failed to create drawing bitmap.");
+        return;
+      }
+    }
+    if (this.clickToSegmentIsGrowing && !this.clickToSegmentGrowingBitmap) {
+      log.warn("drawFloodFill called in preview mode without initialized clickToSegmentGrowingBitmap.");
+      if (this.drawBitmap) {
+        this.clickToSegmentGrowingBitmap = this.drawBitmap.slice();
+      } else {
+        log.error("Cannot initialize growing bitmap as drawBitmap is null.");
+        return;
+      }
+      if (!this.clickToSegmentGrowingBitmap) {
+        log.error("Failed to create growing bitmap.");
+        return;
+      }
+    }
+    if (targetBitmap === null) {
+      targetBitmap = this.drawBitmap;
+    }
+    if (!targetBitmap) {
+      log.error("drawFloodFill targetBitmap is null.");
+      return;
     }
     if (!this.back?.dims) {
       throw new Error("back.dims undefined");
@@ -28844,15 +29414,12 @@ var Niivue = class {
     const nx = dims[0];
     const nxy = nx * dims[1];
     const nxyz = nxy * dims[2];
-    let img = this.drawBitmap.slice();
-    let drawBitmap = this.drawBitmap;
-    if (this.clickToSegmentIsGrowing) {
-      img = this.clickToSegmentGrowingBitmap.slice();
-      drawBitmap = this.clickToSegmentGrowingBitmap;
-    }
-    if (img.length !== nxy * dims[2]) {
+    const originalBitmap = this.clickToSegmentIsGrowing ? this.drawBitmap : targetBitmap;
+    if (!originalBitmap) {
+      log.error("Could not determine original bitmap state.");
       return;
     }
+    const img = new Uint8Array(nxyz).fill(0);
     let constrainXYZ = -1;
     if (is2D && this.drawPenAxCorSag === 0 /* AXIAL */) {
       constrainXYZ = 2;
@@ -28885,73 +29452,141 @@ var Niivue = class {
       return dist2 <= maxDistanceMM2;
     }
     const seedVx = xyz2vx(seedXYZ);
-    const seedColor = img[seedVx];
-    if (seedColor === newColor) {
-      if (growSelectedCluster !== 0) {
-        log.debug("drawFloodFill selected voxel is not part of a drawing");
-      } else {
-        log.debug("drawFloodFill selected voxel is already desired color");
+    const originalSeedColor = originalBitmap[seedVx];
+    if (isGrowClusterTool && originalSeedColor === 0) {
+      log.debug("Grow/Erase Cluster tool requires starting on a masked voxel.");
+      if (this.clickToSegmentIsGrowing && this.clickToSegmentGrowingBitmap && this.drawBitmap) {
+        this.clickToSegmentGrowingBitmap.set(this.drawBitmap);
+        this.refreshDrawing(true, true);
       }
       return;
     }
-    for (let i = 1; i < nxyz; i++) {
-      img[i] = 0;
-      if (drawBitmap[i] === seedColor) {
-        if (!isWithinDistance(i)) {
-          continue;
-        }
-        img[i] = 1;
+    if (growSelectedCluster === 0 && originalSeedColor === newColor && !isGrowClusterTool && newColor !== 0) {
+      log.debug("drawFloodFill selected voxel is already desired color");
+      if (!this.clickToSegmentIsGrowing) {
+        return;
       }
     }
-    this.drawFloodFillCore(img, seedVx, neighbors);
-    if (growSelectedCluster !== 0) {
+    let baseIntensity = NaN;
+    if (isGrowClusterTool && (growSelectedCluster === Number.POSITIVE_INFINITY || growSelectedCluster === Number.NEGATIVE_INFINITY)) {
+      const tempImgForIdentification = originalBitmap.slice();
+      for (let i = 0; i < nxyz; i++) {
+        tempImgForIdentification[i] = tempImgForIdentification[i] === originalSeedColor && isWithinDistance(i) ? 1 : 0;
+      }
+      if (tempImgForIdentification[seedVx] !== 1) {
+        log.error("Seed voxel could not be marked for cluster ID.");
+        return;
+      }
+      this.drawFloodFillCore(tempImgForIdentification, seedVx, neighbors);
       const backImg = this.volumes[0].img2RAS();
-      let mx = backImg[seedVx];
-      let mn = mx;
-      if (isFinite(forceMax) && isFinite(forceMin)) {
-        mx = forceMax;
-        mn = forceMin;
+      let clusterSum = 0;
+      let clusterCount = 0;
+      for (let i = 0; i < nxyz; i++) {
+        if (tempImgForIdentification[i] === 2) {
+          clusterSum += backImg[i];
+          clusterCount++;
+        }
+      }
+      baseIntensity = clusterCount > 0 ? clusterSum / clusterCount : backImg[seedVx];
+      log.debug(`Grow Cluster using mean intensity: ${baseIntensity.toFixed(2)} from ${clusterCount} voxels.`);
+      let fillMin = -Infinity;
+      let fillMax = Infinity;
+      if (growSelectedCluster === Number.POSITIVE_INFINITY) {
+        fillMin = baseIntensity;
+      }
+      if (growSelectedCluster === Number.NEGATIVE_INFINITY) {
+        fillMax = baseIntensity;
+      }
+      for (let i = 0; i < nxyz; i++) {
+        if (tempImgForIdentification[i] === 2) {
+          img[i] = 1;
+        } else if (originalBitmap[i] === 0) {
+          const intensity = backImg[i];
+          if (intensity >= fillMin && intensity <= fillMax && isWithinDistance(i)) {
+            img[i] = 1;
+          }
+        }
+      }
+      newColor = originalSeedColor;
+    } else {
+      if (growSelectedCluster === 0) {
+        if (isGrowClusterTool && newColor === 0) {
+          log.debug(`Erase Cluster: Identifying cluster with color ${originalSeedColor}`);
+          for (let i = 0; i < nxyz; i++) {
+            img[i] = originalBitmap[i] === originalSeedColor && isWithinDistance(i) ? 1 : 0;
+          }
+        } else {
+          for (let i = 0; i < nxyz; i++) {
+            if (originalBitmap[i] === originalSeedColor && isWithinDistance(i)) {
+              if (originalSeedColor !== 0) {
+                img[i] = 1;
+              }
+            }
+          }
+        }
       } else {
-        for (let i = 1; i < nxyz; i++) {
-          if (img[i] === 2) {
-            mx = Math.max(mx, backImg[i]);
-            mn = Math.min(mn, backImg[i]);
+        const backImg = this.volumes[0].img2RAS();
+        baseIntensity = backImg[seedVx];
+        let fillMin = -Infinity;
+        let fillMax = Infinity;
+        if (isFinite(forceMin) && isFinite(forceMax)) {
+          fillMin = forceMin;
+          fillMax = forceMax;
+        } else if (growSelectedCluster === Number.POSITIVE_INFINITY) {
+          fillMin = baseIntensity;
+        } else if (growSelectedCluster === Number.NEGATIVE_INFINITY) {
+          fillMax = baseIntensity;
+        }
+        for (let i = 0; i < nxyz; i++) {
+          const intensity = backImg[i];
+          if (intensity >= fillMin && intensity <= fillMax && isWithinDistance(i)) {
+            img[i] = 1;
           }
         }
-        if (growSelectedCluster === Number.POSITIVE_INFINITY) {
-          mx = growSelectedCluster;
+        newColor = originalBitmap[seedVx];
+        if (newColor === 0) {
+          newColor = this.opts.penValue;
+          if (newColor < 1 || !isFinite(newColor)) {
+            newColor = 1;
+          }
+        }
+      }
+    }
+    if (img[seedVx] !== 1) {
+      let isSeedValidOriginal = false;
+      if (isGrowClusterTool && growSelectedCluster !== 0) {
+        if (originalSeedColor !== 0) {
+          isSeedValidOriginal = true;
         }
-        if (growSelectedCluster === Number.NEGATIVE_INFINITY) {
-          mn = growSelectedCluster;
+      } else {
+        if (originalSeedColor !== 0 || newColor === 0) {
+          isSeedValidOriginal = true;
         }
       }
-      log.debug("Intensity range of selected cluster :", mn, mx);
-      for (let i = 1; i < nxyz; i++) {
-        img[i] = 0;
-        if (backImg[i] >= mn && backImg[i] <= mx) {
-          if (!isWithinDistance(i)) {
-            continue;
-          }
-          img[i] = 1;
+      if (isSeedValidOriginal && isWithinDistance(seedVx)) {
+        img[seedVx] = 1;
+        log.debug("Forcing seed voxel to 1 in working buffer.");
+      } else {
+        log.debug("Seed voxel not marked as candidate '1' and not valid originally.");
+        if (this.clickToSegmentIsGrowing && this.clickToSegmentGrowingBitmap && this.drawBitmap) {
+          this.clickToSegmentGrowingBitmap.set(this.drawBitmap);
         }
+        return;
       }
-      this.drawFloodFillCore(img, seedVx, neighbors);
-      newColor = seedColor;
     }
-    for (let i = 1; i < nxyz; i++) {
+    this.drawFloodFillCore(img, seedVx, neighbors);
+    for (let i = 0; i < nxyz; i++) {
       if (img[i] === 2) {
-        drawBitmap[i] = newColor;
+        targetBitmap[i] = newColor;
+      } else if (this.clickToSegmentIsGrowing && targetBitmap === this.clickToSegmentGrowingBitmap) {
+        targetBitmap[i] = originalBitmap[i];
       }
     }
     if (!this.clickToSegmentIsGrowing) {
-      this.drawBitmap = drawBitmap.slice();
-      if (!this.opts.clickToSegment) {
-        this.drawAddUndoBitmap();
-      }
-      this.refreshDrawing(true, this.clickToSegmentIsGrowing);
+      this.drawAddUndoBitmap();
+      this.refreshDrawing(true, false);
     } else {
-      this.clickToSegmentGrowingBitmap = drawBitmap;
-      this.refreshDrawing(true, this.clickToSegmentIsGrowing);
+      this.refreshDrawing(true, true);
     }
   }
   // not included in public docs
@@ -29122,36 +29757,67 @@ var Niivue = class {
    * @see {@link https://niivue.github.io/niivue/features/cactus.html | live demo usage}
    */
   refreshDrawing(isForceRedraw = true, useClickToSegmentBitmap = false) {
+    if (useClickToSegmentBitmap && (!this.opts.drawingEnabled || !this.opts.clickToSegment)) {
+      log.debug("refreshDrawing: Conditions not met for clickToSegment bitmap, using drawBitmap.");
+      useClickToSegmentBitmap = false;
+    }
+    const selectedBitmap = useClickToSegmentBitmap ? this.clickToSegmentGrowingBitmap : this.drawBitmap;
+    if (!selectedBitmap && !useClickToSegmentBitmap && this.clickToSegmentGrowingBitmap) {
+      log.warn("refreshDrawing: drawBitmap is null, but clickToSegmentGrowingBitmap exists. Check state.");
+    } else if (!selectedBitmap && useClickToSegmentBitmap && this.drawBitmap) {
+      log.warn("refreshDrawing: clickToSegmentGrowingBitmap is null, falling back to drawBitmap.");
+      useClickToSegmentBitmap = false;
+    } else if (!selectedBitmap) {
+      log.warn("refreshDrawing: Both bitmaps are null. Uploading empty data.");
+    }
+    const bitmapDataSource = useClickToSegmentBitmap ? this.clickToSegmentGrowingBitmap : this.drawBitmap;
     if (!this.back?.dims) {
-      throw new Error("back.dims undefined");
-    }
-    if (!this.drawBitmap) {
-      throw new Error("drawBitmap undefined");
+      log.warn("refreshDrawing: back.dims undefined, cannot refresh drawing texture yet.");
+      return;
     }
     const dims = this.back.dims.slice();
     const vx = this.back.dims[1] * this.back.dims[2] * this.back.dims[3];
-    if (this.drawBitmap.length === 8) {
+    if (!bitmapDataSource) {
+      log.warn(
+        `refreshDrawing: Bitmap data source (${useClickToSegmentBitmap ? "growing" : "main"}) is null. Cannot update texture.`
+      );
+      if (isForceRedraw) {
+        this.drawScene();
+      }
+      return;
+    }
+    if (bitmapDataSource.length === 8) {
       dims[1] = 2;
       dims[2] = 2;
       dims[3] = 2;
-    } else if (vx !== this.drawBitmap.length) {
-      log.warn("Drawing bitmap must match the background image");
+    } else if (vx !== bitmapDataSource.length) {
+      log.warn(`Drawing bitmap length (${bitmapDataSource.length}) must match the background image (${vx})`);
     }
     this.gl.activeTexture(TEXTURE7_DRAW);
     this.gl.bindTexture(this.gl.TEXTURE_3D, this.drawTexture);
-    this.gl.texSubImage3D(
-      this.gl.TEXTURE_3D,
-      0,
-      0,
-      0,
-      0,
-      dims[1],
-      dims[2],
-      dims[3],
-      this.gl.RED,
-      this.gl.UNSIGNED_BYTE,
-      useClickToSegmentBitmap ? this.clickToSegmentGrowingBitmap : this.drawBitmap
-    );
+    if (!this.drawTexture) {
+      log.error("refreshDrawing: drawTexture (GPU texture) is null.");
+      return;
+    }
+    try {
+      this.gl.texSubImage3D(
+        this.gl.TEXTURE_3D,
+        0,
+        0,
+        0,
+        0,
+        dims[1],
+        dims[2],
+        dims[3],
+        this.gl.RED,
+        this.gl.UNSIGNED_BYTE,
+        bitmapDataSource
+        // Use the determined source
+      );
+    } catch (error) {
+      log.error("Error during texSubImage3D in refreshDrawing:", error);
+      log.error("Dimensions:", dims, "Bitmap length:", bitmapDataSource?.length);
+    }
     if (isForceRedraw) {
       this.drawScene();
     }
@@ -29989,10 +30655,10 @@ var Niivue = class {
     if (this.crosshairs3D) {
       this.crosshairs3D.mm[0] = NaN;
     }
-    let mtx = mat46.clone(overlayItem.toRAS);
+    let mtx = mat49.clone(overlayItem.toRAS);
     if (layer === 0) {
-      this.volumeObject3D = overlayItem.toNiivueObject3D(this.VOLUME_ID, this.gl);
-      mat46.invert(mtx, mtx);
+      this.volumeObject3D = toNiivueObject3D(overlayItem, this.VOLUME_ID, this.gl);
+      mat49.invert(mtx, mtx);
       this.back.matRAS = overlayItem.matRAS;
       this.back.dims = overlayItem.dimsRAS;
       this.back.pixDims = overlayItem.pixDimsRAS;
@@ -30022,10 +30688,10 @@ var Niivue = class {
       let f100 = this.mm2frac(overlayItem.mm100, 0, true);
       let f010 = this.mm2frac(overlayItem.mm010, 0, true);
       let f001 = this.mm2frac(overlayItem.mm001, 0, true);
-      f100 = vec311.subtract(f100, f100, f000);
-      f010 = vec311.subtract(f010, f010, f000);
-      f001 = vec311.subtract(f001, f001, f000);
-      mtx = mat46.fromValues(
+      f100 = vec314.subtract(f100, f100, f000);
+      f010 = vec314.subtract(f010, f010, f000);
+      f001 = vec314.subtract(f001, f001, f000);
+      mtx = mat49.fromValues(
         f100[0],
         f010[0],
         f001[0],
@@ -30043,7 +30709,7 @@ var Niivue = class {
         0,
         1
       );
-      mat46.invert(mtx, mtx);
+      mat49.invert(mtx, mtx);
       if (layer === 1) {
         outTexture = this.rgbaTex(this.overlayTexture, TEXTURE2_OVERLAY_VOL, this.back.dims);
         this.overlayTexture = outTexture;
@@ -30917,7 +31583,7 @@ var Niivue = class {
   // https://github.com/nipy/nibabel/blob/a2e5dee05cf374c22670ff9fd0d385ce366eb495/nibabel/freesurfer/mghformat.py#L30
   conformVox2Vox(inDims, inAffine, outDim = 256, outMM = 1, toRAS = false) {
     const a = inAffine.flat();
-    const affine = mat46.fromValues(
+    const affine = mat49.fromValues(
       a[0],
       a[1],
       a[2],
@@ -30935,37 +31601,37 @@ var Niivue = class {
       a[14],
       a[15]
     );
-    const half = vec48.fromValues(inDims[1] / 2, inDims[2] / 2, inDims[3] / 2, 1);
-    const Pxyz_c4 = vec48.create();
-    const affineT = mat46.create();
-    mat46.transpose(affineT, affine);
-    vec48.transformMat4(Pxyz_c4, half, affineT);
-    const Pxyz_c = vec311.fromValues(Pxyz_c4[0], Pxyz_c4[1], Pxyz_c4[2]);
-    const delta = vec311.fromValues(outMM, outMM, outMM);
-    let Mdc = mat46.fromValues(-1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1);
+    const half = vec49.fromValues(inDims[1] / 2, inDims[2] / 2, inDims[3] / 2, 1);
+    const Pxyz_c4 = vec49.create();
+    const affineT = mat49.create();
+    mat49.transpose(affineT, affine);
+    vec49.transformMat4(Pxyz_c4, half, affineT);
+    const Pxyz_c = vec314.fromValues(Pxyz_c4[0], Pxyz_c4[1], Pxyz_c4[2]);
+    const delta = vec314.fromValues(outMM, outMM, outMM);
+    let Mdc = mat49.fromValues(-1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1);
     if (toRAS) {
-      Mdc = mat46.fromValues(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
-    }
-    mat46.transpose(Mdc, Mdc);
-    const dims = vec48.fromValues(outDim, outDim, outDim, 1);
-    const MdcD = mat46.create();
-    mat46.scale(MdcD, Mdc, delta);
-    const vol_center = vec48.fromValues(dims[0], dims[1], dims[2], 1);
-    vec48.transformMat4(vol_center, vol_center, MdcD);
-    vec48.scale(vol_center, vol_center, 0.5);
-    const translate = vec311.create();
-    vec311.subtract(translate, Pxyz_c, vec311.fromValues(vol_center[0], vol_center[1], vol_center[2]));
-    const out_affine = mat46.create();
-    mat46.transpose(out_affine, MdcD);
+      Mdc = mat49.fromValues(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
+    }
+    mat49.transpose(Mdc, Mdc);
+    const dims = vec49.fromValues(outDim, outDim, outDim, 1);
+    const MdcD = mat49.create();
+    mat49.scale(MdcD, Mdc, delta);
+    const vol_center = vec49.fromValues(dims[0], dims[1], dims[2], 1);
+    vec49.transformMat4(vol_center, vol_center, MdcD);
+    vec49.scale(vol_center, vol_center, 0.5);
+    const translate = vec314.create();
+    vec314.subtract(translate, Pxyz_c, vec314.fromValues(vol_center[0], vol_center[1], vol_center[2]));
+    const out_affine = mat49.create();
+    mat49.transpose(out_affine, MdcD);
     out_affine[3] = translate[0];
     out_affine[7] = translate[1];
     out_affine[11] = translate[2];
-    const inv_out_affine = mat46.create();
-    mat46.invert(inv_out_affine, out_affine);
-    const vox2vox = mat46.create();
-    mat46.mul(vox2vox, affine, inv_out_affine);
-    const inv_vox2vox = mat46.create();
-    mat46.invert(inv_vox2vox, vox2vox);
+    const inv_out_affine = mat49.create();
+    mat49.invert(inv_out_affine, out_affine);
+    const vox2vox = mat49.create();
+    mat49.mul(vox2vox, affine, inv_out_affine);
+    const inv_vox2vox = mat49.create();
+    mat49.invert(inv_vox2vox, vox2vox);
     return [out_affine, vox2vox, inv_vox2vox];
   }
   // Create a binary byte array with a NIfTI format header as well as image data
@@ -31487,6 +32153,97 @@ var Niivue = class {
     }
     return sum;
   }
+  doClickToSegment(options) {
+    const { tileIndex } = options;
+    if (tileIndex < 0 || tileIndex >= this.screenSlices.length) {
+      log.warn(`Invalid tileIndex ${tileIndex} received in doClickToSegment.`);
+      return;
+    }
+    const axCorSag = this.screenSlices[tileIndex].axCorSag;
+    if (axCorSag > 2 /* SAGITTAL */) {
+      log.warn("ClickToSegment attempted on non-2D slice tile.");
+      return;
+    }
+    const texFrac = this.screenXY2TextureFrac(
+      this.clickToSegmentXY[0],
+      // Use the stored click location
+      this.clickToSegmentXY[1],
+      tileIndex,
+      false
+    );
+    if (texFrac[0] < 0) {
+      log.debug("Click location outside valid texture fraction for the tile.");
+      return;
+    }
+    const pt = this.frac2vox(texFrac);
+    const threshold = this.opts.clickToSegmentPercent;
+    let voxelIntensity = this.back.getValue(pt[0], pt[1], pt[2]);
+    if (this.opts.clickToSegmentAutoIntensity) {
+      if (threshold !== 0) {
+        if (voxelIntensity === 0) {
+          voxelIntensity = 0.01;
+        }
+        this.opts.clickToSegmentIntensityMax = voxelIntensity * (1 + threshold);
+        this.opts.clickToSegmentIntensityMin = voxelIntensity * (1 - threshold);
+      }
+      if (voxelIntensity > (this.back.cal_min + this.back.cal_max) * 0.5) {
+        this.opts.clickToSegmentBright = true;
+      } else {
+        this.opts.clickToSegmentBright = false;
+      }
+    }
+    const brightOrDark = this.opts.clickToSegmentBright ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+    this.drawPenAxCorSag = axCorSag;
+    const targetBitmap = this.clickToSegmentIsGrowing ? this.clickToSegmentGrowingBitmap : this.drawBitmap;
+    if (!targetBitmap) {
+      log.error("Target bitmap for flood fill is null.");
+      if (!this.clickToSegmentIsGrowing) {
+        this.createEmptyDrawing();
+        if (!this.drawBitmap) {
+          return;
+        }
+      } else {
+        if (!this.drawBitmap) {
+          this.createEmptyDrawing();
+        }
+        if (!this.drawBitmap) {
+          return;
+        }
+        this.clickToSegmentGrowingBitmap = this.drawBitmap.slice();
+      }
+      log.warn("Initialized missing bitmap in doClickToSegment.");
+    }
+    this.drawFloodFill(
+      [pt[0], pt[1], pt[2]],
+      this.opts.penValue,
+      brightOrDark,
+      this.opts.clickToSegmentIntensityMin,
+      this.opts.clickToSegmentIntensityMax,
+      this.opts.floodFillNeighbors,
+      this.opts.clickToSegmentMaxDistanceMM,
+      this.opts.clickToSegmentIs2D,
+      targetBitmap
+    );
+    if (!this.clickToSegmentIsGrowing) {
+      log.debug("Applying clickToSegment mask to drawBitmap.");
+      if (this.drawBitmap) {
+        this.refreshDrawing(false, false);
+        this.drawScene();
+      } else {
+        log.error("Cannot refresh drawing after click-to-segment apply, drawBitmap is null.");
+      }
+      if (this.drawBitmap) {
+        const info = this.getDescriptives({
+          layer: 0,
+          masks: [],
+          drawingIsMask: true
+          // Use the final this.drawBitmap
+        });
+        this.onClickToSegment({ mL: info.volumeML, mm3: info.volumeMM3 });
+      }
+    }
+    this.createOnLocationChange(axCorSag);
+  }
   // not included in public docs
   // handle mouse click event on canvas
   mouseClick(x, y, posChange = 0, isDelta = true) {
@@ -31533,138 +32290,94 @@ var Niivue = class {
       if (this.drawPenAxCorSag >= 0 && this.drawPenAxCorSag !== axCorSag) {
         continue;
       }
-      if (axCorSag > 2 /* SAGITTAL */) {
+      if (axCorSag > 2 /* SAGITTAL */ && !this.opts.clickToSegment && posChange === 0) {
         continue;
       }
-      let texFrac = this.screenXY2TextureFrac(x, y, i, false);
+      const texFrac = this.screenXY2TextureFrac(x, y, i, true);
       if (texFrac[0] < 0) {
         continue;
       }
-      if (!isDelta) {
-        this.scene.crosshairPos[2 - axCorSag] = posChange;
-        this.drawScene();
-        return;
-      }
-      if (posChange !== 0) {
-        let posNeg = 1;
-        if (posChange < 0) {
-          posNeg = -1;
+      if (posChange !== 0 || !isDelta) {
+        if (!isDelta) {
+          if (axCorSag <= 2 /* SAGITTAL */) {
+            this.scene.crosshairPos[2 - axCorSag] = posChange;
+            this.drawScene();
+            this.createOnLocationChange(axCorSag);
+          }
+          return;
         }
+        const posNeg = posChange < 0 ? -1 : 1;
         const xyz = [0, 0, 0];
-        xyz[2 - axCorSag] = posNeg;
-        this.moveCrosshairInVox(xyz[0], xyz[1], xyz[2]);
-        this.drawScene();
-        this.createOnLocationChange(axCorSag);
+        if (axCorSag <= 2 /* SAGITTAL */) {
+          xyz[2 - axCorSag] = posNeg;
+          this.moveCrosshairInVox(xyz[0], xyz[1], xyz[2]);
+        }
         return;
       }
       if (this.opts.isForceMouseClickToVoxelCenters) {
-        this.scene.crosshairPos = vec311.clone(this.vox2frac(this.frac2vox(texFrac)));
+        this.scene.crosshairPos = vec314.clone(this.vox2frac(this.frac2vox(texFrac)));
       } else {
-        this.scene.crosshairPos = vec311.clone(texFrac);
+        this.scene.crosshairPos = vec314.clone(texFrac);
       }
       if (this.opts.drawingEnabled) {
-        let pt = this.frac2vox(this.scene.crosshairPos);
-        if (this.opts.clickToSegment) {
-          texFrac = this.screenXY2TextureFrac(this.clickToSegmentXY[0], this.clickToSegmentXY[1], i, false);
-          pt = this.frac2vox(texFrac);
-          let diff = 0;
-          let threshold = this.opts.clickToSegmentPercent + diff;
-          if (this.uiData.mousedown) {
-            const xDiff = (this.clickToSegmentXY[0] - x) / this.gl.canvas.width;
-            const yDiff = (this.clickToSegmentXY[1] - y) / this.gl.canvas.height;
-            diff = Math.max(Math.abs(xDiff), Math.abs(yDiff));
-            threshold = this.opts.clickToSegmentPercent + diff;
-          }
-          let voxelIntensity = this.back.getValue(pt[0], pt[1], pt[2]);
-          if (this.opts.clickToSegmentAutoIntensity) {
-            if (threshold !== 0) {
-              if (voxelIntensity === 0) {
-                voxelIntensity = 0.01;
-              }
-              this.opts.clickToSegmentIntensityMax = voxelIntensity * (1 + threshold);
-              this.opts.clickToSegmentIntensityMin = voxelIntensity * (1 - threshold);
-            }
-            if (voxelIntensity > (this.back.cal_min + this.back.cal_max) * 0.5) {
-              this.opts.clickToSegmentBright = true;
-            } else {
-              this.opts.clickToSegmentBright = false;
-            }
-          }
-          const brightOrDark = this.opts.clickToSegmentBright ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
-          this.drawPenAxCorSag = axCorSag;
-          if (this.drawPenAxCorSag === 0 /* AXIAL */) {
-            const pixDims = [this.back.pixDimsRAS[0], this.back.pixDimsRAS[1]];
-            const minPixDim = Math.min(...pixDims);
-            this.opts.penSize = Math.ceil(this.opts.clickToSegmentRadius / minPixDim);
-          } else if (this.drawPenAxCorSag === 1 /* CORONAL */) {
-            const pixDims = [this.back.pixDimsRAS[0], this.back.pixDimsRAS[2]];
-            const minPixDim = Math.min(...pixDims);
-            this.opts.penSize = Math.ceil(this.opts.clickToSegmentRadius / minPixDim);
-          } else if (this.drawPenAxCorSag === 2 /* SAGITTAL */) {
-            const pixDims = [this.back.pixDimsRAS[1], this.back.pixDimsRAS[2]];
-            const minPixDim = Math.min(...pixDims);
-            this.opts.penSize = Math.ceil(this.opts.clickToSegmentRadius / minPixDim);
-          }
-          this.drawPt(pt[0], pt[1], pt[2], this.opts.penValue);
-          if (diff !== 0) {
-            this.clickToSegmentIsGrowing = true;
-            this.clickToSegmentGrowingBitmap = this.drawBitmap.slice();
+        const pt = this.frac2vox(this.scene.crosshairPos);
+        if (!isFinite(this.opts.penValue) || this.opts.penValue < 0 || Object.is(this.opts.penValue, -0)) {
+          let growMode = 0;
+          let floodFillNewColor = Math.abs(this.opts.penValue);
+          const isGrowTool = true;
+          if (Object.is(this.opts.penValue, -0)) {
+            growMode = 0;
+            floodFillNewColor = 0;
+            log.debug("Erase Cluster selected");
           } else {
-            this.clickToSegmentIsGrowing = false;
+            growMode = this.opts.penValue;
+            log.debug("Intensity Grow selected", growMode);
           }
           this.drawFloodFill(
-            [pt[0], pt[1], pt[2]],
-            0,
-            brightOrDark,
-            this.opts.clickToSegmentIntensityMin,
-            this.opts.clickToSegmentIntensityMax,
+            pt,
+            floodFillNewColor,
+            growMode,
+            NaN,
+            NaN,
             this.opts.floodFillNeighbors,
-            this.opts.clickToSegmentMaxDistanceMM,
-            this.opts.clickToSegmentIs2D
+            Number.POSITIVE_INFINITY,
+            false,
+            this.drawBitmap,
+            isGrowTool
           );
           this.drawScene();
           this.createOnLocationChange(axCorSag);
-          if (this.clickToSegmentIsGrowing) {
-            return;
-          }
-          const info = this.getDescriptives({
-            layer: 0,
-            masks: [],
-            drawingIsMask: true
-          });
-          this.onClickToSegment({ mL: info.volumeML, mm3: info.volumeMM3 });
           return;
-        }
-        if (!isFinite(this.opts.penValue) || this.opts.penValue < 0 || Object.is(this.opts.penValue, -0)) {
-          if (!isFinite(this.opts.penValue)) {
-            this.drawFloodFill(pt, 0, this.opts.penValue, NaN, NaN, this.opts.floodFillNeighbors);
-          } else {
-            this.drawFloodFill(
-              pt,
-              Math.abs(this.opts.penValue),
-              this.opts.penValue,
-              NaN,
-              NaN,
-              this.opts.floodFillNeighbors
-            );
+        } else if (this.opts.clickToSegment) {
+          if (axCorSag <= 2 /* SAGITTAL */) {
+            this.clickToSegmentIsGrowing = false;
+            this.doClickToSegment({
+              x: this.clickToSegmentXY[0],
+              y: this.clickToSegmentXY[1],
+              tileIndex: i
+            });
           }
+          this.createOnLocationChange(axCorSag);
           return;
-        }
-        if (isNaN(this.drawPenLocation[0])) {
-          this.drawPenAxCorSag = axCorSag;
-          this.drawPenFillPts = [];
-          this.drawPt(...pt, this.opts.penValue);
         } else {
-          if (pt[0] === this.drawPenLocation[0] && pt[1] === this.drawPenLocation[1] && pt[2] === this.drawPenLocation[2]) {
-            return;
+          if (isNaN(this.drawPenLocation[0])) {
+            this.drawPenAxCorSag = axCorSag;
+            this.drawPenFillPts = [];
+            this.drawPt(...pt, this.opts.penValue);
+          } else {
+            if (pt[0] === this.drawPenLocation[0] && pt[1] === this.drawPenLocation[1] && pt[2] === this.drawPenLocation[2]) {
+              this.drawScene();
+              this.createOnLocationChange(axCorSag);
+              return;
+            }
+            this.drawPenLine(pt, this.drawPenLocation, this.opts.penValue);
           }
-          this.drawPenLine(pt, this.drawPenLocation, this.opts.penValue);
-        }
-        this.drawPenLocation = pt;
-        if (this.opts.isFilledPen) {
-          this.drawPenFillPts.push(pt);
+          this.drawPenLocation = pt;
+          if (this.opts.isFilledPen) {
+            this.drawPenFillPts.push(pt);
+          }
+          this.refreshDrawing(false, false);
         }
-        this.refreshDrawing(false);
       }
       this.drawScene();
       this.createOnLocationChange(axCorSag);
@@ -31755,9 +32468,9 @@ var Niivue = class {
         continue;
       }
       const mm = this.frac2mm(texFrac);
-      return vec48.fromValues(mm[0], mm[1], mm[2], i);
+      return vec49.fromValues(mm[0], mm[1], mm[2], i);
     }
-    return vec48.fromValues(NaN, NaN, NaN, NaN);
+    return vec49.fromValues(NaN, NaN, NaN, NaN);
   }
   // not included in public docs
   dragForPanZoom(startXYendXY) {
@@ -31769,9 +32482,9 @@ var Niivue = class {
     if (isNaN(startMM[0]) || isNaN(endMM[0]) || isNaN(endMM[3])) {
       return;
     }
-    const v = vec48.create();
+    const v = vec49.create();
     const zoom = this.uiData.pan2DxyzmmAtMouseDown[3];
-    vec48.sub(v, endMM, startMM);
+    vec49.sub(v, endMM, startMM);
     this.scene.pan2Dxyzmm[0] = this.uiData.pan2DxyzmmAtMouseDown[0] + zoom * v[0];
     this.scene.pan2Dxyzmm[1] = this.uiData.pan2DxyzmmAtMouseDown[1] + zoom * v[1];
     this.scene.pan2Dxyzmm[2] = this.uiData.pan2DxyzmmAtMouseDown[2] + zoom * v[2];
@@ -31848,12 +32561,12 @@ var Niivue = class {
     let endXY = this.canvasPos2frac([startXYendXY[2], startXYendXY[3]]);
     if (startXY[0] >= 0 && endXY[0] >= 0) {
       const startMm = this.frac2mm(startXY);
-      startXY = vec311.fromValues(startMm[0], startMm[1], startMm[2]);
+      startXY = vec314.fromValues(startMm[0], startMm[1], startMm[2]);
       const endMm = this.frac2mm(endXY);
-      endXY = vec311.fromValues(endMm[0], endMm[1], endMm[2]);
-      const v = vec311.create();
-      vec311.sub(v, startXY, endXY);
-      const lenMM = vec311.len(v);
+      endXY = vec314.fromValues(endMm[0], endMm[1], endMm[2]);
+      const v = vec314.create();
+      vec314.sub(v, startXY, endXY);
+      const lenMM = vec314.len(v);
       let decimals = 2;
       if (lenMM > 9) {
         decimals = 1;
@@ -32393,7 +33106,7 @@ var Niivue = class {
       right = -mn[0];
     }
     const scale = 2 * Math.max(Math.abs(mn[2]), Math.abs(mx[2]));
-    const projectionMatrix = mat46.create();
+    const projectionMatrix = mat49.create();
     let near = 0.01;
     let far = scale * 8;
     if (clipTolerance !== Infinity) {
@@ -32408,19 +33121,19 @@ var Niivue = class {
       near = dx - clipTolerance;
       far = dx + clipTolerance;
     }
-    mat46.ortho(projectionMatrix, left, right, mn[1], mx[1], near, far);
-    const modelMatrix = mat46.create();
+    mat49.ortho(projectionMatrix, left, right, mn[1], mx[1], near, far);
+    const modelMatrix = mat49.create();
     modelMatrix[0] = -1;
-    const translateVec3 = vec311.fromValues(0, 0, -scale * 1.8);
-    mat46.translate(modelMatrix, modelMatrix, translateVec3);
-    mat46.rotateX(modelMatrix, modelMatrix, deg2rad(270 - elevation));
-    mat46.rotateZ(modelMatrix, modelMatrix, deg2rad(azimuth - 180));
-    const iModelMatrix = mat46.create();
-    mat46.invert(iModelMatrix, modelMatrix);
-    const normalMatrix = mat46.create();
-    mat46.transpose(normalMatrix, iModelMatrix);
-    const modelViewProjectionMatrix = mat46.create();
-    mat46.multiply(modelViewProjectionMatrix, projectionMatrix, modelMatrix);
+    const translateVec3 = vec314.fromValues(0, 0, -scale * 1.8);
+    mat49.translate(modelMatrix, modelMatrix, translateVec3);
+    mat49.rotateX(modelMatrix, modelMatrix, deg2rad(270 - elevation));
+    mat49.rotateZ(modelMatrix, modelMatrix, deg2rad(azimuth - 180));
+    const iModelMatrix = mat49.create();
+    mat49.invert(iModelMatrix, modelMatrix);
+    const normalMatrix = mat49.create();
+    mat49.transpose(normalMatrix, iModelMatrix);
+    const modelViewProjectionMatrix = mat49.create();
+    mat49.multiply(modelViewProjectionMatrix, projectionMatrix, modelMatrix);
     return {
       modelViewProjectionMatrix,
       modelMatrix,
@@ -32440,7 +33153,7 @@ var Niivue = class {
   }
   // not included in public docs
   screenFieldOfViewVox(axCorSag = 0) {
-    const fov = vec311.clone(this.volumeObject3D.fieldOfViewDeObliqueMM);
+    const fov = vec314.clone(this.volumeObject3D.fieldOfViewDeObliqueMM);
     return this.swizzleVec3MM(fov, axCorSag);
   }
   // not included in public docs
@@ -32451,25 +33164,25 @@ var Niivue = class {
     }
     const extentsMin = this.volumeObject3D.extentsMin;
     const extentsMax = this.volumeObject3D.extentsMax;
-    let mnMM = vec311.fromValues(extentsMin[0], extentsMin[1], extentsMin[2]);
-    let mxMM = vec311.fromValues(extentsMax[0], extentsMax[1], extentsMax[2]);
+    let mnMM = vec314.fromValues(extentsMin[0], extentsMin[1], extentsMin[2]);
+    let mxMM = vec314.fromValues(extentsMax[0], extentsMax[1], extentsMax[2]);
     mnMM = this.swizzleVec3MM(mnMM, axCorSag);
     mxMM = this.swizzleVec3MM(mxMM, axCorSag);
-    const fovMM = vec311.create();
-    vec311.subtract(fovMM, mxMM, mnMM);
+    const fovMM = vec314.create();
+    vec314.subtract(fovMM, mxMM, mnMM);
     return fovMM;
   }
   // not included in public docs
   screenFieldOfViewExtendedVox(axCorSag = 0) {
     const extentsMinOrtho = this.volumes[0].extentsMinOrtho;
     const extentsMaxOrtho = this.volumes[0].extentsMaxOrtho;
-    let mnMM = vec311.fromValues(extentsMinOrtho[0], extentsMinOrtho[1], extentsMinOrtho[2]);
-    let mxMM = vec311.fromValues(extentsMaxOrtho[0], extentsMaxOrtho[1], extentsMaxOrtho[2]);
-    const rotation = mat46.create();
+    let mnMM = vec314.fromValues(extentsMinOrtho[0], extentsMinOrtho[1], extentsMinOrtho[2]);
+    let mxMM = vec314.fromValues(extentsMaxOrtho[0], extentsMaxOrtho[1], extentsMaxOrtho[2]);
+    const rotation = mat49.create();
     mnMM = this.swizzleVec3MM(mnMM, axCorSag);
     mxMM = this.swizzleVec3MM(mxMM, axCorSag);
-    const fovMM = vec311.create();
-    vec311.subtract(fovMM, mxMM, mnMM);
+    const fovMM = vec314.create();
+    vec314.subtract(fovMM, mxMM, mnMM);
     return { mnMM, mxMM, rotation, fovMM };
   }
   // not included in public docs
@@ -32479,13 +33192,13 @@ var Niivue = class {
     }
     const eMin = this.volumeObject3D.extentsMin;
     const eMax = this.volumeObject3D.extentsMax;
-    let mnMM = vec311.fromValues(eMin[0], eMin[1], eMin[2]);
-    let mxMM = vec311.fromValues(eMax[0], eMax[1], eMax[2]);
-    const rotation = mat46.create();
+    let mnMM = vec314.fromValues(eMin[0], eMin[1], eMin[2]);
+    let mxMM = vec314.fromValues(eMax[0], eMax[1], eMax[2]);
+    const rotation = mat49.create();
     mnMM = this.swizzleVec3MM(mnMM, axCorSag);
     mxMM = this.swizzleVec3MM(mxMM, axCorSag);
-    const fovMM = vec311.create();
-    vec311.subtract(fovMM, mxMM, mnMM);
+    const fovMM = vec314.create();
+    vec314.subtract(fovMM, mxMM, mnMM);
     return { mnMM, mxMM, rotation, fovMM };
   }
   // not included in public docs
@@ -32549,9 +33262,9 @@ var Niivue = class {
     a = this.frac2mm(a);
     b = this.frac2mm(b);
     c = this.frac2mm(c);
-    a = this.swizzleVec3MM(vec311.fromValues(a[0], a[1], a[2]), axCorSag);
-    b = this.swizzleVec3MM(vec311.fromValues(b[0], b[1], b[2]), axCorSag);
-    c = this.swizzleVec3MM(vec311.fromValues(c[0], c[1], c[2]), axCorSag);
+    a = this.swizzleVec3MM(vec314.fromValues(a[0], a[1], a[2]), axCorSag);
+    b = this.swizzleVec3MM(vec314.fromValues(b[0], b[1], b[2]), axCorSag);
+    c = this.swizzleVec3MM(vec314.fromValues(c[0], c[1], c[2]), axCorSag);
     const denom = (b[0] - a[0]) * (c[1] - a[1]) - (c[0] - a[0]) * (b[1] - a[1]);
     let yMult = (b[0] - a[0]) * (c[2] - a[2]) - (c[0] - a[0]) * (b[2] - a[2]);
     yMult /= denom;
@@ -32570,10 +33283,10 @@ var Niivue = class {
   draw2DMain(leftTopWidthHeight, axCorSag, customMM = NaN) {
     let frac2mmTexture = this.volumes[0].frac2mm.slice();
     let screen = this.screenFieldOfViewExtendedMM(axCorSag);
-    let mesh2ortho = mat46.create();
+    let mesh2ortho = mat49.create();
     if (!this.opts.isSliceMM) {
       frac2mmTexture = this.volumes[0].frac2mmOrtho.slice();
-      mesh2ortho = mat46.clone(this.volumes[0].mm2ortho);
+      mesh2ortho = mat49.clone(this.volumes[0].mm2ortho);
       screen = this.screenFieldOfViewExtendedVox(axCorSag);
     }
     let isRadiolgical = this.opts.isRadiologicalConvention && axCorSag < 2 /* SAGITTAL */;
@@ -32616,7 +33329,7 @@ var Niivue = class {
     }
     if (isNaN(customMM)) {
       const pan = this.scene.pan2Dxyzmm;
-      const panXY = this.swizzleVec3MM(vec311.fromValues(pan[0], pan[1], pan[2]), axCorSag);
+      const panXY = this.swizzleVec3MM(vec314.fromValues(pan[0], pan[1], pan[2]), axCorSag);
       const zoom = this.scene.pan2Dxyzmm[3];
       screen.mnMM[0] -= panXY[0];
       screen.mxMM[0] -= panXY[0];
@@ -32731,8 +33444,8 @@ var Niivue = class {
           isRadiolgical
         );
       }
-      const mx = mat46.clone(obj.modelViewProjectionMatrix);
-      mat46.multiply(mx, mx, mesh2ortho);
+      const mx = mat49.clone(obj.modelViewProjectionMatrix);
+      mat49.multiply(mx, mx, mesh2ortho);
       this.drawMesh3D(
         true,
         1,
@@ -32792,29 +33505,29 @@ var Niivue = class {
     const whratio = leftTopWidthHeight[2] / leftTopWidthHeight[3];
     let scale = this.furthestFromPivot;
     const origin = this.pivot3D;
-    const projectionMatrix = mat46.create();
+    const projectionMatrix = mat49.create();
     scale = 0.8 * scale / this.scene.volScaleMultiplier;
     if (whratio < 1) {
-      mat46.ortho(projectionMatrix, -scale, scale, -scale / whratio, scale / whratio, scale * 0.01, scale * 8);
+      mat49.ortho(projectionMatrix, -scale, scale, -scale / whratio, scale / whratio, scale * 0.01, scale * 8);
     } else {
-      mat46.ortho(projectionMatrix, -scale * whratio, scale * whratio, -scale, scale, scale * 0.01, scale * 8);
+      mat49.ortho(projectionMatrix, -scale * whratio, scale * whratio, -scale, scale, scale * 0.01, scale * 8);
     }
-    const modelMatrix = mat46.create();
+    const modelMatrix = mat49.create();
     modelMatrix[0] = -1;
-    const translateVec3 = vec311.fromValues(0, 0, -scale * 1.8);
-    mat46.translate(modelMatrix, modelMatrix, translateVec3);
+    const translateVec3 = vec314.fromValues(0, 0, -scale * 1.8);
+    mat49.translate(modelMatrix, modelMatrix, translateVec3);
     if (this.position) {
-      mat46.translate(modelMatrix, modelMatrix, this.position);
-    }
-    mat46.rotateX(modelMatrix, modelMatrix, deg2rad(270 - elevation));
-    mat46.rotateZ(modelMatrix, modelMatrix, deg2rad(azimuth - 180));
-    mat46.translate(modelMatrix, modelMatrix, [-origin[0], -origin[1], -origin[2]]);
-    const iModelMatrix = mat46.create();
-    mat46.invert(iModelMatrix, modelMatrix);
-    const normalMatrix = mat46.create();
-    mat46.transpose(normalMatrix, iModelMatrix);
-    const modelViewProjectionMatrix = mat46.create();
-    mat46.multiply(modelViewProjectionMatrix, projectionMatrix, modelMatrix);
+      mat49.translate(modelMatrix, modelMatrix, this.position);
+    }
+    mat49.rotateX(modelMatrix, modelMatrix, deg2rad(270 - elevation));
+    mat49.rotateZ(modelMatrix, modelMatrix, deg2rad(azimuth - 180));
+    mat49.translate(modelMatrix, modelMatrix, [-origin[0], -origin[1], -origin[2]]);
+    const iModelMatrix = mat49.create();
+    mat49.invert(iModelMatrix, modelMatrix);
+    const normalMatrix = mat49.create();
+    mat49.transpose(normalMatrix, iModelMatrix);
+    const modelViewProjectionMatrix = mat49.create();
+    mat49.multiply(modelViewProjectionMatrix, projectionMatrix, modelMatrix);
     return [modelViewProjectionMatrix, modelMatrix, normalMatrix];
   }
   // not included in public docs
@@ -32822,13 +33535,13 @@ var Niivue = class {
     if (!this.back) {
       throw new Error("back undefined");
     }
-    const modelMatrix = mat46.create();
+    const modelMatrix = mat49.create();
     modelMatrix[0] = -1;
-    mat46.rotateX(modelMatrix, modelMatrix, deg2rad(270 - elevation));
-    mat46.rotateZ(modelMatrix, modelMatrix, deg2rad(azimuth - 180));
+    mat49.rotateX(modelMatrix, modelMatrix, deg2rad(270 - elevation));
+    mat49.rotateZ(modelMatrix, modelMatrix, deg2rad(azimuth - 180));
     if (this.back.obliqueRAS) {
-      const oblique = mat46.clone(this.back.obliqueRAS);
-      mat46.multiply(modelMatrix, modelMatrix, oblique);
+      const oblique = mat49.clone(this.back.obliqueRAS);
+      mat49.multiply(modelMatrix, modelMatrix, oblique);
     }
     return modelMatrix;
   }
@@ -32836,15 +33549,15 @@ var Niivue = class {
   // calculate the near-far direction from the camera's perspective
   calculateRayDirection(azimuth, elevation) {
     const modelMatrix = this.calculateModelMatrix(azimuth, elevation);
-    const projectionMatrix = mat46.fromValues(1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1);
-    const mvpMatrix = mat46.create();
-    mat46.multiply(mvpMatrix, projectionMatrix, modelMatrix);
-    const inv = mat46.create();
-    mat46.invert(inv, mvpMatrix);
-    const rayDir4 = vec48.fromValues(0, 0, -1, 1);
-    vec48.transformMat4(rayDir4, rayDir4, inv);
-    const rayDir = vec311.fromValues(rayDir4[0], rayDir4[1], rayDir4[2]);
-    vec311.normalize(rayDir, rayDir);
+    const projectionMatrix = mat49.fromValues(1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1);
+    const mvpMatrix = mat49.create();
+    mat49.multiply(mvpMatrix, projectionMatrix, modelMatrix);
+    const inv = mat49.create();
+    mat49.invert(inv, mvpMatrix);
+    const rayDir4 = vec49.fromValues(0, 0, -1, 1);
+    vec49.transformMat4(rayDir4, rayDir4, inv);
+    const rayDir = vec314.fromValues(rayDir4[0], rayDir4[1], rayDir4[2]);
+    vec314.normalize(rayDir, rayDir);
     const tiny = 5e-5;
     if (Math.abs(rayDir[0]) < tiny) {
       rayDir[0] = tiny;
@@ -32859,29 +33572,29 @@ var Niivue = class {
   }
   // not included in public docs
   sceneExtentsMinMax(isSliceMM = true) {
-    let mn = vec311.fromValues(0, 0, 0);
-    let mx = vec311.fromValues(0, 0, 0);
+    let mn = vec314.fromValues(0, 0, 0);
+    let mx = vec314.fromValues(0, 0, 0);
     if (this.volumes.length > 0) {
       if (!this.volumeObject3D) {
         throw new Error("volumeObject3D undefined");
       }
-      mn = vec311.fromValues(
+      mn = vec314.fromValues(
         this.volumeObject3D.extentsMin[0],
         this.volumeObject3D.extentsMin[1],
         this.volumeObject3D.extentsMin[2]
       );
-      mx = vec311.fromValues(
+      mx = vec314.fromValues(
         this.volumeObject3D.extentsMax[0],
         this.volumeObject3D.extentsMax[1],
         this.volumeObject3D.extentsMax[2]
       );
       if (!isSliceMM) {
-        mn = vec311.fromValues(
+        mn = vec314.fromValues(
           this.volumes[0].extentsMinOrtho[0],
           this.volumes[0].extentsMinOrtho[1],
           this.volumes[0].extentsMinOrtho[2]
         );
-        mx = vec311.fromValues(
+        mx = vec314.fromValues(
           this.volumes[0].extentsMaxOrtho[0],
           this.volumes[0].extentsMaxOrtho[1],
           this.volumes[0].extentsMaxOrtho[2]
@@ -32892,33 +33605,33 @@ var Niivue = class {
       if (this.volumes.length < 1) {
         const minExtents = this.meshes[0].extentsMin;
         const maxExtents = this.meshes[0].extentsMax;
-        mn = vec311.fromValues(minExtents[0], minExtents[1], minExtents[2]);
-        mx = vec311.fromValues(maxExtents[0], maxExtents[1], maxExtents[2]);
+        mn = vec314.fromValues(minExtents[0], minExtents[1], minExtents[2]);
+        mx = vec314.fromValues(maxExtents[0], maxExtents[1], maxExtents[2]);
       }
       for (let i = 0; i < this.meshes.length; i++) {
         const minExtents = this.meshes[i].extentsMin;
         const maxExtents = this.meshes[i].extentsMax;
-        const vmn = vec311.fromValues(minExtents[0], minExtents[1], minExtents[2]);
-        vec311.min(mn, mn, vmn);
-        const vmx = vec311.fromValues(maxExtents[0], maxExtents[1], maxExtents[2]);
-        vec311.max(mx, mx, vmx);
+        const vmn = vec314.fromValues(minExtents[0], minExtents[1], minExtents[2]);
+        vec314.min(mn, mn, vmn);
+        const vmx = vec314.fromValues(maxExtents[0], maxExtents[1], maxExtents[2]);
+        vec314.max(mx, mx, vmx);
       }
     }
-    const range = vec311.create();
-    vec311.subtract(range, mx, mn);
+    const range = vec314.create();
+    vec314.subtract(range, mx, mn);
     return [mn, mx, range];
   }
   // not included in public docs
   setPivot3D() {
     const [mn, mx] = this.sceneExtentsMinMax();
-    const pivot = vec311.create();
-    vec311.add(pivot, mn, mx);
-    vec311.scale(pivot, pivot, 0.5);
+    const pivot = vec314.create();
+    vec314.add(pivot, mn, mx);
+    vec314.scale(pivot, pivot, 0.5);
     this.pivot3D = [pivot[0], pivot[1], pivot[2]];
-    vec311.subtract(pivot, mx, mn);
+    vec314.subtract(pivot, mx, mn);
     this.extentsMin = mn;
     this.extentsMax = mx;
-    this.furthestFromPivot = vec311.length(pivot) * 0.5;
+    this.furthestFromPivot = vec314.length(pivot) * 0.5;
   }
   // not included in public docs
   getMaxVols() {
@@ -33253,10 +33966,10 @@ var Niivue = class {
         gl.activeTexture(TEXTURE6_GRADIENT);
         gl.bindTexture(gl.TEXTURE_3D, this.gradientTexture);
         const modelMatrix = this.calculateModelMatrix(azimuth, elevation);
-        const iModelMatrix = mat46.create();
-        mat46.invert(iModelMatrix, modelMatrix);
-        const normalMatrix = mat46.create();
-        mat46.transpose(normalMatrix, iModelMatrix);
+        const iModelMatrix = mat49.create();
+        mat49.invert(iModelMatrix, modelMatrix);
+        const normalMatrix = mat49.create();
+        mat49.transpose(normalMatrix, iModelMatrix);
         gl.uniformMatrix4fv(shader.uniforms.normMtx, false, normalMatrix);
       }
       if (this.drawBitmap && this.drawBitmap.length > 8) {
@@ -33298,23 +34011,23 @@ var Niivue = class {
     gl.cullFace(gl.BACK);
     this.orientCubeShader.use(this.gl);
     gl.bindVertexArray(this.orientCubeShaderVAO);
-    const modelMatrix = mat46.create();
-    const projectionMatrix = mat46.create();
-    mat46.ortho(projectionMatrix, 0, gl.canvas.width, 0, gl.canvas.height, -10 * sz, 10 * sz);
+    const modelMatrix = mat49.create();
+    const projectionMatrix = mat49.create();
+    mat49.ortho(projectionMatrix, 0, gl.canvas.width, 0, gl.canvas.height, -10 * sz, 10 * sz);
     let translateUpForColorbar = 0;
     if (leftTopWidthHeight[1] === 0) {
       translateUpForColorbar = gl.canvas.height - this.effectiveCanvasHeight();
     }
-    mat46.translate(modelMatrix, modelMatrix, [
+    mat49.translate(modelMatrix, modelMatrix, [
       1.8 * sz + leftTopWidthHeight[0],
       translateUpForColorbar + 1.8 * sz + leftTopWidthHeight[1],
       0
     ]);
-    mat46.scale(modelMatrix, modelMatrix, [sz, sz, sz]);
-    mat46.rotateX(modelMatrix, modelMatrix, deg2rad(270 - elevation));
-    mat46.rotateZ(modelMatrix, modelMatrix, deg2rad(-azimuth));
-    const modelViewProjectionMatrix = mat46.create();
-    mat46.multiply(modelViewProjectionMatrix, projectionMatrix, modelMatrix);
+    mat49.scale(modelMatrix, modelMatrix, [sz, sz, sz]);
+    mat49.rotateX(modelMatrix, modelMatrix, deg2rad(270 - elevation));
+    mat49.rotateZ(modelMatrix, modelMatrix, deg2rad(-azimuth));
+    const modelViewProjectionMatrix = mat49.create();
+    mat49.multiply(modelViewProjectionMatrix, projectionMatrix, modelMatrix);
     gl.uniformMatrix4fv(this.orientCubeShader.uniforms.u_matrix, false, modelViewProjectionMatrix);
     gl.drawArrays(gl.TRIANGLE_STRIP, 0, 168);
     gl.bindVertexArray(this.unusedVAO);
@@ -33417,8 +34130,8 @@ var Niivue = class {
   }
   // not included in public docs
   calculateScreenPoint(point, mvpMatrix, leftTopWidthHeight) {
-    const screenPoint = vec48.create();
-    vec48.transformMat4(screenPoint, [...point, 1], mvpMatrix);
+    const screenPoint = vec49.create();
+    vec49.transformMat4(screenPoint, [...point, 1], mvpMatrix);
     if (screenPoint[3] !== 0) {
       screenPoint[0] = (screenPoint[0] / screenPoint[3] + 1) * 0.5 * leftTopWidthHeight[2];
       screenPoint[1] = (1 - screenPoint[1] / screenPoint[3]) * 0.5 * leftTopWidthHeight[3];
@@ -33876,7 +34589,7 @@ var Niivue = class {
   // not included in public docs
   mm2frac(mm, volIdx = 0, isForceSliceMM = false) {
     if (this.volumes.length < 1) {
-      const frac = vec311.fromValues(0.1, 0.5, 0.5);
+      const frac = vec314.fromValues(0.1, 0.5, 0.5);
       const [mn, _mx, range] = this.sceneExtentsMinMax();
       frac[0] = (mm[0] - mn[0]) / range[0];
       frac[1] = (mm[1] - mn[1]) / range[1];
@@ -33932,7 +34645,7 @@ var Niivue = class {
   }
   // not included in public docs
   frac2mm(frac, volIdx = 0, isForceSliceMM = false) {
-    const pos = vec48.fromValues(frac[0], frac[1], frac[2], 1);
+    const pos = vec49.fromValues(frac[0], frac[1], frac[2], 1);
     if (this.volumes.length > 0) {
       return this.volumes[volIdx].convertFrac2MM(frac, isForceSliceMM || this.opts.isSliceMM);
     } else {
@@ -33946,7 +34659,7 @@ var Niivue = class {
   }
   // not included in public docs
   screenXY2TextureFrac(x, y, i, restrict0to1 = true) {
-    const texFrac = vec311.fromValues(-1, -1, -1);
+    const texFrac = vec314.fromValues(-1, -1, -1);
     const axCorSag = this.screenSlices[i].axCorSag;
     if (axCorSag > 2 /* SAGITTAL */) {
       return texFrac;
@@ -33969,7 +34682,7 @@ var Niivue = class {
     if (this.screenSlices[i].AxyzMxy.length < 4) {
       return texFrac;
     }
-    let xyzMM = vec311.fromValues(0, 0, 0);
+    let xyzMM = vec314.fromValues(0, 0, 0);
     xyzMM[0] = this.screenSlices[i].leftTopMM[0] + fracX * this.screenSlices[i].fovMM[0];
     xyzMM[1] = this.screenSlices[i].leftTopMM[1] + fracY * this.screenSlices[i].fovMM[1];
     const v = this.screenSlices[i].AxyzMxy;
@@ -34026,7 +34739,9 @@ var Niivue = class {
       h = this.gl.canvas.width / this.bmpTextureWH;
       w = this.gl.canvas.width;
     }
-    this.gl.uniform4f(this.bmpShader.uniforms.leftTopWidthHeight, 0, 0, w, h);
+    const left = (this.gl.canvas.width - w) / 2;
+    const top = (this.gl.canvas.height - h) / 2;
+    this.gl.uniform4f(this.bmpShader.uniforms.leftTopWidthHeight, left, top, w, h);
     this.gl.bindVertexArray(this.genericVAO);
     this.gl.drawArrays(this.gl.TRIANGLE_STRIP, 0, 4);
     this.gl.bindVertexArray(this.unusedVAO);
@@ -34722,23 +35437,6 @@ var Niivue = class {
       ]);
       return;
     }
-    if (this.opts.clickToSegment) {
-      const x = this.mousePos[0];
-      const y = this.mousePos[1];
-      if (this.inRenderTile(x, y) >= 0) {
-        return;
-      }
-      const tileIdx = this.tileIndex(x, y);
-      if (tileIdx > -1) {
-        const fovMM = this.screenSlices[tileIdx].fovMM;
-        const ltwh = this.screenSlices[tileIdx].leftTopWidthHeight;
-        const pixPerMM = ltwh[2] / fovMM[0];
-        const color = this.opts.crosshairColor;
-        const segmentCursorColor = [color[0], color[1], color[2], 0.4];
-        const radius = this.opts.clickToSegmentRadius * pixPerMM;
-        this.drawCircle([x - radius, y - radius, radius * 2, radius * 2], segmentCursorColor, 1);
-      }
-    }
     const pos = this.frac2mm([this.scene.crosshairPos[0], this.scene.crosshairPos[1], this.scene.crosshairPos[2]]);
     posString = pos[0].toFixed(2) + "\xD7" + pos[1].toFixed(2) + "\xD7" + pos[2].toFixed(2);
     this.readyForSync = true;