@niivue/niivue 0.47.0 → 0.48.0

package/build/index.d.ts

@@ -404,7 +404,8 @@ declare class NVImage {
     readMIF(buffer: ArrayBuffer, pairedImgData: ArrayBuffer | null): ArrayBuffer;
     readNRRD(dataBuffer: ArrayBuffer, pairedImgData: ArrayBuffer | null): ArrayBuffer;
     calculateRAS(): void;
-    img2RAS(): TypedVoxelArray;
+    hdr2RAS(nVolumes?: number): nifti.NIFTI1 | nifti.NIFTI2;
+    img2RAS(nVolume?: number): TypedVoxelArray;
     vox2mm(XYZ: number[], mtx: mat4): vec3;
     mm2vox(mm: number[], frac?: boolean): Float32Array | vec3;
     arrayEquals(a: unknown[], b: unknown[]): boolean;

package/build/index.js

@@ -10,7 +10,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 import { mat4 as mat46, vec2, vec3 as vec311, vec4 as vec48 } from "gl-matrix";
 
 // package.json
-var version = "0.47.0";
+var version = "0.48.0";
 
 // src/logger.ts
 var _Log = class _Log {
@@ -20867,9 +20867,48 @@ var NVImage = class _NVImage {
     this.img2RASstart = outStart;
     this.calculateOblique();
   }
+  // Reorient raw header data to RAS
+  // assume single volume, use nVolumes to specify, set nVolumes = 0 for same as input
+  hdr2RAS(nVolumes = 1) {
+    if (!this.permRAS) {
+      throw new Error("permRAS undefined");
+    }
+    if (!this.hdr) {
+      throw new Error("hdr undefined");
+    }
+    const hdrBytes = hdrToArrayBuffer({ ...this.hdr, vox_offset: 352 }, false);
+    const hdr = nifti.readHeader(hdrBytes.buffer, true);
+    if (nVolumes === 1) {
+      hdr.dims[0] = 3;
+      hdr.dims[4] = 1;
+    } else if (nVolumes > 1) {
+      hdr.dims[0] = 4;
+      hdr.dims[4] = nVolumes;
+    }
+    const perm = this.permRAS.slice();
+    if (perm[0] === 1 && perm[1] === 2 && perm[2] === 3) {
+      return hdr;
+    }
+    hdr.qform_code = 0;
+    for (let i = 1; i < 4; i++) {
+      hdr.dims[i] = this.dimsRAS[i];
+    }
+    for (let i = 0; i < this.pixDimsRAS.length; i++) {
+      hdr.pixDims[i] = this.pixDimsRAS[i];
+    }
+    let k = 0;
+    for (let i = 0; i < 4; i++) {
+      for (let j = 0; j < 4; j++) {
+        hdr.affine[i][j] = this.matRAS[k];
+        k++;
+      }
+    }
+    return hdr;
+  }
   // Reorient raw image data to RAS
   // note that GPU-based orient shader is much faster
-  img2RAS() {
+  // returns single 3D volume even for 4D input. Use nVolume to select volume (0 indexed)
+  img2RAS(nVolume = 0) {
     if (!this.permRAS) {
       throw new Error("permRAS undefined");
     }
@@ -20884,7 +20923,13 @@ var NVImage = class _NVImage {
       return this.img;
     }
     const hdr = this.hdr;
-    const imgRAS = this.img.slice(0, hdr.dims[1] * hdr.dims[1] * hdr.dims[2] * hdr.dims[3]);
+    const nVox = hdr.dims[1] * hdr.dims[2] * hdr.dims[3];
+    let volSkip = nVolume * nVox;
+    if (volSkip + nVox > this.img.length || volSkip < 0) {
+      volSkip = 0;
+      log.warn(`img2RAS nVolume (${nVolume}) out of bounds (${nVolume}+1)\xD7${nVox} > ${this.img.length}`);
+    }
+    const imgRAS = this.img.slice(0, nVox);
     const aperm = [Math.abs(perm[0]), Math.abs(perm[1]), Math.abs(perm[2])];
     const outdim = [hdr.dims[aperm[0]], hdr.dims[aperm[1]], hdr.dims[aperm[2]]];
     const inStep = [1, hdr.dims[1], hdr.dims[1] * hdr.dims[2]];
@@ -20903,7 +20948,7 @@ var NVImage = class _NVImage {
         const yi = outStart[1] + y * outStep[1];
         for (let x = 0; x < outdim[0]; x++) {
           const xi = outStart[0] + x * outStep[0];
-          imgRAS[j] = this.img[xi + yi + zi];
+          imgRAS[j] = this.img[xi + yi + zi + volSkip];
           j++;
         }
       }