@aics/vole-core 3.12.4

package/es/MeshVolume.js

@@ -0,0 +1,334 @@
+import { Object3D, Vector3, Color, Mesh, Group, Material, MeshPhongMaterial, Plane, DoubleSide } from "three";
+import { STLExporter } from "three/examples/jsm/exporters/STLExporter.js";
+import { GLTFExporter } from "three/examples/jsm/exporters/GLTFExporter.js";
+import { defaultMaterialSettings } from "./constants/materials.js";
+import FileSaver from "./FileSaver.js";
+import NaiveSurfaceNets from "./NaiveSurfaceNets.js";
+import MarchingCubes from "./MarchingCubes.js";
+import { MESH_LAYER } from "./ThreeJsPanel.js";
+
+/**
+ * this cutoff is chosen to have a small buffer of values before the object is treated
+ * as transparent for gpu blending and depth testing.
+ */
+const ALPHA_THRESHOLD = 0.95;
+export default class MeshVolume {
+  constructor(volume) {
+    // need?
+    this.volume = volume;
+    this.meshRoot = new Object3D(); //create an empty container
+    this.meshRoot.name = "Mesh Surface Group";
+
+    // handle transform ordering for giving the meshroot a rotation about a pivot point
+    this.meshPivot = new Group();
+    this.meshPivot.name = "MeshContainerNode";
+    this.meshPivot.add(this.meshRoot);
+    this.meshrep = [];
+    this.channelColors = [];
+    this.channelOpacities = [];
+    this.scale = new Vector3(1, 1, 1);
+    this.bounds = {
+      bmin: new Vector3(-0.5, -0.5, -0.5),
+      bmax: new Vector3(0.5, 0.5, 0.5)
+    };
+  }
+  cleanup() {
+    for (let i = 0; i < this.volume.imageInfo.numChannels; ++i) {
+      this.destroyIsosurface(i);
+    }
+  }
+  setVisible(isVisible) {
+    this.meshRoot.visible = isVisible;
+  }
+  doRender() {
+    // no op
+  }
+  get3dObject() {
+    return this.meshPivot;
+  }
+  setScale(scale, position = new Vector3(0, 0, 0)) {
+    this.scale = scale;
+    this.meshRoot.scale.copy(scale).multiplyScalar(0.5);
+    this.meshRoot.position.copy(position);
+  }
+  setFlipAxes(flipX, flipY, flipZ) {
+    this.meshRoot.scale.copy(new Vector3(0.5 * this.scale.x * flipX, 0.5 * this.scale.y * flipY, 0.5 * this.scale.z * flipZ));
+  }
+  setTranslation(vec3xyz) {
+    this.meshPivot.position.copy(vec3xyz);
+  }
+  setRotation(eulerXYZ) {
+    this.meshPivot.rotation.copy(eulerXYZ);
+    this.updateClipFromBounds();
+  }
+  setResolution(_x, _y) {
+    // no op
+  }
+  setOrthoThickness(_value) {
+    // no op
+  }
+  setAxisClip(axis, minval, maxval, _isOrthoAxis) {
+    this.bounds.bmax[axis] = maxval;
+    this.bounds.bmin[axis] = minval;
+    this.updateClipFromBounds();
+  }
+
+  //////////////////////////////
+
+  updateMeshColors(channelColors) {
+    // stash values here for later changes
+    this.channelColors = channelColors;
+
+    // update existing meshes
+    for (let i = 0; i < this.volume.imageInfo.numChannels; ++i) {
+      const meshrep = this.meshrep[i];
+      if (meshrep) {
+        const rgb = channelColors[i];
+        const c = rgb[0] << 16 | rgb[1] << 8 | rgb[2];
+        meshrep.traverse(function (child) {
+          if (child instanceof Mesh) {
+            child.material.color = new Color(c);
+          }
+        });
+      }
+    }
+  }
+  createMaterialForChannel(rgb, alpha, _transp) {
+    const col = rgb[0] << 16 | rgb[1] << 8 | rgb[2];
+    const material = new MeshPhongMaterial({
+      color: new Color(col),
+      shininess: defaultMaterialSettings.shininess,
+      specular: new Color(defaultMaterialSettings.specularColor),
+      opacity: alpha,
+      transparent: alpha < ALPHA_THRESHOLD,
+      side: DoubleSide
+    });
+    return material;
+  }
+  createMeshForChannel(channelIndex, colorrgb, isovalue, alpha, transp) {
+    // note that if isovalue out of range, this will return an empty array.
+    const geometries = this.generateIsosurfaceGeometry(channelIndex, isovalue);
+    const material = this.createMaterialForChannel(colorrgb, alpha, transp);
+    const theObject = new Group();
+    theObject.name = "Channel" + channelIndex;
+    theObject.userData = {
+      isovalue: isovalue
+    };
+    // proper scaling will be done in parent object
+    for (let i = 0; i < geometries.length; ++i) {
+      const mesh = new Mesh(geometries[i], material);
+      mesh.layers.set(MESH_LAYER);
+      theObject.add(mesh);
+    }
+    return theObject;
+  }
+  updateIsovalue(channel, value) {
+    const meshrep = this.meshrep[channel];
+    if (!meshrep) {
+      return;
+    }
+    if (meshrep.userData.isovalue === value) {
+      return;
+    }
+
+    // find the current isosurface opacity and color.
+    const opacity = this.channelOpacities[channel];
+    const color = this.channelColors[channel];
+    this.destroyIsosurface(channel);
+    const newmeshrep = this.createMeshForChannel(channel, color, value, opacity, false);
+    this.meshrep[channel] = newmeshrep;
+    this.meshRoot.add(newmeshrep);
+  }
+  getIsovalue(channel) {
+    const meshrep = this.meshrep[channel];
+    return meshrep?.userData.isovalue;
+  }
+  getOpacity(channel) {
+    const meshrep = this.meshrep[channel];
+    let opacity = undefined;
+    meshrep?.traverse(obj => {
+      if (obj instanceof Mesh) {
+        opacity = obj.material.opacity;
+      }
+    });
+    return opacity;
+  }
+  updateClipRegion(xmin, xmax, ymin, ymax, zmin, zmax) {
+    // incoming values expected to be between 0 and 1.
+    // I shift them here to be between -0.5 and 0.5
+    this.bounds = {
+      bmin: new Vector3(xmin - 0.5, ymin - 0.5, zmin - 0.5),
+      bmax: new Vector3(xmax - 0.5, ymax - 0.5, zmax - 0.5)
+    };
+    this.updateClipFromBounds();
+  }
+  updateClipFromBounds() {
+    const xmin = this.bounds.bmin.x;
+    const ymin = this.bounds.bmin.y;
+    const zmin = this.bounds.bmin.z;
+    const xmax = this.bounds.bmax.x;
+    const ymax = this.bounds.bmax.y;
+    const zmax = this.bounds.bmax.z;
+    const euler = this.meshPivot.rotation;
+    for (let channel = 0; channel < this.meshrep.length; ++channel) {
+      const meshrep = this.meshrep[channel];
+      if (!meshrep) {
+        continue;
+      }
+      const planes = [];
+      // up to 6 planes.
+      if (xmin > -0.5) {
+        planes.push(new Plane(new Vector3(1, 0, 0).applyEuler(euler), this.meshRoot.position.x + -xmin * this.scale.x));
+      }
+      if (ymin > -0.5) {
+        planes.push(new Plane(new Vector3(0, 1, 0).applyEuler(euler), this.meshRoot.position.y + -ymin * this.scale.y));
+      }
+      if (zmin > -0.5) {
+        planes.push(new Plane(new Vector3(0, 0, 1).applyEuler(euler), this.meshRoot.position.z + -zmin * this.scale.z));
+      }
+      if (xmax < 0.5) {
+        planes.push(new Plane(new Vector3(-1, 0, 0).applyEuler(euler), this.meshRoot.position.x + xmax * this.scale.x));
+      }
+      if (ymax < 0.5) {
+        planes.push(new Plane(new Vector3(0, -1, 0).applyEuler(euler), this.meshRoot.position.y + ymax * this.scale.y));
+      }
+      if (zmax < 0.5) {
+        planes.push(new Plane(new Vector3(0, 0, -1).applyEuler(euler), this.meshRoot.position.z + zmax * this.scale.z));
+      }
+      meshrep.traverse(function (child) {
+        if (child instanceof Mesh) {
+          child.material.clippingPlanes = planes;
+        }
+      });
+    }
+  }
+  updateOpacity(channel, value) {
+    this.channelOpacities[channel] = value;
+    const meshrep = this.meshrep[channel];
+    if (!meshrep) {
+      return;
+    }
+    meshrep.traverse(function (child) {
+      if (child instanceof Mesh) {
+        child.material.opacity = value;
+        child.material.transparent = value < ALPHA_THRESHOLD;
+        //child.material.depthWrite = !child.material.transparent;
+      }
+    });
+  }
+  hasIsosurface(channel) {
+    return !!this.meshrep[channel];
+  }
+  createIsosurface(channel, color,
+  // 127 is half of the intensity range 0..255
+  value = 127,
+  // 1.0 indicates full opacity, non-transparent
+  alpha = 1.0, transp = alpha < ALPHA_THRESHOLD) {
+    if (!this.meshrep[channel]) {
+      const meshrep = this.createMeshForChannel(channel, color, value, alpha, transp);
+      this.meshrep[channel] = meshrep;
+      this.channelOpacities[channel] = alpha;
+      this.channelColors[channel] = color;
+      // note we are not removing any prior mesh reps for this channel
+      this.meshRoot.add(meshrep);
+    }
+  }
+  destroyIsosurface(channel) {
+    const meshrep = this.meshrep[channel];
+    if (meshrep) {
+      this.meshRoot.remove(meshrep);
+      meshrep.traverse(function (child) {
+        if (child instanceof Mesh) {
+          child.material.dispose();
+          child.geometry.dispose();
+        }
+      });
+      this.meshrep[channel] = null;
+    }
+  }
+  saveChannelIsosurface(channelIndex, type, namePrefix) {
+    const meshrep = this.meshrep[channelIndex];
+    if (!meshrep) {
+      return;
+    }
+    if (type === "STL") {
+      this.exportSTL(meshrep, namePrefix + "_" + this.volume.channelNames[channelIndex]);
+    } else if (type === "GLTF") {
+      // temporarily set other meshreps to invisible
+      const prevviz = [];
+      for (let i = 0; i < this.meshrep.length; ++i) {
+        const meshrepi = this.meshrep[i];
+        if (meshrepi) {
+          prevviz[i] = meshrepi.visible;
+          meshrepi.visible = i === channelIndex;
+        }
+      }
+      this.exportGLTF(this.meshRoot, namePrefix + "_" + this.volume.channelNames[channelIndex]);
+      for (let i = 0; i < this.meshrep.length; ++i) {
+        const meshrepi = this.meshrep[i];
+        if (meshrepi) {
+          meshrepi.visible = prevviz[i];
+        }
+      }
+    }
+  }
+  exportSTL(input, fname) {
+    const ex = new STLExporter();
+    const output = ex.parse(input, {
+      binary: true
+    });
+    // STLExporter's typing shows that it returns string
+    // but this is not the case when binary=true.
+    FileSaver.saveBinary(output.buffer, fname + ".stl");
+  }
+
+  // takes a scene or object or array of scenes or objects or both!
+  exportGLTF(input, fname) {
+    const gltfExporter = new GLTFExporter();
+    const options = {
+      // transforms as translate rotate scale?
+      trs: false,
+      onlyVisible: true,
+      truncateDrawRange: true,
+      binary: true,
+      forceIndices: false,
+      forcePowerOfTwoTextures: true
+    };
+    gltfExporter.parse(input, function (result) {
+      if (result instanceof ArrayBuffer) {
+        FileSaver.saveArrayBuffer(result, fname + ".glb");
+      } else {
+        const output = JSON.stringify(result, null, 2);
+        FileSaver.saveString(output, fname + ".gltf");
+      }
+    }, function (error) {
+      console.error(error);
+    }, options);
+  }
+  generateIsosurfaceGeometry(channelIndex, isovalue) {
+    if (!this.volume) {
+      return [];
+    }
+    const volumeData = this.volume.channels[channelIndex].volumeData;
+    const marchingcubes = true;
+    const regionSizeArr = this.volume.imageInfo.subregionSize.toArray();
+    if (marchingcubes) {
+      const effect = new MarchingCubes(regionSizeArr, new Material(), false, false, true, volumeData);
+      effect.position.copy(this.meshRoot.position);
+      effect.scale.set(0.5 * this.scale.x, 0.5 * this.scale.y, 0.5 * this.scale.z);
+      effect.isovalue = isovalue;
+      const geometries = effect.generateGeometry();
+      // TODO: weld vertices and recompute normals if MarchingCubes results in excessive coincident verts
+      // for (var i = 0; i < geometries.length; ++i) {
+      //   var g = new THREE.Geometry().fromBufferGeometry(geometries[i]);
+      //   g.mergeVertices();
+      //   geometries[i] = new THREE.BufferGeometry().fromGeometry(g);
+      //   geometries[i].computeVertexNormals();
+      // }
+      return geometries || [];
+    } else {
+      const result = NaiveSurfaceNets.surfaceNets(volumeData, regionSizeArr, isovalue);
+      return NaiveSurfaceNets.constructTHREEGeometry(result);
+    }
+  }
+}

