zincjs 1.16.2 → 1.16.4

package/src/primitives/zincObject.js

@@ -11,7 +11,7 @@ const getUniqueId = function () {
 /**
  * Provides the base object for other primitive types.
  * This class contains multiple base methods.
- * 
+ *
  * @class
  * @author Alan Wu
  * @return {ZincObject}
@@ -33,7 +33,7 @@ const ZincObject = function() {
   this.mixer = undefined;
   this.animationGroup = undefined;
 	/**
-	 * Total duration of the animation, this value interacts with the 
+	 * Total duration of the animation, this value interacts with the
 	 * {@link Renderer#playRate} to produce the actual duration of the
 	 * animation. Actual time in second = duration / playRate.
 	 */
@@ -69,7 +69,7 @@ const ZincObject = function() {
 
 /**
  * Set the duration of the animation of this object.
- * 
+ *
  * @param {Number} durationIn - Duration of the animation.
  */
 ZincObject.prototype.setDuration = function(durationIn) {
@@ -81,7 +81,7 @@ ZincObject.prototype.setDuration = function(durationIn) {
 
 /**
  * Get the duration of the animation of this object.
- * 
+ *
  * @return {Number}
  */
 ZincObject.prototype.getDuration = function() {
@@ -99,7 +99,7 @@ ZincObject.prototype.setRegion = function(region) {
 
 /**
  * Get the region this object belongs to.
- * 
+ *
  * @return {Region}
  */
 ZincObject.prototype.getRegion = function() {
@@ -107,8 +107,8 @@ ZincObject.prototype.getRegion = function() {
 }
 
 /**
- * Get the threejs object3D. 
- * 
+ * Get the threejs object3D.
+ *
  * @return {Object}
  */
  ZincObject.prototype.getMorph = function() {
@@ -117,8 +117,8 @@ ZincObject.prototype.getRegion = function() {
 }
 
 /**
- * Get the threejs object3D. 
- * 
+ * Get the threejs object3D.
+ *
  * @return {Object}
  */
  ZincObject.prototype.getGroup = function() {
@@ -126,7 +126,7 @@ ZincObject.prototype.getRegion = function() {
 }
 
 /**
- * Set the internal threejs object3D. 
+ * Set the internal threejs object3D.
  */
  ZincObject.prototype.setMorph = function(mesh) {
   this.morph = mesh;
@@ -147,7 +147,7 @@ ZincObject.prototype.checkTransparentMesh = function() {
 
 /**
  * Set the mesh function for zincObject.
- * 
+ *
  * @param {THREE.Mesh} mesh - Mesh to be set for this zinc object.
  * @param {Boolean} localTimeEnabled - A flag to indicate either the mesh is
  * time dependent.
@@ -201,7 +201,7 @@ ZincObject.prototype.setMesh = function(mesh, localTimeEnabled, localMorphColour
 
 /**
  * Set isPickable for this ZincObject.
- * 
+ *
  * @param {String} isPickable - Boolean to enable object pick.
  */
 ZincObject.prototype.setIsPickable = function(isPickable) {
@@ -213,7 +213,7 @@ ZincObject.prototype.setIsPickable = function(isPickable) {
 
 /**
  * Set the anatomicalId for this ZincObject.
- * 
+ *
  * @param {String} anatomicalId - Id to be set.
  */
 ZincObject.prototype.setAnatomicalId = function(anatomicalId) {
@@ -222,7 +222,7 @@ ZincObject.prototype.setAnatomicalId = function(anatomicalId) {
 
 /**
  * Set the name for this ZincObject.
- * 
+ *
  * @param {String} groupNameIn - Name to be set.
  */
 ZincObject.prototype.setName = function(groupNameIn) {
@@ -231,9 +231,9 @@ ZincObject.prototype.setName = function(groupNameIn) {
 }
 
 /**
- * Get the local time of this geometry, it returns a value between 
+ * Get the local time of this geometry, it returns a value between
  * 0 and the duration.
- * 
+ *
  * @return {Number}
  */
 ZincObject.prototype.getCurrentTime = function() {
@@ -247,7 +247,7 @@ ZincObject.prototype.getCurrentTime = function() {
 
 /**
  * Set the local time of this geometry.
- * 
+ *
  * @param {Number} time - Can be any value between 0 to duration.
  */
 ZincObject.prototype.setMorphTime = function(time) {
@@ -264,7 +264,7 @@ ZincObject.prototype.setMorphTime = function(time) {
       this.mixer.update( 0.0 );
     }
   } else {
-    let newTime = time; 
+    let newTime = time;
     if (time > this.duration)
       newTime = this.duration;
     else if (0 > time)
@@ -286,7 +286,7 @@ ZincObject.prototype.setMorphTime = function(time) {
 
 /**
  * Check if the geometry is time varying.
- * 
+ *
  * @return {Boolean}
  */
 ZincObject.prototype.isTimeVarying = function() {
@@ -297,7 +297,7 @@ ZincObject.prototype.isTimeVarying = function() {
 
 /**
  * Get the visibility of this Geometry.
- * 
+ *
  */
 ZincObject.prototype.getVisibility = function() {
   return this.visible;
@@ -305,8 +305,8 @@ ZincObject.prototype.getVisibility = function() {
 
 /**
  * Set the visibility of this Geometry.
- * 
- * @param {Boolean} visible - a boolean flag indicate the visibility to be set 
+ *
+ * @param {Boolean} visible - a boolean flag indicate the visibility to be set
  */
 ZincObject.prototype.setVisibility = function(visible) {
   if (visible !== this.visible) {
@@ -319,8 +319,8 @@ ZincObject.prototype.setVisibility = function(visible) {
 /**
  * Set the opacity of this Geometry. This function will also set the isTransparent
  * flag according to the provided alpha value.
- * 
- * @param {Number} alpah - Alpha value to set for this geometry, 
+ *
+ * @param {Number} alpah - Alpha value to set for this geometry,
  * can be any value between from 0 to 1.0.
  */
 ZincObject.prototype.setAlpha = function(alpha) {
@@ -337,7 +337,7 @@ ZincObject.prototype.setAlpha = function(alpha) {
  * The rendering will be culled if it is outside of the frustrum
  * when this flag is set to true, it should be set to false if
  * morphing is enabled.
- * 
+ *
  * @param {Boolean} flag - Set frustrum culling on/off based on this flag.
  */
 ZincObject.prototype.setFrustumCulled = function(flag) {
@@ -348,7 +348,7 @@ ZincObject.prototype.setFrustumCulled = function(flag) {
 /**
  * Set rather a zinc object should be displayed using per vertex colour or
  * not.
- * 
+ *
  * @param {Boolean} vertexColors - Set display with vertex color on/off.
  */
 ZincObject.prototype.setVertexColors = function(vertexColors) {
@@ -359,7 +359,7 @@ ZincObject.prototype.setVertexColors = function(vertexColors) {
 
 /**
  * Get the colour of the mesh.
- * 
+ *
  * @return {THREE.Color}
  */
 ZincObject.prototype.getColour = function() {
@@ -367,10 +367,10 @@ ZincObject.prototype.getColour = function() {
     return this._lod._material.color;
 	return undefined;
 }
-  
+
 /**
  * Set the colour of the mesh.
- * 
+ *
  * @param {THREE.Color} colour - Colour to be set for this geometry.
  */
 ZincObject.prototype.setColour = function(colour) {
@@ -379,7 +379,7 @@ ZincObject.prototype.setColour = function(colour) {
 
 /**
  * Set the colour of the mesh.
- * 
+ *
  * @param {THREE.Color} colour - Colour to be set for this geometry.
  */
 ZincObject.prototype.setGreyScale = function(flag) {
@@ -406,7 +406,7 @@ ZincObject.prototype.setGreyScale = function(flag) {
 
 /**
  * Get the colour of the mesh in hex string form.
- * 
+ *
  * @return {String}
  */
 ZincObject.prototype.getColourHex = function() {
@@ -419,7 +419,7 @@ ZincObject.prototype.getColourHex = function() {
 
 /**
  * Set the colour of the mesh using hex in string form.
- * 
+ *
  * @param {String} hex - The colour value in hex form.
  */
 ZincObject.prototype.setColourHex = function(hex) {
@@ -431,7 +431,7 @@ ZincObject.prototype.setColourHex = function(hex) {
 
 /**
  * Set the emissive rgb of the mesh using rgb.
- * 
+ *
  * @param {String} colour - The colour value in rgb form.
  */
 ZincObject.prototype.setEmissiveRGB = function(colour) {
@@ -446,7 +446,7 @@ ZincObject.prototype.setEmissiveRGB = function(colour) {
 
 /**
  * Set the material of the geometry.
- * 
+ *
  * @param {THREE.Material} material - Material to be set for this geometry.
  */
 ZincObject.prototype.setMaterial = function(material) {
@@ -455,17 +455,17 @@ ZincObject.prototype.setMaterial = function(material) {
 
 /**
  * Get the index of the closest vertex to centroid.
- * 
+ *
  * @return {Number} - integer index in the array
  */
 ZincObject.prototype.getClosestVertexIndex = function() {
   let closestIndex = -1;
   const morph = this.getMorph();
-  if (morph && morph.geoemtry) {
+  if (morph && morph.geometry) {
     let position = morph.geometry.attributes.position;
-    this._b1.setFromBufferAttribute(position);
-    this._b1.getCenter(this._v1);
     if (position) {
+      this._b1.setFromBufferAttribute(position);
+      this._b1.getCenter(this._v1);
       let distance = -1;
       let currentDistance = 0;
       for (let i = 0; i < position.count; i++) {
@@ -485,7 +485,7 @@ ZincObject.prototype.getClosestVertexIndex = function() {
 
 /**
  * Get the  closest vertex to centroid.
- * 
+ *
  * @return {THREE.Vector3}
  */
 ZincObject.prototype.getClosestVertex = function(applyMatrixWorld) {
@@ -516,14 +516,15 @@ ZincObject.prototype.getClosestVertex = function(applyMatrixWorld) {
       return applyMatrixWorld ? position.applyMatrix4(morph.matrixWorld) : position;
     }
   }
+  //Matrix world has already been applied
   this.getBoundingBox();
   position.copy(this.center);
-  return applyMatrixWorld ? position.applyMatrix4(this.morph.matrixWorld) : position;
+  return position;
 }
 
 /**
  * Get the bounding box of this geometry.
- * 
+ *
  * @return {THREE.Box3}.
  */
 ZincObject.prototype.getBoundingBox = function() {
@@ -558,13 +559,13 @@ ZincObject.prototype.dispose = function() {
 }
 
 /**
- * Check if marker is enabled based on the objects settings with 
+ * Check if marker is enabled based on the objects settings with
  * the provided scene options.
- * 
- * @return {Boolean} 
+ *
+ * @return {Boolean}
  */
 ZincObject.prototype.markerIsRequired = function(options) {
-  if (this.visible && 
+  if (this.visible &&
     (this.markerMode === "on" || (options && options.displayMarkers &&
     (this.markerMode === "inherited")))) {
       return true;
@@ -573,7 +574,7 @@ ZincObject.prototype.markerIsRequired = function(options) {
 }
 
 /**
- * Update the marker's position and size based on current viewport. 
+ * Update the marker's position and size based on current viewport.
  */
 ZincObject.prototype.updateMarker = function(playAnimation, options) {
   if ((playAnimation == false) &&
@@ -594,7 +595,7 @@ ZincObject.prototype.updateMarker = function(playAnimation, options) {
       }
       if (!this.marker.isEnabled()) {
         if (options.markersList &&
-          (!(this.marker.uuid in options.markersList))) {    
+          (!(this.marker.uuid in options.markersList))) {
             ndcToBeUpdated = true;
           options.markersList[this.marker.uuid] = this.marker;
         }
@@ -647,7 +648,7 @@ ZincObject.prototype.setRenderOrder = function(renderOrder) {
 
 /**
  * Get the windows coordinates.
- * 
+ *
  * @return {Object} - position and rather the closest vertex is on screen.
  */
 ZincObject.prototype.getClosestVertexDOMElementCoords = function(scene) {
@@ -675,8 +676,8 @@ ZincObject.prototype.getClosestVertexDOMElementCoords = function(scene) {
  * "off" - marker is disabled regardless of settings of scene
  * "inherited" - Marker settings on scene will determine the visibility
  *  of the marker.
- * 
- * @return {Boolean} 
+ *
+ * @return {Boolean}
  */
  ZincObject.prototype.setMarkerMode = function(mode, options) {
   if (mode !== this.markerMode) {
@@ -764,7 +765,9 @@ ZincObject.prototype.setPosition = function(x, y, z) {
   const group = this.getGroup();
   if (group) {
     group.position.set(x, y, z);
+    group.matrixWorldNeedsUpdate = true;
     group.updateMatrix();
+    group.updateWorldMatrix(true, true);
     this.boundingBoxUpdateRequired = true;
   }
 }

package/src/shaders/volumeRender_old.js

@@ -0,0 +1,287 @@
+const THREE = require('three');
+
+const glslVersion = null;
+
+const fs =
+`
+  precision highp float;
+  precision highp sampler2DArray;
+  precision highp sampler2D;
+
+  uniform vec3 u_size;
+  uniform int u_renderstyle;
+  uniform float u_renderthreshold;
+  uniform vec2 u_clim;
+
+  uniform sampler2DArray u_data;
+  uniform sampler2D u_cmdata;
+
+  varying vec3 v_position;
+  varying vec4 v_nearpos;
+  varying vec4 v_farpos;
+
+  // The maximum distance through our rendering volume is sqrt(3).
+  const int MAX_STEPS = 887;	// 887 for 512^3, 1774 for 1024^3
+  const int REFINEMENT_STEPS = 4;
+  const float relative_step_size = 1.0;
+  const vec4 ambient_color = vec4(0.2, 0.4, 0.2, 1.0);
+  const vec4 diffuse_color = vec4(0.8, 0.2, 0.2, 1.0);
+  const vec4 specular_color = vec4(1.0, 1.0, 1.0, 1.0);
+  const float shininess = 40.0;
+
+  void cast_mip(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray);
+  void cast_iso(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray);
+
+  vec3 sample1(vec3 texcoords);
+  vec4 apply_colormap(float val);
+  vec4 add_lighting(float val, vec3 loc, vec3 step, vec3 view_ray);
+
+
+  void main() {
+      // Normalize clipping plane info
+      vec3 farpos = v_farpos.xyz / v_farpos.w;
+      vec3 nearpos = v_nearpos.xyz / v_nearpos.w;
+
+      // Calculate unit vector pointing in the view direction through this fragment.
+      vec3 view_ray = normalize(nearpos.xyz - farpos.xyz);
+
+      // Compute the (negative) distance to the front surface or near clipping plane.
+      // v_position is the back face of the cuboid, so the initial distance calculated in the dot
+      // product below is the distance from near clip plane to the back of the cuboid
+      float distance = dot(nearpos - v_position, view_ray);
+      distance = max(distance, min((-0.5 - v_position.x) / view_ray.x,
+                                  (u_size.x - 0.5 - v_position.x) / view_ray.x));
+      distance = max(distance, min((-0.5 - v_position.y) / view_ray.y,
+                                  (u_size.y - 0.5 - v_position.y) / view_ray.y));
+      distance = max(distance, min((-0.5 - v_position.z) / view_ray.z,
+                                  (u_size.z - 0.5 - v_position.z) / view_ray.z));
+
+      // Now we have the starting position on the front surface
+      vec3 front = v_position + view_ray * distance;
+
+      // Decide how many steps to take
+      int nsteps = int(-distance / relative_step_size + 0.5);
+      if ( nsteps < 1 )
+          discard;
+
+      // Get starting location and step vector in texture coordinates
+      vec3 step = ((v_position - front) / u_size) / float(nsteps);
+      vec3 start_loc = front / u_size;
+
+      // For testing: show the number of steps. This helps to establish
+      // whether the rays are correctly oriented
+      //gl_FragColor = vec4(0.0, float(nsteps) / 1.0 / u_size.x, 1.0, 1.0);
+      //return;
+
+      if (u_renderstyle == 0)
+          cast_mip(start_loc, step, nsteps, view_ray);
+      else if (u_renderstyle == 1)
+          cast_iso(start_loc, step, nsteps, view_ray);
+
+      if (gl_FragColor.a < 0.05)
+          discard;
+  }
+
+
+  vec3 sample1(vec3 texcoords) {
+      /* Sample float value from a 3D texture. Assumes intensity data. */
+      return texture(u_data, texcoords.xyz).rgb;
+  }
+
+
+  vec4 apply_colormap(float val) {
+      val = (val - u_clim[0]) / (u_clim[1] - u_clim[0]);
+      return texture2D(u_cmdata, vec2(val, 0.5));
+  }
+
+
+  void cast_mip(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray) {
+
+      float max_val = -1e6;
+      int max_i = 100;
+      vec3 loc = start_loc;
+
+      // Enter the raycasting loop. In WebGL 1 the loop index cannot be compared with
+      // non-constant expression. So we use a hard-coded max, and an additional condition
+      // inside the loop.
+      for (int iter=0; iter<MAX_STEPS; iter++) {
+          if (iter >= nsteps)
+              break;
+          // Sample from the 3D texture
+          vec3 val = sample1(loc);
+          float avg = (val.x + val.y + val.z) / 3.0;
+          // Apply MIP operation
+          if (val > max_val) {
+              max_val = val;
+              max_i = iter;
+          }
+          // Advance location deeper into the volume
+          loc += step;
+      }
+
+      // Refine location, gives crispier images
+      vec3 iloc = start_loc + step * (float(max_i) - 0.5);
+      vec3 istep = step / float(REFINEMENT_STEPS);
+      for (int i=0; i<REFINEMENT_STEPS; i++) {
+          max_val = max(max_val, sample1(iloc));
+          iloc += istep;
+      }
+
+      // Resolve final color
+      gl_FragColor = apply_colormap(max_val);
+  }
+
+
+  void cast_iso(vec3 start_loc, vec3 step, int nsteps, vec3 view_ray) {
+
+      gl_FragColor = vec4(0.0);	// init transparent
+      vec4 color3 = vec4(0.0);	// final color
+      vec3 dstep = 1.5 / u_size;	// step to sample derivative
+      vec3 loc = start_loc;
+
+      float low_threshold = u_renderthreshold - 0.02 * (u_clim[1] - u_clim[0]);
+
+      // Enter the raycasting loop. In WebGL 1 the loop index cannot be compared with
+      // non-constant expression. So we use a hard-coded max, and an additional condition
+      // inside the loop.
+      for (int iter=0; iter<MAX_STEPS; iter++) {
+          if (iter >= nsteps)
+              break;
+
+          // Sample from the 3D texture
+          float val = sample1(loc);
+
+          if (val > low_threshold) {
+              // Take the last interval in smaller steps
+              vec3 iloc = loc - 0.5 * step;
+              vec3 istep = step / float(REFINEMENT_STEPS);
+              for (int i=0; i<REFINEMENT_STEPS; i++) {
+                  val = sample1(iloc);
+                  if (val > u_renderthreshold) {
+                      gl_FragColor = add_lighting(val, iloc, dstep, view_ray);
+                      return;
+                  }
+                  iloc += istep;
+              }
+          }
+
+          // Advance location deeper into the volume
+          loc += step;
+      }
+  }
+
+
+  vec4 add_lighting(float val, vec3 loc, vec3 step, vec3 view_ray)
+  {
+    // Calculate color by incorporating lighting
+
+      // View direction
+      vec3 V = normalize(view_ray);
+
+      // calculate normal vector from gradient
+      vec3 N;
+      float val1, val2;
+      val1 = sample1(loc + vec3(-step[0], 0.0, 0.0));
+      val2 = sample1(loc + vec3(+step[0], 0.0, 0.0));
+      N[0] = val1 - val2;
+      val = max(max(val1, val2), val);
+      val1 = sample1(loc + vec3(0.0, -step[1], 0.0));
+      val2 = sample1(loc + vec3(0.0, +step[1], 0.0));
+      N[1] = val1 - val2;
+      val = max(max(val1, val2), val);
+      val1 = sample1(loc + vec3(0.0, 0.0, -step[2]));
+      val2 = sample1(loc + vec3(0.0, 0.0, +step[2]));
+      N[2] = val1 - val2;
+      val = max(max(val1, val2), val);
+
+      float gm = length(N); // gradient magnitude
+      N = normalize(N);
+
+      // Flip normal so it points towards viewer
+      float Nselect = float(dot(N, V) > 0.0);
+      N = (2.0 * Nselect - 1.0) * N;	// ==	Nselect * N - (1.0-Nselect)*N;
+
+      // Init colors
+      vec4 ambient_color = vec4(0.0, 0.0, 0.0, 0.0);
+      vec4 diffuse_color = vec4(0.0, 0.0, 0.0, 0.0);
+      vec4 specular_color = vec4(0.0, 0.0, 0.0, 0.0);
+
+      // note: could allow multiple lights
+      for (int i=0; i<1; i++)
+      {
+            // Get light direction (make sure to prevent zero devision)
+          vec3 L = normalize(view_ray);	//lightDirs[i];
+          float lightEnabled = float( length(L) > 0.0 );
+          L = normalize(L + (1.0 - lightEnabled));
+
+          // Calculate lighting properties
+          float lambertTerm = clamp(dot(N, L), 0.0, 1.0);
+          vec3 H = normalize(L+V); // Halfway vector
+          float specularTerm = pow(max(dot(H, N), 0.0), shininess);
+
+          // Calculate mask
+          float mask1 = lightEnabled;
+
+          // Calculate colors
+          ambient_color +=	mask1 * ambient_color;	// * gl_LightSource[i].ambient;
+          diffuse_color +=	mask1 * lambertTerm;
+          specular_color += mask1 * specularTerm * specular_color;
+      }
+
+      // Calculate final color by componing different components
+      vec4 final_color;
+      vec4 color = apply_colormap(val);
+      final_color = color * (ambient_color + diffuse_color) + specular_color;
+      final_color.a = color.a;
+      return final_color;
+  }
+`;
+
+const vs = 
+`
+  varying vec4 v_nearpos;
+  varying vec4 v_farpos;
+  varying vec3 v_position;
+
+  void main() {
+      // Prepare transforms to map to "camera view". See also:
+      // https://threejs.org/docs/#api/renderers/webgl/WebGLProgram
+      mat4 viewtransformf = modelViewMatrix;
+      mat4 viewtransformi = inverse(modelViewMatrix);
+
+      // Project local vertex coordinate to camera position. Then do a step
+      // backward (in cam coords) to the near clipping plane, and project back. Do
+      // the same for the far clipping plane. This gives us all the information we
+      // need to calculate the ray and truncate it to the viewing cone.
+      vec4 position4 = vec4(position, 1.0);
+      vec4 pos_in_cam = viewtransformf * position4;
+
+      // Intersection of ray and near clipping plane (z = -1 in clip coords)
+      pos_in_cam.z = -pos_in_cam.w;
+      v_nearpos = viewtransformi * pos_in_cam;
+
+      // Intersection of ray and far clipping plane (z = +1 in clip coords)
+      pos_in_cam.z = pos_in_cam.w;
+      v_farpos = viewtransformi * pos_in_cam;
+
+      // Set varyings and output pos
+      v_position = position;
+      gl_Position = projectionMatrix * viewMatrix * modelMatrix * position4;
+  }
+`;
+
+const getUniforms = function() {
+  return {
+		u_size: { value: new THREE.Vector3( 1, 1, 1 ) },
+		u_renderstyle: { value: 0 },
+		u_renderthreshold: { value: 0.5 },
+		u_clim: { value: new THREE.Vector2( 1, 1 ) },
+		u_data: { value: null },
+		u_cmdata: { value: null },
+  }
+};
+
+exports.fs = fs;
+exports.vs = vs;
+exports.glslVersion = glslVersion;
+exports.getUniforms = getUniforms;