@niivue/niivue 0.47.0 → 0.48.1

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.1";
 
 // src/logger.ts
 var _Log = class _Log {
@@ -83,6 +83,13 @@ var compileShader = function(gl, vert, frag) {
   gl.attachShader(program, fs);
   gl.linkProgram(program);
   if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+    console.log(gl.getProgramInfoLog(program));
+    if (!gl.getShaderParameter(vs, gl.COMPILE_STATUS)) {
+      console.log("Vertex shader compilation error:", gl.getShaderInfoLog(vs));
+    }
+    if (!gl.getShaderParameter(fs, gl.COMPILE_STATUS)) {
+      console.log("Fragment shader compilation error:", gl.getShaderInfoLog(fs));
+    }
     log.error(gl.getProgramInfoLog(program));
     throw new Error("Shader failed to link, see console for log");
   }
@@ -1308,9 +1315,11 @@ uniform mat4 mvpMtx;
 uniform mat4 normMtx;
 out vec4 vClr;
 out vec3 vN;
+out vec4 vP;
 out vec4 vPc;
 void main(void) {
 	vec3 lightPosition = vec3(0.0, 0.0, -10.0);
+	vP = vec4(pos, 1.0);
 	vPc = mvpMtx * vec4(pos, 1.0);
 	gl_Position = vPc;
 	vN = normalize((normMtx * vec4(norm.xyz,1.0)).xyz);
@@ -15456,7 +15465,7 @@ var NVMesh2 = class _NVMesh {
     gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.indexBuffer);
     gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, Uint32Array.from(idxs), gl.STATIC_DRAW);
     gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexBuffer);
-    gl.bufferData(gl.ARRAY_BUFFER, Float32Array.from(f32), gl.STATIC_DRAW);
+    gl.bufferData(gl.ARRAY_BUFFER, u8, gl.STATIC_DRAW);
     this.indexCount = nidx;
   }
   // linesToCylinders
@@ -16162,7 +16171,7 @@ var NVMesh2 = class _NVMesh {
     gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.indexBuffer);
     gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, Uint32Array.from(this.tris), gl.STATIC_DRAW);
     gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexBuffer);
-    gl.bufferData(gl.ARRAY_BUFFER, Float32Array.from(posNormClr), gl.STATIC_DRAW);
+    gl.bufferData(gl.ARRAY_BUFFER, u8, gl.STATIC_DRAW);
     this.indexCount = this.tris.length;
     this.vertexCount = this.pts.length;
   }
@@ -20867,9 +20876,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 +20932,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 +20957,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++;
         }
       }