package/es/NaiveSurfaceNets.js

@@ -0,0 +1,251 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2012-2013 Mikola Lysenko
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+/**
+ * SurfaceNets in JavaScript
+ *
+ * Written by Mikola Lysenko (C) 2012
+ *
+ * MIT License
+ *
+ * Based on: S.F. Gibson, "Constrained Elastic Surface Nets". (1998) MERL Tech Report.
+ */
+
+// MODIFIED 2018 BY DANIELT@ALLENINSTITUTE.ORG TO ACCEPT AN ISOVALUE AND RESCALE VERTEX POSITIONS
+import { BufferAttribute, BufferGeometry } from "three";
+var SurfaceNets = function () {
+  "use strict";
+
+  //Precompute edge table, like Paul Bourke does.
+  // This saves a bit of time when computing the centroid of each boundary cell
+  var cube_edges = new Int32Array(24),
+    edge_table = new Int32Array(256);
+  (function () {
+    //Initialize the cube_edges table
+    // This is just the vertex number of each cube
+    var k = 0;
+    for (var i = 0; i < 8; ++i) {
+      for (var j = 1; j <= 4; j <<= 1) {
+        var p = i ^ j;
+        if (i <= p) {
+          cube_edges[k++] = i;
+          cube_edges[k++] = p;
+        }
+      }
+    }
+
+    //Initialize the intersection table.
+    //  This is a 2^(cube configuration) ->  2^(edge configuration) map
+    //  There is one entry for each possible cube configuration, and the output is a 12-bit vector enumerating all edges crossing the 0-level.
+    for (var i = 0; i < 256; ++i) {
+      var em = 0;
+      for (var j = 0; j < 24; j += 2) {
+        var a = !!(i & 1 << cube_edges[j]),
+          b = !!(i & 1 << cube_edges[j + 1]);
+        em |= a !== b ? 1 << (j >> 1) : 0;
+      }
+      edge_table[i] = em;
+    }
+  })();
+
+  //Internal buffer, this may get resized at run time
+  var buffer = new Int32Array(4096);
+  return function (data, dims, isovalue) {
+    var vertices = [],
+      faces = [],
+      n = 0,
+      x = new Int32Array(3),
+      R = new Int32Array([1, dims[0] + 1, (dims[0] + 1) * (dims[1] + 1)]),
+      grid = new Float32Array(8),
+      buf_no = 1;
+
+    //Resize buffer if necessary
+    if (R[2] * 2 > buffer.length) {
+      buffer = new Int32Array(R[2] * 2);
+    }
+
+    //March over the voxel grid
+    for (x[2] = 0; x[2] < dims[2] - 1; ++x[2], n += dims[0], buf_no ^= 1, R[2] = -R[2]) {
+      //m is the pointer into the buffer we are going to use.
+      //This is slightly obtuse because javascript does not have good support for packed data structures, so we must use typed arrays :(
+      //The contents of the buffer will be the indices of the vertices on the previous x/y slice of the volume
+      var m = 1 + (dims[0] + 1) * (1 + buf_no * (dims[1] + 1));
+      for (x[1] = 0; x[1] < dims[1] - 1; ++x[1], ++n, m += 2) for (x[0] = 0; x[0] < dims[0] - 1; ++x[0], ++n, ++m) {
+        //Read in 8 field values around this vertex and store them in an array
+        //Also calculate 8-bit mask, like in marching cubes, so we can speed up sign checks later
+        var mask = 0,
+          g = 0,
+          idx = n;
+        for (var k = 0; k < 2; ++k, idx += dims[0] * (dims[1] - 2)) for (var j = 0; j < 2; ++j, idx += dims[0] - 2) for (var i = 0; i < 2; ++i, ++g, ++idx) {
+          var p = data[idx] - isovalue;
+          grid[g] = p;
+          mask |= p < 0 ? 1 << g : 0;
+        }
+
+        //Check for early termination if cell does not intersect boundary
+        if (mask === 0 || mask === 0xff) {
+          continue;
+        }
+
+        //Sum up edge intersections
+        var edge_mask = edge_table[mask],
+          v = [0.0, 0.0, 0.0],
+          e_count = 0;
+
+        //For every edge of the cube...
+        for (var i = 0; i < 12; ++i) {
+          //Use edge mask to check if it is crossed
+          if (!(edge_mask & 1 << i)) {
+            continue;
+          }
+
+          //If it did, increment number of edge crossings
+          ++e_count;
+
+          //Now find the point of intersection
+          var e0 = cube_edges[i << 1],
+            //Unpack vertices
+            e1 = cube_edges[(i << 1) + 1],
+            g0 = grid[e0],
+            //Unpack grid values
+            g1 = grid[e1],
+            t = g0 - g1; //Compute point of intersection
+          if (Math.abs(t) > 1e-6) {
+            t = g0 / t;
+          } else {
+            continue;
+          }
+
+          //Interpolate vertices and add up intersections (this can be done without multiplying)
+          for (var j = 0, k = 1; j < 3; ++j, k <<= 1) {
+            var a = e0 & k,
+              b = e1 & k;
+            if (a !== b) {
+              v[j] += a ? 1.0 - t : t;
+            } else {
+              v[j] += a ? 1.0 : 0;
+            }
+          }
+        }
+
+        //Now we just average the edge intersections and add them to coordinate
+        var s = 1.0 / e_count;
+        for (var i = 0; i < 3; ++i) {
+          v[i] = x[i] + s * v[i];
+        }
+
+        //Add vertex to buffer, store pointer to vertex index in buffer
+        buffer[m] = vertices.length;
+        vertices.push([2.0 * v[0] / dims[0] - 1.0, 2.0 * v[1] / dims[1] - 1.0, 2.0 * v[2] / dims[2] - 1.0]);
+
+        //Now we need to add faces together, to do this we just loop over 3 basis components
+        for (var i = 0; i < 3; ++i) {
+          //The first three entries of the edge_mask count the crossings along the edge
+          if (!(edge_mask & 1 << i)) {
+            continue;
+          }
+
+          // i = axes we are point along.  iu, iv = orthogonal axes
+          var iu = (i + 1) % 3,
+            iv = (i + 2) % 3;
+
+          //If we are on a boundary, skip it
+          if (x[iu] === 0 || x[iv] === 0) {
+            continue;
+          }
+
+          //Otherwise, look up adjacent edges in buffer
+          var du = R[iu],
+            dv = R[iv];
+
+          //Remember to flip orientation depending on the sign of the corner.
+          if (mask & 1) {
+            faces.push([buffer[m], buffer[m - du], buffer[m - du - dv], buffer[m - dv]]);
+          } else {
+            faces.push([buffer[m], buffer[m - dv], buffer[m - du - dv], buffer[m - du]]);
+          }
+        }
+      }
+    }
+
+    //All done!  Return the result
+    return {
+      vertices: vertices,
+      faces: faces
+    };
+  };
+}();
+
+// returns array of indexed BufferGeometry
+function ConstructTHREEGeometry(surfaceNetResult) {
+  var result = surfaceNetResult;
+  var varray = new Float32Array(result.vertices.length * 3);
+  for (var i = 0; i < result.vertices.length; ++i) {
+    var v = result.vertices[i];
+    varray[i * 3 + 0] = v[0];
+    varray[i * 3 + 1] = v[1];
+    varray[i * 3 + 2] = v[2];
+  }
+
+  // count triangles; split quad faces
+  let n_triangles = 0;
+  for (var i = 0; i < result.faces.length; ++i) {
+    var f = result.faces[i];
+    if (f.length === 3) {
+      n_triangles += 1;
+    } else if (f.length === 4) {
+      n_triangles += 2;
+    } else {
+      //Polygon needs to be subdivided...
+      console.log("unhandled poly with " + f.length + " vertices");
+    }
+  }
+  var inds = new Uint32Array(n_triangles * 3);
+  let j = 0;
+  for (var i = 0; i < result.faces.length; ++i) {
+    var f = result.faces[i];
+    // note what appears to be inverted winding order.
+    // I believe this is related to isosurface < or > testing but have not checked.
+    if (f.length === 3) {
+      inds[j++] = f[2];
+      inds[j++] = f[1];
+      inds[j++] = f[0];
+    } else if (f.length === 4) {
+      // two triangles: (2,1,0) and (3,2,0)
+      inds[j++] = f[2];
+      inds[j++] = f[1];
+      inds[j++] = f[0];
+      inds[j++] = f[3];
+      inds[j++] = f[2];
+      inds[j++] = f[0];
+    }
+  }
+  var geo = new BufferGeometry();
+  geo.setAttribute("position", new BufferAttribute(varray, 3, false));
+  geo.setIndex(new BufferAttribute(inds, 1));
+  geo.computeVertexNormals();
+  return [geo];
+}
+export default {
+  surfaceNets: SurfaceNets,
+  constructTHREEGeometry: ConstructTHREEGeometry
+};