@niivue/niivue 0.60.0 → 0.61.0

package/build/index.js

@@ -19,7 +19,7 @@ import { mat4 as mat49, vec2, vec3 as vec314, vec4 as vec410 } from "gl-matrix";
 // package.json
 var package_default = {
   name: "@niivue/niivue",
-  version: "0.60.0",
+  version: "0.61.0",
   description: "minimal webgl2 nifti image viewer",
   types: "./build/index.d.ts",
   main: "./build/index.js",
@@ -12224,7 +12224,7 @@ var NVUtilities = class _NVUtilities {
       }
       return new Float64Array(byteArray.buffer);
     }
-    function readTag() {
+    function readTag2() {
       const mtype = reader.getUint32(pos, true);
       const mrows = reader.getUint32(pos + 4, true);
       const ncols = reader.getUint32(pos + 8, true);
@@ -12263,7 +12263,7 @@ var NVUtilities = class _NVUtilities {
       pos = posEnd;
     }
     while (pos + 20 < len) {
-      readTag();
+      readTag2();
     }
     return mat;
   }
@@ -16857,37 +16857,133 @@ function setVolumeData(nvImage, voxStartRAS = [-1, 0, 0], voxEndRAS = [0, 0, 0],
 // src/nvimage/ImageReaders/mgh.ts
 var mgh_exports = {};
 __export(mgh_exports, {
+  isFreeSurferLabelImage: () => isFreeSurferLabelImage,
+  optimizeFreeSurferLabels: () => optimizeFreeSurferLabels,
   readMgh: () => readMgh
 });
 import { NIFTI1 as NIFTI12 } from "nifti-reader-js";
 import { mat4 as mat44, vec4 as vec45, vec3 as vec36 } from "gl-matrix";
-function readFirstTag1String(view, offset, footerLength) {
+function readTag(view, offset, footerLength, tagToRead = 1) {
   const end = offset + footerLength;
   let pos = offset;
+  const results = [];
   while (pos + 12 <= end) {
     const tag = view.getInt32(pos, false);
     const length = view.getInt32(pos + 8, false);
     pos += 12;
-    if (tag !== 1) {
+    if (length <= 0 || pos + length > end) {
+      break;
+    }
+    if (tag !== tagToRead) {
       pos += length;
       continue;
     }
-    if (pos + 4 > end) {
-      return "";
+    let strLen = length;
+    let contentPos = pos;
+    if (tagToRead === 1) {
+      if (pos + 4 > end) {
+        break;
+      }
+      strLen = view.getInt32(pos, false);
+      contentPos += 4;
+    }
+    if (strLen > 1 && contentPos + strLen <= end) {
+      const raw = new Uint8Array(view.buffer, contentPos, strLen);
+      const str = new TextDecoder("utf-8").decode(raw.slice(0, -1));
+      results.push(str);
     }
-    const strLen = view.getInt32(pos, false);
-    pos += 4;
-    if (strLen <= 1 || pos + strLen > end) {
-      return "";
+    pos += length;
+  }
+  return results.join("\n\n");
+}
+function optimizeFreeSurferLabels(hdr, imgRaw) {
+  hdr.intent_code = 1002;
+  if (hdr.datatypeCode !== 16 /* DT_FLOAT32 */ && hdr.datatypeCode !== 8 /* DT_INT32 */) {
+    return imgRaw;
+  }
+  let img = new Float32Array(imgRaw);
+  if (hdr.datatypeCode === 8 /* DT_INT32 */) {
+    img = new Int32Array(imgRaw);
+  }
+  if (isPlatformLittleEndian()) {
+    const u32 = new Uint32Array(imgRaw);
+    for (let i = 0; i < u32.length; i++) {
+      const val = u32[i];
+      u32[i] = (val & 255) << 24 | (val & 65280) << 8 | (val & 16711680) >>> 8 | (val & 4278190080) >>> 24;
+    }
+  }
+  hdr.littleEndian = isPlatformLittleEndian();
+  let isInteger = true;
+  let mn = Infinity;
+  let mx = -Infinity;
+  for (let i = 0; i < img.length; i++) {
+    const v = img[i];
+    if (!Number.isFinite(v)) {
+      continue;
+    }
+    if (!Number.isInteger(v)) {
+      isInteger = false;
+    }
+    if (v < mn) {
+      mn = v;
     }
-    const raw = new Uint8Array(view.buffer, pos, strLen);
-    return new TextDecoder("utf-8").decode(raw.slice(0, -1));
+    if (v > mx) {
+      mx = v;
+    }
+  }
+  if (!isInteger || mn < 0 || mx > 2147483647) {
+    log.warn(`FreeSurfer Labels must be integers in INT32 range. range ${mn}..${mx}`);
+    return imgRaw;
+  }
+  if (mx > 32767) {
+    hdr.datatypeCode = 8 /* DT_INT32 */;
+    const out = new Int32Array(img.length);
+    for (let i = 0; i < img.length; i++) {
+      out[i] = Math.trunc(img[i]);
+    }
+    return out.buffer;
+  } else if (mx > 255) {
+    hdr.datatypeCode = 4 /* DT_INT16 */;
+    hdr.numBitsPerVoxel = 16;
+    const out = new Int16Array(img.length);
+    for (let i = 0; i < img.length; i++) {
+      out[i] = Math.trunc(img[i]);
+    }
+    return out.buffer;
+  } else {
+    hdr.datatypeCode = 2 /* DT_UINT8 */;
+    hdr.numBitsPerVoxel = 8;
+    const out = new Uint8Array(img.length);
+    for (let i = 0; i < img.length; i++) {
+      out[i] = Math.trunc(img[i]);
+    }
+    return out.buffer;
   }
-  return "";
+}
+function isFreeSurferLabelImage(raw, hdr, expectedBytes) {
+  const remainingBytes = raw.byteLength - hdr.vox_offset;
+  if (remainingBytes < expectedBytes) {
+    log.error(`MGH image data size mismatch: expected ${expectedBytes}, found ${remainingBytes}`);
+    return false;
+  }
+  if (remainingBytes === expectedBytes) {
+    return false;
+  }
+  const footerStart = hdr.vox_offset + expectedBytes + 20;
+  const footerLength = raw.byteLength - footerStart;
+  if (footerLength <= 12) {
+    return false;
+  }
+  const tag1 = readTag(new DataView(raw), footerStart, footerLength);
+  if (tag1.toLowerCase().endsWith("lut.txt")) {
+    return true;
+  }
+  const tag3 = readTag(new DataView(raw), footerStart, footerLength, 3);
+  return tag3.includes("mri_label2vol");
 }
 async function readMgh(nvImage, buffer) {
   if (!nvImage.hdr) {
-    log.warn("readMgh called before nvImage.hdr was initialized. Creating default.");
+    log.debug("readMgh called before nvImage.hdr was initialized. Creating default.");
     nvImage.hdr = new NIFTI12();
   }
   const hdr = nvImage.hdr;
@@ -17000,24 +17096,10 @@ async function readMgh(nvImage, buffer) {
   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 footerStart = hdr.vox_offset + expectedBytes + 20;
-    const footerLength = raw.byteLength - footerStart;
-    if (footerLength > 12) {
-      const firstTag1String = readFirstTag1String(reader, footerStart, footerLength);
-      const isLUT = firstTag1String.toLowerCase().endsWith("lut.txt");
-      if (isLUT) {
-        hdr.intent_code = 1002;
-      }
-      log.debug(`First tag 1 string: ${firstTag1String} isLUT: ${isLUT}`);
-    }
-  }
   const imgRaw = raw.slice(hdr.vox_offset, hdr.vox_offset + expectedBytes);
+  if (isFreeSurferLabelImage(raw, hdr, expectedBytes)) {
+    return optimizeFreeSurferLabels(hdr, imgRaw);
+  }
   return imgRaw;
 }
 
@@ -19075,11 +19157,12 @@ var NVImage = class _NVImage {
     if (len < 20) {
       throw new Error("File too small to be MIF: bytes = " + len);
     }
-    const bytes = new Uint8Array(buffer);
+    let bytes = new Uint8Array(buffer);
     if (bytes[0] === 31 && bytes[1] === 139) {
       log.debug("MIF with GZ decompression");
       buffer = await NVUtilities.decompressToBuffer(new Uint8Array(buffer));
       len = buffer.byteLength;
+      bytes = new Uint8Array(buffer);
     }
     let pos = 0;
     function readStr() {
@@ -29370,6 +29453,7 @@ var Niivue = class {
         this.renderShader = this.renderSliceShader;
       }
     }
+    await this.refreshLayers(this.volumes[0], 0);
     this.initRenderShader(this.renderShader, gradientAmount);
     this.renderShader.use(this.gl);
     this.setClipPlaneColor(this.opts.clipPlaneColor);
@@ -29381,7 +29465,6 @@ var Niivue = class {
     if (this.volumes.length < 1) {
       return;
     }
-    this.refreshLayers(this.volumes[0], 0);
     this.drawScene();
   }
   /**
@@ -31658,17 +31741,9 @@ var Niivue = class {
    */
   gradientGL(hdr) {
     const gl = this.gl;
-    const faceStrip = [0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0];
-    const vao2 = gl.createVertexArray();
-    gl.bindVertexArray(vao2);
-    const vbo2 = gl.createBuffer();
-    gl.bindBuffer(gl.ARRAY_BUFFER, vbo2);
-    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(faceStrip), gl.STATIC_DRAW);
-    gl.enableVertexAttribArray(0);
-    gl.vertexAttribPointer(0, 3, gl.FLOAT, false, 0, 0);
+    gl.bindVertexArray(this.genericVAO);
     const fb = gl.createFramebuffer();
     gl.bindFramebuffer(gl.FRAMEBUFFER, fb);
-    gl.disable(gl.CULL_FACE);
     gl.viewport(0, 0, hdr.dims[1], hdr.dims[2]);
     gl.disable(gl.BLEND);
     const tempTex3D = this.rgbaTex(null, TEXTURE8_GRADIENT_TEMP, hdr.dims, true);
@@ -31676,27 +31751,30 @@ var Niivue = class {
     blurShader.use(gl);
     gl.activeTexture(TEXTURE0_BACK_VOL);
     gl.bindTexture(gl.TEXTURE_3D, this.volumeTexture);
+    gl.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
     const blurRadius = 0.7;
     gl.uniform1i(blurShader.uniforms.intensityVol, 0);
     gl.uniform1f(blurShader.uniforms.dX, blurRadius / hdr.dims[1]);
     gl.uniform1f(blurShader.uniforms.dY, blurRadius / hdr.dims[2]);
     gl.uniform1f(blurShader.uniforms.dZ, blurRadius / hdr.dims[3]);
-    gl.bindVertexArray(vao2);
     for (let i = 0; i < hdr.dims[3] - 1; i++) {
       const coordZ = 1 / hdr.dims[3] * (i + 0.5);
       gl.uniform1f(blurShader.uniforms.coordZ, coordZ);
       gl.framebufferTextureLayer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, tempTex3D, 0, i);
       const status = gl.checkFramebufferStatus(gl.FRAMEBUFFER);
       if (status !== gl.FRAMEBUFFER_COMPLETE) {
-        log.error("framebuffer status: ", status);
+        log.error("blur shader: ", status);
       }
       gl.clear(gl.DEPTH_BUFFER_BIT);
-      gl.drawArrays(gl.TRIANGLE_STRIP, 0, faceStrip.length / 3);
+      gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
     }
     const sobelShader = this.opts.gradientOrder === 2 ? this.sobelSecondOrderShader : this.sobelFirstOrderShader;
     sobelShader.use(gl);
     gl.activeTexture(TEXTURE8_GRADIENT_TEMP);
     gl.bindTexture(gl.TEXTURE_3D, tempTex3D);
+    gl.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
     gl.uniform1i(sobelShader.uniforms.intensityVol, 8);
     const sobelRadius = 0.7;
     gl.uniform1f(sobelShader.uniforms.dX, sobelRadius / hdr.dims[1]);
@@ -31708,7 +31786,6 @@ var Niivue = class {
       gl.uniform1f(sobelShader.uniforms.dZ2, 2 * sobelRadius / hdr.dims[3]);
     }
     gl.uniform1f(sobelShader.uniforms.coordZ, 0.5);
-    gl.bindVertexArray(vao2);
     if (this.gradientTexture !== null) {
       gl.deleteTexture(this.gradientTexture);
     }
@@ -31719,15 +31796,15 @@ var Niivue = class {
       gl.framebufferTextureLayer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, this.gradientTexture, 0, i);
       const status = gl.checkFramebufferStatus(gl.FRAMEBUFFER);
       if (status !== gl.FRAMEBUFFER_COMPLETE) {
-        log.error("framebuffer status: ", status);
+        log.error("sobel shader: ", status);
       }
       gl.clear(gl.DEPTH_BUFFER_BIT);
-      gl.drawArrays(gl.TRIANGLE_STRIP, 0, faceStrip.length / 3);
+      gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
     }
     gl.deleteFramebuffer(fb);
     gl.deleteTexture(tempTex3D);
-    gl.deleteBuffer(vbo2);
     gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    this.gl.bindVertexArray(this.unusedVAO);
   }
   /**
    * Get the gradient texture produced by gradientGL as a TypedArray
@@ -32594,6 +32671,7 @@ var Niivue = class {
       this.volumeTexture = outTexture;
       if (this.gradientTextureAmount > 0 && !this.useCustomGradientTexture) {
         this.gradientGL(hdr);
+        this.gl.bindVertexArray(this.genericVAO);
       } else if (this.gradientTextureAmount <= 0) {
         if (this.gradientTexture !== null) {
           this.gl.deleteTexture(this.gradientTexture);
@@ -32608,7 +32686,7 @@ var Niivue = class {
     const slicescl = this.sliceScale(true);
     const vox = slicescl.vox;
     const volScale = slicescl.volScale;
-    this.gl.uniform1f(this.renderShader.uniforms.overlays, this.overlays);
+    this.gl.uniform1f(this.renderShader.uniforms.overlays, this.overlays.length);
     this.gl.uniform4fv(this.renderShader.uniforms.clipPlaneColor, this.opts.clipPlaneColor);
     this.gl.uniform1f(this.renderShader.uniforms.clipThick, this.opts.clipThick);
     this.gl.uniform3fv(this.renderShader.uniforms.clipLo, this.opts.clipVolumeLow);
@@ -35950,7 +36028,7 @@ var Niivue = class {
       }
       shader.use(this.gl);
       gl.uniform1i(shader.uniforms.backgroundMasksOverlays, this.backgroundMasksOverlays);
-      if (this.gradientTextureAmount > 0) {
+      if (this.gradientTextureAmount > 0 && shader.uniforms.normMtx && this.gradientTexture) {
         gl.activeTexture(TEXTURE6_GRADIENT);
         gl.bindTexture(gl.TEXTURE_3D, this.gradientTexture);
         const modelMatrix = this.calculateModelMatrix(azimuth, elevation);