opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/misc/Volume.js

@@ -0,0 +1,427 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "../misc/VolumeSlice.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("../misc/VolumeSlice.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.VolumeSlice);
+    global.Volume = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, _VolumeSlice) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.Volume = Volume;
+
+  /**
+   * This class had been written to handle the output of the NRRD loader.
+   * It contains a volume of data and informations about it.
+   * For now it only handles 3 dimensional data.
+   * See the webgl_loader_nrrd.html example and the loaderNRRD.js file to see how to use this class.
+   * @class
+   * @param   {number}        xLength         Width of the volume
+   * @param   {number}        yLength         Length of the volume
+   * @param   {number}        zLength         Depth of the volume
+   * @param   {string}        type            The type of data (uint8, uint16, ...)
+   * @param   {ArrayBuffer}   arrayBuffer     The buffer with volume data
+   */
+  function Volume(xLength, yLength, zLength, type, arrayBuffer) {
+    if (arguments.length > 0) {
+      /**
+       * @member {number} xLength Width of the volume in the IJK coordinate system
+       */
+      this.xLength = Number(xLength) || 1;
+      /**
+       * @member {number} yLength Height of the volume in the IJK coordinate system
+       */
+
+      this.yLength = Number(yLength) || 1;
+      /**
+       * @member {number} zLength Depth of the volume in the IJK coordinate system
+       */
+
+      this.zLength = Number(zLength) || 1;
+      /**
+       * @member {Array<string>} The order of the Axis dictated by the NRRD header
+       */
+
+      this.axisOrder = ['x', 'y', 'z'];
+      /**
+       * @member {TypedArray} data Data of the volume
+       */
+
+      switch (type) {
+        case 'Uint8':
+        case 'uint8':
+        case 'uchar':
+        case 'unsigned char':
+        case 'uint8_t':
+          this.data = new Uint8Array(arrayBuffer);
+          break;
+
+        case 'Int8':
+        case 'int8':
+        case 'signed char':
+        case 'int8_t':
+          this.data = new Int8Array(arrayBuffer);
+          break;
+
+        case 'Int16':
+        case 'int16':
+        case 'short':
+        case 'short int':
+        case 'signed short':
+        case 'signed short int':
+        case 'int16_t':
+          this.data = new Int16Array(arrayBuffer);
+          break;
+
+        case 'Uint16':
+        case 'uint16':
+        case 'ushort':
+        case 'unsigned short':
+        case 'unsigned short int':
+        case 'uint16_t':
+          this.data = new Uint16Array(arrayBuffer);
+          break;
+
+        case 'Int32':
+        case 'int32':
+        case 'int':
+        case 'signed int':
+        case 'int32_t':
+          this.data = new Int32Array(arrayBuffer);
+          break;
+
+        case 'Uint32':
+        case 'uint32':
+        case 'uint':
+        case 'unsigned int':
+        case 'uint32_t':
+          this.data = new Uint32Array(arrayBuffer);
+          break;
+
+        case 'longlong':
+        case 'long long':
+        case 'long long int':
+        case 'signed long long':
+        case 'signed long long int':
+        case 'int64':
+        case 'int64_t':
+        case 'ulonglong':
+        case 'unsigned long long':
+        case 'unsigned long long int':
+        case 'uint64':
+        case 'uint64_t':
+          throw 'Error in Volume constructor : this type is not supported in JavaScript';
+          break;
+
+        case 'Float32':
+        case 'float32':
+        case 'float':
+          this.data = new Float32Array(arrayBuffer);
+          break;
+
+        case 'Float64':
+        case 'float64':
+        case 'double':
+          this.data = new Float64Array(arrayBuffer);
+          break;
+
+        default:
+          this.data = new Uint8Array(arrayBuffer);
+      }
+
+      if (this.data.length !== this.xLength * this.yLength * this.zLength) {
+        throw 'Error in Volume constructor, lengths are not matching arrayBuffer size';
+      }
+    }
+    /**
+     * @member {Array}  spacing Spacing to apply to the volume from IJK to RAS coordinate system
+     */
+
+
+    this.spacing = [1, 1, 1];
+    /**
+     * @member {Array}  offset Offset of the volume in the RAS coordinate system
+     */
+
+    this.offset = [0, 0, 0];
+    /**
+     * @member {Martrix3} matrix The IJK to RAS matrix
+     */
+
+    this.matrix = new _three.Matrix3();
+    this.matrix.identity();
+    /**
+     * @member {Martrix3} inverseMatrix The RAS to IJK matrix
+     */
+
+    /**
+     * @member {number} lowerThreshold The voxels with values under this threshold won't appear in the slices.
+     *                      If changed, geometryNeedsUpdate is automatically set to true on all the slices associated to this volume
+     */
+
+    var lowerThreshold = -Infinity;
+    Object.defineProperty(this, 'lowerThreshold', {
+      get: function get() {
+        return lowerThreshold;
+      },
+      set: function set(value) {
+        lowerThreshold = value;
+        this.sliceList.forEach(function (slice) {
+          slice.geometryNeedsUpdate = true;
+        });
+      }
+    });
+    /**
+     * @member {number} upperThreshold The voxels with values over this threshold won't appear in the slices.
+     *                      If changed, geometryNeedsUpdate is automatically set to true on all the slices associated to this volume
+     */
+
+    var upperThreshold = Infinity;
+    Object.defineProperty(this, 'upperThreshold', {
+      get: function get() {
+        return upperThreshold;
+      },
+      set: function set(value) {
+        upperThreshold = value;
+        this.sliceList.forEach(function (slice) {
+          slice.geometryNeedsUpdate = true;
+        });
+      }
+    });
+    /**
+     * @member {Array} sliceList The list of all the slices associated to this volume
+     */
+
+    this.sliceList = [];
+    /**
+     * @member {Array} RASDimensions This array holds the dimensions of the volume in the RAS space
+     */
+  }
+
+  Volume.prototype = {
+    constructor: Volume,
+
+    /**
+     * @member {Function} getData Shortcut for data[access(i,j,k)]
+     * @memberof Volume
+     * @param {number} i    First coordinate
+     * @param {number} j    Second coordinate
+     * @param {number} k    Third coordinate
+     * @returns {number}  value in the data array
+     */
+    getData: function getData(i, j, k) {
+      return this.data[k * this.xLength * this.yLength + j * this.xLength + i];
+    },
+
+    /**
+     * @member {Function} access compute the index in the data array corresponding to the given coordinates in IJK system
+     * @memberof Volume
+     * @param {number} i    First coordinate
+     * @param {number} j    Second coordinate
+     * @param {number} k    Third coordinate
+     * @returns {number}  index
+     */
+    access: function access(i, j, k) {
+      return k * this.xLength * this.yLength + j * this.xLength + i;
+    },
+
+    /**
+     * @member {Function} reverseAccess Retrieve the IJK coordinates of the voxel corresponding of the given index in the data
+     * @memberof Volume
+     * @param {number} index index of the voxel
+     * @returns {Array}  [x,y,z]
+     */
+    reverseAccess: function reverseAccess(index) {
+      var z = Math.floor(index / (this.yLength * this.xLength));
+      var y = Math.floor((index - z * this.yLength * this.xLength) / this.xLength);
+      var x = index - z * this.yLength * this.xLength - y * this.xLength;
+      return [x, y, z];
+    },
+
+    /**
+     * @member {Function} map Apply a function to all the voxels, be careful, the value will be replaced
+     * @memberof Volume
+     * @param {Function} functionToMap A function to apply to every voxel, will be called with the following parameters :
+     *                                 value of the voxel
+     *                                 index of the voxel
+     *                                 the data (TypedArray)
+     * @param {Object}   context    You can specify a context in which call the function, default if this Volume
+     * @returns {Volume}   this
+     */
+    map: function map(functionToMap, context) {
+      var length = this.data.length;
+      context = context || this;
+
+      for (var i = 0; i < length; i++) {
+        this.data[i] = functionToMap.call(context, this.data[i], i, this.data);
+      }
+
+      return this;
+    },
+
+    /**
+     * @member {Function} extractPerpendicularPlane Compute the orientation of the slice and returns all the information relative to the geometry such as sliceAccess, the plane matrix (orientation and position in RAS coordinate) and the dimensions of the plane in both coordinate system.
+     * @memberof Volume
+     * @param {string}            axis  the normal axis to the slice 'x' 'y' or 'z'
+     * @param {number}            index the index of the slice
+     * @returns {Object} an object containing all the usefull information on the geometry of the slice
+     */
+    extractPerpendicularPlane: function extractPerpendicularPlane(axis, RASIndex) {
+      var iLength,
+          jLength,
+          sliceAccess,
+          planeMatrix = new _three.Matrix4().identity(),
+          volume = this,
+          planeWidth,
+          planeHeight,
+          firstSpacing,
+          secondSpacing,
+          positionOffset,
+          IJKIndex;
+      var axisInIJK = new _three.Vector3(),
+          firstDirection = new _three.Vector3(),
+          secondDirection = new _three.Vector3();
+      var dimensions = new _three.Vector3(this.xLength, this.yLength, this.zLength);
+
+      switch (axis) {
+        case 'x':
+          axisInIJK.set(1, 0, 0);
+          firstDirection.set(0, 0, -1);
+          secondDirection.set(0, -1, 0);
+          firstSpacing = this.spacing[this.axisOrder.indexOf('z')];
+          secondSpacing = this.spacing[this.axisOrder.indexOf('y')];
+          IJKIndex = new _three.Vector3(RASIndex, 0, 0);
+          planeMatrix.multiply(new _three.Matrix4().makeRotationY(Math.PI / 2));
+          positionOffset = (volume.RASDimensions[0] - 1) / 2;
+          planeMatrix.setPosition(new _three.Vector3(RASIndex - positionOffset, 0, 0));
+          break;
+
+        case 'y':
+          axisInIJK.set(0, 1, 0);
+          firstDirection.set(1, 0, 0);
+          secondDirection.set(0, 0, 1);
+          firstSpacing = this.spacing[this.axisOrder.indexOf('x')];
+          secondSpacing = this.spacing[this.axisOrder.indexOf('z')];
+          IJKIndex = new _three.Vector3(0, RASIndex, 0);
+          planeMatrix.multiply(new _three.Matrix4().makeRotationX(-Math.PI / 2));
+          positionOffset = (volume.RASDimensions[1] - 1) / 2;
+          planeMatrix.setPosition(new _three.Vector3(0, RASIndex - positionOffset, 0));
+          break;
+
+        case 'z':
+        default:
+          axisInIJK.set(0, 0, 1);
+          firstDirection.set(1, 0, 0);
+          secondDirection.set(0, -1, 0);
+          firstSpacing = this.spacing[this.axisOrder.indexOf('x')];
+          secondSpacing = this.spacing[this.axisOrder.indexOf('y')];
+          IJKIndex = new _three.Vector3(0, 0, RASIndex);
+          positionOffset = (volume.RASDimensions[2] - 1) / 2;
+          planeMatrix.setPosition(new _three.Vector3(0, 0, RASIndex - positionOffset));
+          break;
+      }
+
+      firstDirection.applyMatrix4(volume.inverseMatrix).normalize();
+      firstDirection.argVar = 'i';
+      secondDirection.applyMatrix4(volume.inverseMatrix).normalize();
+      secondDirection.argVar = 'j';
+      axisInIJK.applyMatrix4(volume.inverseMatrix).normalize();
+      iLength = Math.floor(Math.abs(firstDirection.dot(dimensions)));
+      jLength = Math.floor(Math.abs(secondDirection.dot(dimensions)));
+      planeWidth = Math.abs(iLength * firstSpacing);
+      planeHeight = Math.abs(jLength * secondSpacing);
+      IJKIndex = Math.abs(Math.round(IJKIndex.applyMatrix4(volume.inverseMatrix).dot(axisInIJK)));
+      var base = [new _three.Vector3(1, 0, 0), new _three.Vector3(0, 1, 0), new _three.Vector3(0, 0, 1)];
+      var iDirection = [firstDirection, secondDirection, axisInIJK].find(function (x) {
+        return Math.abs(x.dot(base[0])) > 0.9;
+      });
+      var jDirection = [firstDirection, secondDirection, axisInIJK].find(function (x) {
+        return Math.abs(x.dot(base[1])) > 0.9;
+      });
+      var kDirection = [firstDirection, secondDirection, axisInIJK].find(function (x) {
+        return Math.abs(x.dot(base[2])) > 0.9;
+      });
+
+      sliceAccess = function sliceAccess(i, j) {
+        var accessI, accessJ, accessK;
+        var si = iDirection === axisInIJK ? IJKIndex : iDirection.argVar === 'i' ? i : j;
+        var sj = jDirection === axisInIJK ? IJKIndex : jDirection.argVar === 'i' ? i : j;
+        var sk = kDirection === axisInIJK ? IJKIndex : kDirection.argVar === 'i' ? i : j; // invert indices if necessary
+
+        var accessI = iDirection.dot(base[0]) > 0 ? si : volume.xLength - 1 - si;
+        var accessJ = jDirection.dot(base[1]) > 0 ? sj : volume.yLength - 1 - sj;
+        var accessK = kDirection.dot(base[2]) > 0 ? sk : volume.zLength - 1 - sk;
+        return volume.access(accessI, accessJ, accessK);
+      };
+
+      return {
+        iLength: iLength,
+        jLength: jLength,
+        sliceAccess: sliceAccess,
+        matrix: planeMatrix,
+        planeWidth: planeWidth,
+        planeHeight: planeHeight
+      };
+    },
+
+    /**
+     * @member {Function} extractSlice Returns a slice corresponding to the given axis and index
+     *                        The coordinate are given in the Right Anterior Superior coordinate format
+     * @memberof Volume
+     * @param {string}            axis  the normal axis to the slice 'x' 'y' or 'z'
+     * @param {number}            index the index of the slice
+     * @returns {VolumeSlice} the extracted slice
+     */
+    extractSlice: function extractSlice(axis, index) {
+      var slice = new _VolumeSlice.VolumeSlice(this, index, axis);
+      this.sliceList.push(slice);
+      return slice;
+    },
+
+    /**
+     * @member {Function} repaintAllSlices Call repaint on all the slices extracted from this volume
+     * @see VolumeSlice.repaint
+     * @memberof Volume
+     * @returns {Volume} this
+     */
+    repaintAllSlices: function repaintAllSlices() {
+      this.sliceList.forEach(function (slice) {
+        slice.repaint();
+      });
+      return this;
+    },
+
+    /**
+     * @member {Function} computeMinMax Compute the minimum and the maximum of the data in the volume
+     * @memberof Volume
+     * @returns {Array} [min,max]
+     */
+    computeMinMax: function computeMinMax() {
+      var min = Infinity;
+      var max = -Infinity; // buffer the length
+
+      var datasize = this.data.length;
+      var i = 0;
+
+      for (i = 0; i < datasize; i++) {
+        if (!isNaN(this.data[i])) {
+          var value = this.data[i];
+          min = Math.min(min, value);
+          max = Math.max(max, value);
+        }
+      }
+
+      this.min = min;
+      this.max = max;
+      return [min, max];
+    }
+  };
+});

