zincjs 1.16.2 → 1.16.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zincjs",
-  "version": "1.16.2",
+  "version": "1.16.4",
   "description": "ZincJS (Web-based-Zinc-Visualisation)",
   "main": "build/zinc.js",
   "directories": {

package/src/primitives/lines2.js

@@ -8,7 +8,7 @@ const LineSegmentsGeometry = require("../three/line/LineSegmentsGeometry").LineS
  * Provides an object which stores lines.
  * This is created when a valid json file containing lines is read into a {@link Zinc.Scene}
  * object.
- * 
+ *
  * @class
  * @author Alan Wu
  * @return {Lines}
@@ -20,7 +20,7 @@ const Lines2 = function () {
 
   /**
    * Create the line segements using geometry and material.
-   * 
+   *
    * @param {Array} arrayIn - Geometry of lines to be rendered.
    * @param {THREE.Material} materialIn - Material to be set for the lines.
    * @param {Object} options - Provide various options
@@ -43,7 +43,7 @@ const Lines2 = function () {
 
   /**
    * Set the width for the lines.
-   * 
+   *
    * @param {Number} width - Width of the lines.
    */
 	this.setWidth = width => {
@@ -121,6 +121,7 @@ const Lines2 = function () {
       if (!mesh || 0 > i || maxIndex >= this.drawRange) {
         return;
       } else {
+
         let index = i * 3;
         coords.forEach(coord => {
           positions[index++] = coord[0];

package/src/primitives/pointset.js

@@ -66,7 +66,10 @@ const Pointset = function () {
    */
   this.addPoints = (coords, labels, colour) => {
     if (coords && coords.length > 0) {
-      let current = this.drawRange - 1;
+      let current = this.drawRange;
+      if (current === -1) {
+        current = 0;
+      }
       const geometry = this.addVertices(coords);
       let mesh = this.getMorph();
       if (!mesh) {
@@ -76,13 +79,15 @@ const Pointset = function () {
         geometry.colorsNeedUpdate = true;
         this.createMesh(geometry, material, options);
       }
+
       let end = current + coords.length;
       let index = 0;
       if ((Array.isArray(labels) && labels.length === coords.length) ||
         (typeof labels === "string")) {
+        const size = labelSets.length;
         for (current; current + index < end;) {
           const labelText = typeof labels === "string" ? labels : labels[index];
-          addLabel(index, coords[index], labelText, colour);
+          addLabel(current + index, coords[index], labelText, this._lod._material.color);
           index++;
         }
       }
@@ -199,6 +204,7 @@ const Pointset = function () {
     }
     Pointset.prototype.render.call(this, delta, playAnimation, cameraControls, options);
   }
+
 }
 
 Pointset.prototype = Object.create((require('./zincObject').ZincObject).prototype);

package/src/primitives/textureVolume.js

@@ -0,0 +1,317 @@
+const THREE = require('three');
+const shader = require("../shaders/volumeRender.js");
+/**
+ * Provides a class which create a texture stacks in a block
+ * with shaders allowing slices of texture to be displayed.
+ *
+ * @param {TextureArray} textureIn - An object of texture array
+ * holding texture information.
+ *
+ * @class
+ * @author Alan Wu
+ * @return {TextureSlides}
+ */
+const TextureSlides = function (textureIn) {
+  (require('./texturePrimitive.js').TexturePrimitive).call(this, textureIn);
+  this.isTextureVolume = true;
+  const textureSettings = [];
+  this.morph = new THREE.Group();
+  this.group = this.morph;
+  this.morph.userData = this;
+  let edgesLine = undefined;
+  let flipY = true;
+
+  /**
+    @typedef SLIDE_SETTINGS
+    @type {Set}
+    @property {String} direction - the value must be x, y or z, specify the
+    direction the slide should be facing.
+    @property {Number} value - Normalised value of the location on direction.
+    @property {String} id - ID of the mesh, it is only available if the settings
+    is returned from {@link TextureSlides.createSlide} or
+    {@link TextureSlides.getTextureSettings}.
+   */
+  /**
+   * Create the slides required for visualisation based on the slide settings.
+   * The slides themselves are {THREE.PlanGeometry} objects.
+   *
+   * @param {SLIDE_SETTINGS} slideSettings - An array to each slide settings.
+   */
+  this.createSlides = slideSettings => {
+    slideSettings.forEach(slide => this.createSlide(slide));
+  }
+
+  /**
+   * Set the value of the uniforms for a specific mesh in this
+   * texture slide object.
+   *
+   * @param {THREE.Mesh} mesh - Mesh to be modified
+   * @param {SLIDE_SETTINGS} slideSettings - Slide settings.
+   */
+  const setUniformSlideSettingsOfMesh = (mesh, settings) => {
+    const material = mesh.material;
+    const uniforms = material.uniforms;
+    mesh.rotation.x = 0;
+    mesh.rotation.y = 0;
+    mesh.rotation.z = 0;
+    mesh.position.x = 0;
+    mesh.position.y = 0;
+    mesh.position.z = 0;
+    switch (settings.direction) {
+      case "x":
+        const rotation = -Math.PI / 2;
+        mesh.rotation.y = rotation;
+        uniforms.direction.value = 1;
+        uniforms.slide.value.set(settings.value, 0, 0);
+        mesh.position.x = settings.value;
+        break;
+      case "y":
+        mesh.rotation.x = Math.PI / 2;
+        uniforms.direction.value = 2;
+        uniforms.slide.value.set(0, settings.value, 0);
+        mesh.position.y = settings.value;
+        break;
+      case "z":
+        uniforms.direction.value = 3;
+        uniforms.slide.value.set(0, 0, settings.value);
+        mesh.position.z = settings.value;
+        break;
+      default:
+        break;
+    }
+    material.needsUpdate = true;
+    this.boundingBoxUpdateRequired = true;
+  }
+
+  /**
+   * Modify the mesh based on a setting
+   *
+   * @param {SLIDE_SETTINGS} settings - s.
+   */
+  this.modifySlideSettings = (settings) => {
+    if (settings && settings.id &&
+      settings.id in idTextureMap &&
+      idTextureMap[settings.id]) {
+      setUniformSlideSettingsOfMesh(idTextureMap[settings.id], settings);
+    }
+  }
+
+  /**
+   * Create a slide required for visualisation based on the slide settings.
+   * The slide itself is an {THREE.PlanGeometry} object.
+   *
+   * @param {SLIDE_SETTINGS} settings -settings of the slide to be created.
+   * @return {SLIDE_SETTINGS} - Returned settings, it includes the newly
+   * created mesh's id.
+   */
+  this.createSlide = settings => {
+    if (this.texture && this.texture.isTextureArray && this.texture.isReady()) {
+      if (settings && settings.direction && settings.value !== undefined) {
+        const geometry = new THREE.PlaneGeometry(1, 1);
+        geometry.translate(0.5, 0.5, 0);
+        const uniforms = shader.getUniforms();
+        uniforms.diffuse.value = this.texture.impl;
+        uniforms.depth.value = this.texture.size.depth;
+        uniforms.flipY.value = flipY;
+
+        const options = {
+          fs: shader.fs,
+          vs: shader.vs,
+          uniforms: uniforms,
+          glslVersion: shader.glslVersion,
+          side: THREE.DoubleSide,
+          transparent: false
+        };
+        const material = this.texture.getMaterial(options);
+        material.needsUpdate = true;
+        const mesh = new THREE.Mesh(geometry, material);
+        mesh.name = this.groupName;
+        mesh.userData = this;
+        const slideSettings = {
+          value: settings.value,
+          direction: settings.direction,
+          id: mesh.id,
+        };
+        textureSettings.push(slideSettings);
+        setUniformSlideSettingsOfMesh(mesh, slideSettings);
+        idTextureMap[mesh.id] = mesh;
+        this.morph.add(mesh);
+        this.boundingBoxUpdateRequired = true;
+        return slideSettings;
+      }
+    }
+  }
+
+  /**
+   * Return a copy of texture settings used by this object.
+   *
+   * @return {SLIDE_SETTINGS} - Returned the list of settings.
+   */
+  this.getTextureSettings = () => {
+    return [...textureSettings];
+  }
+
+  /**
+   * Return a copy of texture settings with corresponding id used by this object.
+   *
+   * @return {SLIDE_SETTINGS} - Returned a copy of settings with corresponding id.
+   */
+  this.getTextureSettingsWithId = (id) => {
+    for (let i = 0; i < textureSettings.length; i++) {
+      if (id === textureSettings[i].id) {
+        return {...textureSettings[i]};
+      }
+    }
+  }
+
+  /**
+   * Get  the array of slides, return them in an array
+   *
+   * @return {Array} - Return an array of {@link THREE.Object)
+   */
+  this.getSlides = () => {
+    if (this.morph) return [...this.morph.children];
+    return [];
+  }
+
+  /**
+   * Clean up all internal objects.
+   */
+  this.dispose = () => {
+    this.morph.children.forEach(slide => {
+      if (slide.geometry)
+        slide.geometry.dispose();
+      if (slide.material)
+        slide.material.dispose();
+    });
+    (require('./texturePrimitive.js').TexturePrimitive).prototype.dispose.call(this);
+    this.boundingBoxUpdateRequired = true;
+  }
+
+  //Expand the boundingbox with slide settings
+  const expandBoxWithSettings = (box, settings, vector) => {
+    if (settings) {
+      switch (settings.direction.value) {
+        case 1:
+          vector.copy(settings.slide.value);
+          box.expandByPoint(vector);
+          vector.setY(1.0);
+          vector.setZ(1.0);
+          box.expandByPoint(vector);
+          break;
+        case 2:
+          vector.copy(settings.slide.value);
+          box.expandByPoint(vector);
+          vector.setX(1.0);
+          vector.setZ(1.0);
+          box.expandByPoint(vector);
+          break;
+        case 3:
+          vector.copy(settings.slide.value);
+          box.expandByPoint(vector);
+          vector.setX(1.0);
+          vector.setY(1.0);
+          box.expandByPoint(vector);
+          break;
+        default:
+          break;
+      }
+    }
+  }
+
+  /**
+   * Get the bounding box of this slides.
+   * It uses the max and min of the slides position and the
+   * transformation to calculate the position of the box.
+   *
+   * @return {THREE.Box3}.
+   */
+  this.getBoundingBox = () => {
+    if (this.morph && this.morph.children && this.morph.visible &&
+      this.boundingBoxUpdateRequired) {
+      this.cachedBoundingBox.makeEmpty();
+      const vector = new THREE.Vector3(0, 0, 0);
+      this.morph.children.forEach(slide => {
+        expandBoxWithSettings(this.cachedBoundingBox, slide.material.uniforms,
+          vector);
+      });
+      this.morph.updateMatrixWorld (true, true);
+      this.cachedBoundingBox.applyMatrix4(this.morph.matrixWorld);
+      this.boundingBoxUpdateRequired = false;
+    }
+    return this.cachedBoundingBox;
+  }
+
+  this.applyTransformation = (rotation, position, scale) => {
+    const matrix = new THREE.Matrix4();
+    matrix.set(
+      rotation[0],
+      rotation[1],
+      rotation[2],
+      0,
+      rotation[3],
+      rotation[4],
+      rotation[5],
+      0,
+      rotation[6],
+      rotation[7],
+      rotation[8],
+      0,
+      0,
+      0,
+      0,
+      0
+    );
+    const quaternion = new THREE.Quaternion().setFromRotationMatrix(matrix);
+    this.morph.position.set(...position);
+    this.morph.quaternion.copy( quaternion );
+    this.morph.scale.set(...scale);
+    this.morph.updateMatrix();
+    this.boundingBoxUpdateRequired = true;
+  }
+
+  this.setRenderOrder = (order) => {
+    //multiilayers
+    this.morph.renderOrder = order;
+  }
+
+  this.initialise = (textureData, finishCallback) => {
+    if (textureData) {
+      const locations = textureData.locations;
+      if (locations && locations.length > 0) {
+        this.applyTransformation(locations[0].orientation,
+          locations[0].position, locations[0].scale);
+        if ("flipY" in locations[0]) {
+          flipY = locations[0].flipY;
+        }
+      }
+      this.createSlides(textureData.settings.slides);
+      if (finishCallback != undefined && (typeof finishCallback == 'function')) {
+        finishCallback(this);
+      }
+    }
+  }
+
+  this.showEdges = (color) => {
+    if (!edgesLine) {
+      const geometry = new THREE.BoxGeometry( 1, 1, 1 );
+      geometry.translate(0.5, 0.5, 0.5);
+      const edges = new THREE.EdgesGeometry( geometry );
+      edgesLine = new THREE.LineSegments(edges, new THREE.LineBasicMaterial( { color } ) );
+      this.group.add( edgesLine );
+    } else {
+      edgesLine.material.color = color;
+    }
+    edgesLine.visible = true;
+  }
+
+  this.hideEdges = () => {
+    if (edgesLine) {
+      edgesLine.visible = false;
+    }
+  }
+}
+
+TextureSlides.prototype = Object.create((require('./texturePrimitive.js').TexturePrimitive).prototype);
+TextureSlides.prototype.constructor = TextureSlides;
+exports.TextureSlides = TextureSlides;