@niivue/niivue 0.24.2 → 0.26.3

package/src/nvimage.js

@@ -52,7 +52,8 @@ export function NVImage(
   ignoreZeroVoxels = false,
   visible = true,
   isDICOMDIR = false,
-  useQFormNotSForm = false
+  useQFormNotSForm = false,
+  colorMapNegative = ""
 ) {
   // https://nifti.nimh.nih.gov/pub/dist/src/niftilib/nifti1.h
   this.DT_NONE = 0;
@@ -84,7 +85,9 @@ export function NVImage(
   this.percentileFrac = percentileFrac;
   this.ignoreZeroVoxels = ignoreZeroVoxels;
   this.trustCalMinMax = trustCalMinMax;
+  this.colorMapNegative = colorMapNegative;
   this.visible = visible;
+  this.modulationImage = null;
   this.series = []; // for concatenating dicom images
 
   // Added to support zerosLike
@@ -143,8 +146,10 @@ export function NVImage(
       this.hdr,
       imgRaw.byteLength
     );
+  //1007 = NIFTI_INTENT_VECTOR; 2003 = NIFTI_INTENT_RGB_VECTOR
+  // n.b. NIfTI standard says "NIFTI_INTENT_RGB_VECTOR" should be RGBA, but FSL only stores RGB
   if (
-    this.hdr.intent_code === 1007 &&
+    (this.hdr.intent_code === 1007 || this.hdr.intent_code === 2003) &&
     this.nFrame4D === 3 &&
     this.hdr.datatypeCode === this.DT_FLOAT
   ) {
@@ -379,7 +384,36 @@ export function NVImage(
   this.calMinMax();
 }
 
+NVImage.prototype.computeObliqueAngle = function (mtx44) {
+  //https://github.com/afni/afni/blob/25e77d564f2c67ff480fa99a7b8e48ec2d9a89fc/src/thd_coords.c#L717
+  let mtx = mat4.clone(mtx44);
+  mat4.transpose(mtx, mtx44);
+  let dxtmp = Math.sqrt(mtx[0] * mtx[0] + mtx[1] * mtx[1] + mtx[2] * mtx[2]);
+  let xmax =
+    Math.max(Math.max(Math.abs(mtx[0]), Math.abs(mtx[1])), Math.abs(mtx[2])) /
+    dxtmp;
+  let dytmp = Math.sqrt(mtx[4] * mtx[4] + mtx[5] * mtx[5] + mtx[6] * mtx[6]);
+  let ymax =
+    Math.max(Math.max(Math.abs(mtx[4]), Math.abs(mtx[5])), Math.abs(mtx[6])) /
+    dytmp;
+  let dztmp = Math.sqrt(mtx[8] * mtx[8] + mtx[9] * mtx[9] + mtx[10] * mtx[10]);
+  let zmax =
+    Math.max(Math.max(Math.abs(mtx[8]), Math.abs(mtx[9])), Math.abs(mtx[10])) /
+    dztmp;
+  let fig_merit = Math.min(Math.min(xmax, ymax), zmax);
+  let oblique_angle = Math.abs((Math.acos(fig_merit) * 180.0) / 3.141592653);
+  if (oblique_angle > 0.01)
+    console.log(
+      "Warning voxels not aligned with world space: " +
+        oblique_angle +
+        " degrees from plumb.\n"
+    );
+  else oblique_angle = 0.0;
+  return oblique_angle;
+};
+
 NVImage.prototype.calculateOblique = function () {
+  this.oblique_angle = this.computeObliqueAngle(this.matRAS);
   let LPI = this.vox2mm([0.0, 0.0, 0.0], this.matRAS);
   let X1mm = this.vox2mm([1.0 / this.pixDimsRAS[1], 0.0, 0.0], this.matRAS);
   let Y1mm = this.vox2mm([0.0, 1.0 / this.pixDimsRAS[2], 0.0], this.matRAS);
@@ -412,6 +446,28 @@ NVImage.prototype.calculateOblique = function () {
   let maxShear = Math.max(Math.max(XY, XZ), YZ);
   if (maxShear > 0.1)
     log.debug("Warning: shear detected (gantry tilt) of %f degrees", maxShear);
+  //compute a matrix to transform vectors from factional space to mm:
+  let dim = vec4.fromValues(
+    this.dimsRAS[1],
+    this.dimsRAS[2],
+    this.dimsRAS[3],
+    1
+  );
+  let sform = mat4.clone(this.matRAS);
+  mat4.transpose(sform, sform);
+  let shim = vec4.fromValues(-0.5, -0.5, -0.5, 0); //bitmap with 5 voxels scaled 0..1, voxel centers are 0.1,0.3,0.5,0.7,0.9
+  mat4.translate(sform, sform, shim);
+  //mat.mat4.scale(sform, sform, dim);
+  sform[0] *= dim[0];
+  sform[1] *= dim[0];
+  sform[2] *= dim[0];
+  sform[4] *= dim[1];
+  sform[5] *= dim[1];
+  sform[6] *= dim[1];
+  sform[8] *= dim[2];
+  sform[9] *= dim[2];
+  sform[10] *= dim[2];
+  this.frac2mm = mat4.clone(sform);
 };
 
 NVImage.prototype.THD_daxes_to_NIFTI = function (
@@ -894,11 +950,12 @@ NVImage.prototype.readMGH = function (buffer) {
   let hdr = this.hdr;
   hdr.dims = [3, 1, 1, 1, 0, 0, 0, 0];
   hdr.pixDims = [1, 1, 1, 1, 1, 0, 0, 0];
-  var reader = new DataView(buffer);
   var raw = buffer;
+  var reader = new DataView(raw);
   if (reader.getUint8(0) === 31 && reader.getUint8(1) === 139) {
-    var raw = fflate.decompressSync(new Uint8Array(buffer));
-    reader = new DataView(raw.buffer);
+    let raw8 = fflate.decompressSync(new Uint8Array(buffer));
+    raw = raw8.buffer;
+    reader = new DataView(raw);
   }
   let version = reader.getInt32(0, false);
   let width = reader.getInt32(4, false);
@@ -2203,6 +2260,7 @@ NVImage.loadFromUrl = async function ({
   percentileFrac = 0.02,
   ignoreZeroVoxels = false,
   visible = true,
+  colorMapNegative = "",
 } = {}) {
   if (url === "") {
     throw Error("url must not be empty");
@@ -2248,7 +2306,10 @@ NVImage.loadFromUrl = async function ({
       trustCalMinMax,
       percentileFrac,
       ignoreZeroVoxels,
-      visible
+      visible,
+      false,
+      false,
+      colorMapNegative
     );
   } else {
     alert("Unable to load buffer properly from volume");
@@ -2586,27 +2647,23 @@ function getExtents(positions, forceOriginInVolume = true) {
  */
 NVImage.prototype.toNiivueObject3D = function (id, gl) {
   //cube has 8 vertices: left/right, posterior/anterior, inferior/superior
-  let LPI = this.vox2mm([0.0, 0.0, 0.0], this.matRAS);
-  //TODO: ray direction needs to be corrected for oblique rotations
-  let LAI = this.vox2mm([0.0, this.dimsRAS[2] - 1, 0.0], this.matRAS);
-  let LPS = this.vox2mm([0.0, 0.0, this.dimsRAS[3] - 1], this.matRAS);
-  let LAS = this.vox2mm(
-    [0.0, this.dimsRAS[2] - 1, this.dimsRAS[3] - 1],
-    this.matRAS
-  );
-  let RPI = this.vox2mm([this.dimsRAS[1] - 1, 0.0, 0.0], this.matRAS);
-  let RAI = this.vox2mm(
-    [this.dimsRAS[1] - 1, this.dimsRAS[2] - 1, 0.0],
-    this.matRAS
-  );
-  let RPS = this.vox2mm(
-    [this.dimsRAS[1] - 1, 0.0, this.dimsRAS[3] - 1],
-    this.matRAS
-  );
-  let RAS = this.vox2mm(
-    [this.dimsRAS[1] - 1, this.dimsRAS[2] - 1, this.dimsRAS[3] - 1],
-    this.matRAS
-  );
+  //n.b. voxel coordinates are from VOXEL centers
+  // add/subtract 0.5 to get full image field of view
+  let L = -0.5;
+  let P = -0.5;
+  let I = -0.5;
+  let R = this.dimsRAS[1] - 1 + 0.5;
+  let A = this.dimsRAS[2] - 1 + 0.5;
+  let S = this.dimsRAS[3] - 1 + 0.5;
+
+  let LPI = this.vox2mm([L, P, I], this.matRAS);
+  let LAI = this.vox2mm([L, A, I], this.matRAS);
+  let LPS = this.vox2mm([L, P, S], this.matRAS);
+  let LAS = this.vox2mm([L, A, S], this.matRAS);
+  let RPI = this.vox2mm([R, P, I], this.matRAS);
+  let RAI = this.vox2mm([R, A, I], this.matRAS);
+  let RPS = this.vox2mm([R, P, S], this.matRAS);
+  let RAS = this.vox2mm([R, A, S], this.matRAS);
 
   let posTex = [
     //spatial position (XYZ), texture coordinates UVW
@@ -2709,7 +2766,6 @@ NVImage.prototype.toNiivueObject3D = function (id, gl) {
     indexBuffer,
     vao
   );
-
   const extents = getExtents([
     ...LPS,
     ...RPS,
@@ -2720,10 +2776,56 @@ NVImage.prototype.toNiivueObject3D = function (id, gl) {
     ...RAI,
     ...RPI,
   ]);
-  obj3D.extentsMin = extents.min;
-  obj3D.extentsMax = extents.max;
+  obj3D.extentsMin = extents.min.slice();
+  obj3D.extentsMax = extents.max.slice();
+
   obj3D.furthestVertexFromOrigin = extents.furthestVertexFromOrigin;
   obj3D.originNegate = vec3.clone(extents.origin);
   vec3.negate(obj3D.originNegate, obj3D.originNegate);
+  /*
+  let matDeOblique = mat4.fromValues(
+    this.pixDimsRAS[1],
+    0,
+    0,
+    this.matRAS[3],
+    0,
+    this.pixDimsRAS[2],
+    0,
+    this.matRAS[7],
+    0,
+    0,
+    this.pixDimsRAS[3],
+    this.matRAS[11],
+    0,
+    0,
+    0,
+    1
+  );
+  LPI = this.vox2mm([L,P,I], matDeOblique);
+  LAI = this.vox2mm([L,A,I], matDeOblique);
+  LPS = this.vox2mm([L,P,S], matDeOblique);
+  LAS = this.vox2mm([L,A,S], matDeOblique);
+  RPI = this.vox2mm([R,P,I], matDeOblique);
+  RAI = this.vox2mm([R,A,I], matDeOblique);
+  RPS = this.vox2mm([R,P,S], matDeOblique);
+  RAS = this.vox2mm([R,A,S], matDeOblique);
+  const extentsDeOblique = getExtents([
+    ...LPS,
+    ...RPS,
+    ...RAS,
+    ...LAS,
+    ...LPI,
+    ...LAI,
+    ...RAI,
+    ...RPI,
+  ]);
+  obj3D.extentsDeObliqueMin = extentsDeOblique.min.slice();
+  obj3D.extentsDeObliqueMax = extentsDeOblique.max.slice();
+*/
+  obj3D.fieldOfViewDeObliqueMM = [
+    this.dimsRAS[1] * this.pixDimsRAS[1],
+    this.dimsRAS[2] * this.pixDimsRAS[2],
+    this.dimsRAS[3] * this.pixDimsRAS[3],
+  ];
   return obj3D;
 };

package/src/nvmesh.js

@@ -1394,7 +1394,8 @@ NVMesh.readVTK = function (buffer) {
   if (!line.startsWith("# vtk DataFile")) alert("Invalid VTK mesh");
   line = readStr(); //2nd line comment
   line = readStr(); //3rd line ASCII/BINARY
-  if (line.startsWith("ASCII")) return readTxtVTK(buffer); //from NiiVue
+  if (line.startsWith("ASCII")) return readTxtVTK(buffer);
+  //from NiiVue
   else if (!line.startsWith("BINARY"))
     alert("Invalid VTK image, expected ASCII or BINARY", line);
   line = readStr(); //5th line "DATASET POLYDATA"
@@ -1754,18 +1755,28 @@ NVMesh.readPLY = function (buffer) {
     }
     let indices = new Int32Array(nface * 3);
     let f = 0;
-    let isTriangular = true;
     for (var i = 0; i < nface; i++) {
       line = readStr();
       let items = line.split(/\s/);
-      if (parseInt(items[0]) > 3) isTriangular = false;
-      indices[f] = parseInt(items[1]);
-      indices[f + 1] = parseInt(items[2]);
-      indices[f + 2] = parseInt(items[3]);
-      f += 3;
-    }
-    if (!isTriangular)
-      console.log("Only able to read PLY meshes limited to triangles.");
+      let nTri = parseInt(items[0]) - 2;
+      if (nTri < 1) break; //error
+      if (f + nTri * 3 > indices.length) {
+        var c = new Int32Array(indices.length + indices.length);
+        c.set(indices);
+        indices = c.slice();
+      }
+      let idx0 = parseInt(items[1]);
+      let idx1 = parseInt(items[2]);
+      for (let j = 0; j < nTri; j++) {
+        let idx2 = parseInt(items[3 + j]);
+        indices[f + 0] = idx0;
+        indices[f + 1] = idx1;
+        indices[f + 2] = idx2;
+        idx1 = idx2;
+        f += 3;
+      }
+    }
+    if (indices.length !== f) indices = indices.slice(0, f);
     return {
       positions,
       indices,
@@ -1963,12 +1974,20 @@ NVMesh.readOBJ = function (buffer) {
     }
     if (str[0] === "f") {
       let items = str.split(" ");
+      let new_t = items.length - 3; //number of new triangles created
+      if (new_t < 1) break; //error
       let tn = items[1].split("/");
-      t.push(parseInt(tn - 1));
+      let t0 = parseInt(tn[0]) - 1; //first vertex
       tn = items[2].split("/");
-      t.push(parseInt(tn - 1));
-      tn = items[3].split("/");
-      t.push(parseInt(tn - 1));
+      let tprev = parseInt(tn[0]) - 1; //previous vertex
+      for (let j = 0; j < new_t; j++) {
+        tn = items[3 + j].split("/");
+        let tcurr = parseInt(tn[0]) - 1; //current vertex
+        t.push(t0);
+        t.push(tprev);
+        t.push(tcurr);
+        tprev = tcurr;
+      }
     }
   } //for all lines
   var positions = new Float32Array(pts);