data/lib-opal/js_wrap/three/misc/VolumeSlice.js

@@ -0,0 +1,210 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three);
+    global.VolumeSlice = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.VolumeSlice = VolumeSlice;
+
+  /**
+   * This class has been made to hold a slice of a volume data
+   * @class
+   * @param   {Volume} volume    The associated volume
+   * @param   {number}       [index=0] The index of the slice
+   * @param   {string}       [axis='z']      For now only 'x', 'y' or 'z' but later it will change to a normal vector
+   * @see Volume
+   */
+  function VolumeSlice(volume, index, axis) {
+    var slice = this;
+    /**
+     * @member {Volume} volume The associated volume
+     */
+
+    this.volume = volume;
+    /**
+     * @member {Number} index The index of the slice, if changed, will automatically call updateGeometry at the next repaint
+     */
+
+    index = index || 0;
+    Object.defineProperty(this, 'index', {
+      get: function get() {
+        return index;
+      },
+      set: function set(value) {
+        index = value;
+        slice.geometryNeedsUpdate = true;
+        return index;
+      }
+    });
+    /**
+     * @member {String} axis The normal axis
+     */
+
+    this.axis = axis || 'z';
+    /**
+     * @member {HTMLCanvasElement} canvas The final canvas used for the texture
+     */
+
+    /**
+     * @member {CanvasRenderingContext2D} ctx Context of the canvas
+     */
+
+    this.canvas = document.createElement('canvas');
+    /**
+     * @member {HTMLCanvasElement} canvasBuffer The intermediary canvas used to paint the data
+     */
+
+    /**
+     * @member {CanvasRenderingContext2D} ctxBuffer Context of the canvas buffer
+     */
+
+    this.canvasBuffer = document.createElement('canvas');
+    this.updateGeometry();
+    var canvasMap = new _three.Texture(this.canvas);
+    canvasMap.minFilter = _three.LinearFilter;
+    canvasMap.wrapS = canvasMap.wrapT = _three.ClampToEdgeWrapping;
+    var material = new _three.MeshBasicMaterial({
+      map: canvasMap,
+      side: _three.DoubleSide,
+      transparent: true
+    });
+    /**
+     * @member {Mesh} mesh The mesh ready to get used in the scene
+     */
+
+    this.mesh = new _three.Mesh(this.geometry, material);
+    this.mesh.matrixAutoUpdate = false;
+    /**
+     * @member {Boolean} geometryNeedsUpdate If set to true, updateGeometry will be triggered at the next repaint
+     */
+
+    this.geometryNeedsUpdate = true;
+    this.repaint();
+    /**
+     * @member {Number} iLength Width of slice in the original coordinate system, corresponds to the width of the buffer canvas
+     */
+
+    /**
+     * @member {Number} jLength Height of slice in the original coordinate system, corresponds to the height of the buffer canvas
+     */
+
+    /**
+     * @member {Function} sliceAccess Function that allow the slice to access right data
+     * @see Volume.extractPerpendicularPlane
+     * @param {Number} i The first coordinate
+     * @param {Number} j The second coordinate
+     * @returns {Number} the index corresponding to the voxel in volume.data of the given position in the slice
+     */
+  }
+
+  VolumeSlice.prototype = {
+    constructor: VolumeSlice,
+
+    /**
+     * @member {Function} repaint Refresh the texture and the geometry if geometryNeedsUpdate is set to true
+     * @memberof VolumeSlice
+     */
+    repaint: function repaint() {
+      if (this.geometryNeedsUpdate) {
+        this.updateGeometry();
+      }
+
+      var iLength = this.iLength,
+          jLength = this.jLength,
+          sliceAccess = this.sliceAccess,
+          volume = this.volume,
+          canvas = this.canvasBuffer,
+          ctx = this.ctxBuffer; // get the imageData and pixel array from the canvas
+
+      var imgData = ctx.getImageData(0, 0, iLength, jLength);
+      var data = imgData.data;
+      var volumeData = volume.data;
+      var upperThreshold = volume.upperThreshold;
+      var lowerThreshold = volume.lowerThreshold;
+      var windowLow = volume.windowLow;
+      var windowHigh = volume.windowHigh; // manipulate some pixel elements
+
+      var pixelCount = 0;
+
+      if (volume.dataType === 'label') {
+        //this part is currently useless but will be used when colortables will be handled
+        for (var j = 0; j < jLength; j++) {
+          for (var i = 0; i < iLength; i++) {
+            var label = volumeData[sliceAccess(i, j)];
+            label = label >= this.colorMap.length ? label % this.colorMap.length + 1 : label;
+            var color = this.colorMap[label];
+            data[4 * pixelCount] = color >> 24 & 0xff;
+            data[4 * pixelCount + 1] = color >> 16 & 0xff;
+            data[4 * pixelCount + 2] = color >> 8 & 0xff;
+            data[4 * pixelCount + 3] = color & 0xff;
+            pixelCount++;
+          }
+        }
+      } else {
+        for (var j = 0; j < jLength; j++) {
+          for (var i = 0; i < iLength; i++) {
+            var value = volumeData[sliceAccess(i, j)];
+            var alpha = 0xff; //apply threshold
+
+            alpha = upperThreshold >= value ? lowerThreshold <= value ? alpha : 0 : 0; //apply window level
+
+            value = Math.floor(255 * (value - windowLow) / (windowHigh - windowLow));
+            value = value > 255 ? 255 : value < 0 ? 0 : value | 0;
+            data[4 * pixelCount] = value;
+            data[4 * pixelCount + 1] = value;
+            data[4 * pixelCount + 2] = value;
+            data[4 * pixelCount + 3] = alpha;
+            pixelCount++;
+          }
+        }
+      }
+
+      ctx.putImageData(imgData, 0, 0);
+      this.ctx.drawImage(canvas, 0, 0, iLength, jLength, 0, 0, this.canvas.width, this.canvas.height);
+      this.mesh.material.map.needsUpdate = true;
+    },
+
+    /**
+     * @member {Function} Refresh the geometry according to axis and index
+     * @see Volume.extractPerpendicularPlane
+     * @memberof VolumeSlice
+     */
+    updateGeometry: function updateGeometry() {
+      var extracted = this.volume.extractPerpendicularPlane(this.axis, this.index);
+      this.sliceAccess = extracted.sliceAccess;
+      this.jLength = extracted.jLength;
+      this.iLength = extracted.iLength;
+      this.matrix = extracted.matrix;
+      this.canvas.width = extracted.planeWidth;
+      this.canvas.height = extracted.planeHeight;
+      this.canvasBuffer.width = this.iLength;
+      this.canvasBuffer.height = this.jLength;
+      this.ctx = this.canvas.getContext('2d');
+      this.ctxBuffer = this.canvasBuffer.getContext('2d');
+      if (this.geometry) this.geometry.dispose(); // dispose existing geometry
+
+      this.geometry = new _three.PlaneGeometry(extracted.planeWidth, extracted.planeHeight);
+
+      if (this.mesh) {
+        this.mesh.geometry = this.geometry; //reset mesh matrix
+
+        this.mesh.matrix.identity();
+        this.mesh.applyMatrix4(this.matrix);
+      }
+
+      this.geometryNeedsUpdate = false;
+    }
+  };
+});