three-stdlib 2.22.7 → 2.22.9

package/dist/misc/VolumeSlice.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+var VolumeSlice = function(volume, index, axis) {
+  var slice = this;
+  this.volume = volume;
+  index = index || 0;
+  Object.defineProperty(this, "index", {
+    get: function() {
+      return index;
+    },
+    set: function(value) {
+      index = value;
+      slice.geometryNeedsUpdate = true;
+      return index;
+    }
+  });
+  this.axis = axis || "z";
+  this.canvas = document.createElement("canvas");
+  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
+  });
+  this.mesh = new THREE.Mesh(this.geometry, material);
+  this.mesh.matrixAutoUpdate = false;
+  this.geometryNeedsUpdate = true;
+  this.repaint();
+};
+VolumeSlice.prototype = {
+  constructor: VolumeSlice,
+  /**
+   * @member {Function} repaint Refresh the texture and the geometry if geometryNeedsUpdate is set to true
+   * @memberof VolumeSlice
+   */
+  repaint: function() {
+    if (this.geometryNeedsUpdate) {
+      this.updateGeometry();
+    }
+    var iLength = this.iLength, jLength = this.jLength, sliceAccess = this.sliceAccess, volume = this.volume, canvas = this.canvasBuffer, ctx = this.ctxBuffer;
+    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;
+    var pixelCount = 0;
+    if (volume.dataType === "label") {
+      for (let j = 0; j < jLength; j++) {
+        for (let 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 & 255;
+          data[4 * pixelCount + 1] = color >> 16 & 255;
+          data[4 * pixelCount + 2] = color >> 8 & 255;
+          data[4 * pixelCount + 3] = color & 255;
+          pixelCount++;
+        }
+      }
+    } else {
+      for (let j = 0; j < jLength; j++) {
+        for (let i = 0; i < iLength; i++) {
+          var value = volumeData[sliceAccess(i, j)];
+          var alpha = 255;
+          alpha = upperThreshold >= value ? lowerThreshold <= value ? alpha : 0 : 0;
+          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() {
+    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();
+    this.geometry = new THREE.PlaneGeometry(extracted.planeWidth, extracted.planeHeight);
+    if (this.mesh) {
+      this.mesh.geometry = this.geometry;
+      this.mesh.matrix.identity();
+      this.mesh.applyMatrix4(this.matrix);
+    }
+    this.geometryNeedsUpdate = false;
+  }
+};
+exports.VolumeSlice = VolumeSlice;

package/dist/misc/VolumeSlice.mjs

@@ -0,0 +1,115 @@
+import { Texture, LinearFilter, ClampToEdgeWrapping, MeshBasicMaterial, DoubleSide, Mesh, PlaneGeometry } from "three";
+var VolumeSlice = function(volume, index, axis) {
+  var slice = this;
+  this.volume = volume;
+  index = index || 0;
+  Object.defineProperty(this, "index", {
+    get: function() {
+      return index;
+    },
+    set: function(value) {
+      index = value;
+      slice.geometryNeedsUpdate = true;
+      return index;
+    }
+  });
+  this.axis = axis || "z";
+  this.canvas = document.createElement("canvas");
+  this.canvasBuffer = document.createElement("canvas");
+  this.updateGeometry();
+  var canvasMap = new Texture(this.canvas);
+  canvasMap.minFilter = LinearFilter;
+  canvasMap.wrapS = canvasMap.wrapT = ClampToEdgeWrapping;
+  var material = new MeshBasicMaterial({
+    map: canvasMap,
+    side: DoubleSide,
+    transparent: true
+  });
+  this.mesh = new Mesh(this.geometry, material);
+  this.mesh.matrixAutoUpdate = false;
+  this.geometryNeedsUpdate = true;
+  this.repaint();
+};
+VolumeSlice.prototype = {
+  constructor: VolumeSlice,
+  /**
+   * @member {Function} repaint Refresh the texture and the geometry if geometryNeedsUpdate is set to true
+   * @memberof VolumeSlice
+   */
+  repaint: function() {
+    if (this.geometryNeedsUpdate) {
+      this.updateGeometry();
+    }
+    var iLength = this.iLength, jLength = this.jLength, sliceAccess = this.sliceAccess, volume = this.volume, canvas = this.canvasBuffer, ctx = this.ctxBuffer;
+    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;
+    var pixelCount = 0;
+    if (volume.dataType === "label") {
+      for (let j = 0; j < jLength; j++) {
+        for (let 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 & 255;
+          data[4 * pixelCount + 1] = color >> 16 & 255;
+          data[4 * pixelCount + 2] = color >> 8 & 255;
+          data[4 * pixelCount + 3] = color & 255;
+          pixelCount++;
+        }
+      }
+    } else {
+      for (let j = 0; j < jLength; j++) {
+        for (let i = 0; i < iLength; i++) {
+          var value = volumeData[sliceAccess(i, j)];
+          var alpha = 255;
+          alpha = upperThreshold >= value ? lowerThreshold <= value ? alpha : 0 : 0;
+          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() {
+    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();
+    this.geometry = new PlaneGeometry(extracted.planeWidth, extracted.planeHeight);
+    if (this.mesh) {
+      this.mesh.geometry = this.geometry;
+      this.mesh.matrix.identity();
+      this.mesh.applyMatrix4(this.matrix);
+    }
+    this.geometryNeedsUpdate = false;
+  }
+};
+export {
+  VolumeSlice
+};

package/dist/misc/WebGL.d.ts

@@ -0,0 +1,5 @@
+export declare function isWebGLAvailable(): boolean;
+export declare function isWebGL2Available(): boolean;
+export declare function getWebGLErrorMessage(): HTMLDivElement;
+export declare function getWebGL2ErrorMessage(): HTMLDivElement;
+export declare function getErrorMessage(version: 1 | 2): HTMLDivElement;

package/dist/misc/WebGL.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let webGLAvailable, webGL2Available;
+function isWebGLAvailable() {
+  var _a;
+  if (webGLAvailable !== void 0)
+    return webGLAvailable;
+  try {
+    let gl;
+    const canvas = document.createElement("canvas");
+    webGLAvailable = !!(window.WebGLRenderingContext && (gl = canvas.getContext("webgl")));
+    if (gl)
+      (_a = gl.getExtension("WEBGL_lose_context")) == null ? void 0 : _a.loseContext();
+    return webGLAvailable;
+  } catch (e) {
+    return webGLAvailable = false;
+  }
+}
+function isWebGL2Available() {
+  var _a;
+  if (webGL2Available !== void 0)
+    return webGL2Available;
+  try {
+    let gl;
+    const canvas = document.createElement("canvas");
+    webGL2Available = !!(window.WebGL2RenderingContext && (gl = canvas.getContext("webgl2")));
+    if (gl)
+      (_a = gl.getExtension("WEBGL_lose_context")) == null ? void 0 : _a.loseContext();
+    return webGL2Available;
+  } catch (e) {
+    return webGL2Available = false;
+  }
+}
+function getWebGLErrorMessage() {
+  return getErrorMessage(1);
+}
+function getWebGL2ErrorMessage() {
+  return getErrorMessage(2);
+}
+function getErrorMessage(version) {
+  const names = {
+    1: "WebGL",
+    2: "WebGL 2"
+  };
+  const contexts = {
+    1: window.WebGLRenderingContext,
+    2: window.WebGL2RenderingContext
+  };
+  const element = document.createElement("div");
+  element.id = "webglmessage";
+  element.style.fontFamily = "monospace";
+  element.style.fontSize = "13px";
+  element.style.fontWeight = "normal";
+  element.style.textAlign = "center";
+  element.style.background = "#fff";
+  element.style.color = "#000";
+  element.style.padding = "1.5em";
+  element.style.width = "400px";
+  element.style.margin = "5em auto 0";
+  let message = 'Your $0 does not seem to support <a href="http://khronos.org/webgl/wiki/Getting_a_WebGL_Implementation" style="color:#000">$1</a>';
+  if (contexts[version]) {
+    message = message.replace("$0", "graphics card");
+  } else {
+    message = message.replace("$0", "browser");
+  }
+  message = message.replace("$1", names[version]);
+  element.innerHTML = message;
+  return element;
+}
+exports.getErrorMessage = getErrorMessage;
+exports.getWebGL2ErrorMessage = getWebGL2ErrorMessage;
+exports.getWebGLErrorMessage = getWebGLErrorMessage;
+exports.isWebGL2Available = isWebGL2Available;
+exports.isWebGLAvailable = isWebGLAvailable;

package/dist/misc/WebGL.mjs

@@ -0,0 +1,74 @@
+let webGLAvailable, webGL2Available;
+function isWebGLAvailable() {
+  var _a;
+  if (webGLAvailable !== void 0)
+    return webGLAvailable;
+  try {
+    let gl;
+    const canvas = document.createElement("canvas");
+    webGLAvailable = !!(window.WebGLRenderingContext && (gl = canvas.getContext("webgl")));
+    if (gl)
+      (_a = gl.getExtension("WEBGL_lose_context")) == null ? void 0 : _a.loseContext();
+    return webGLAvailable;
+  } catch (e) {
+    return webGLAvailable = false;
+  }
+}
+function isWebGL2Available() {
+  var _a;
+  if (webGL2Available !== void 0)
+    return webGL2Available;
+  try {
+    let gl;
+    const canvas = document.createElement("canvas");
+    webGL2Available = !!(window.WebGL2RenderingContext && (gl = canvas.getContext("webgl2")));
+    if (gl)
+      (_a = gl.getExtension("WEBGL_lose_context")) == null ? void 0 : _a.loseContext();
+    return webGL2Available;
+  } catch (e) {
+    return webGL2Available = false;
+  }
+}
+function getWebGLErrorMessage() {
+  return getErrorMessage(1);
+}
+function getWebGL2ErrorMessage() {
+  return getErrorMessage(2);
+}
+function getErrorMessage(version) {
+  const names = {
+    1: "WebGL",
+    2: "WebGL 2"
+  };
+  const contexts = {
+    1: window.WebGLRenderingContext,
+    2: window.WebGL2RenderingContext
+  };
+  const element = document.createElement("div");
+  element.id = "webglmessage";
+  element.style.fontFamily = "monospace";
+  element.style.fontSize = "13px";
+  element.style.fontWeight = "normal";
+  element.style.textAlign = "center";
+  element.style.background = "#fff";
+  element.style.color = "#000";
+  element.style.padding = "1.5em";
+  element.style.width = "400px";
+  element.style.margin = "5em auto 0";
+  let message = 'Your $0 does not seem to support <a href="http://khronos.org/webgl/wiki/Getting_a_WebGL_Implementation" style="color:#000">$1</a>';
+  if (contexts[version]) {
+    message = message.replace("$0", "graphics card");
+  } else {
+    message = message.replace("$0", "browser");
+  }
+  message = message.replace("$1", names[version]);
+  element.innerHTML = message;
+  return element;
+}
+export {
+  getErrorMessage,
+  getWebGL2ErrorMessage,
+  getWebGLErrorMessage,
+  isWebGL2Available,
+  isWebGLAvailable
+};

package/dist/modifiers/CurveModifier.d.ts

@@ -0,0 +1,91 @@
+import { DataTexture, Mesh, InstancedMesh, Material, Curve, BufferGeometry } from 'three';
+import type { IUniform } from 'three';
+/**
+ * Make a new DataTexture to store the descriptions of the curves.
+ *
+ * @param { number } numberOfCurves the number of curves needed to be described by this texture.
+ */
+export declare const initSplineTexture: (numberOfCurves?: number) => DataTexture;
+/**
+ * Write the curve description to the data texture
+ *
+ * @param { DataTexture } texture The DataTexture to write to
+ * @param { Curve } splineCurve The curve to describe
+ * @param { number } offset Which curve slot to write to
+ */
+export declare const updateSplineTexture: <TCurve extends Curve<any>>(texture: DataTexture, splineCurve: TCurve, offset?: number) => void;
+export interface INumericUniform extends IUniform {
+    type: 'f' | 'i';
+    value: number;
+}
+export declare type CurveModifierUniforms = {
+    spineTexture: IUniform<DataTexture>;
+    pathOffset: INumericUniform;
+    pathSegment: INumericUniform;
+    spineOffset: INumericUniform;
+    spineLength: INumericUniform;
+    flow: INumericUniform;
+};
+/**
+ * Create a new set of uniforms for describing the curve modifier
+ *
+ * @param { DataTexture } Texture which holds the curve description
+ */
+export declare const getUniforms: (splineTexture: DataTexture) => CurveModifierUniforms;
+export declare type ModifiedMaterial<TMaterial extends Material> = TMaterial & {
+    __ok: boolean;
+};
+export declare function modifyShader<TMaterial extends Material = Material>(material: ModifiedMaterial<TMaterial>, uniforms: CurveModifierUniforms, numberOfCurves?: number): void;
+/**
+ * A helper class for making meshes bend aroudn curves
+ */
+export declare class Flow<TMesh extends Mesh = Mesh> {
+    curveArray: Curve<any>[];
+    curveLengthArray: number[];
+    object3D: TMesh;
+    splineTexure: DataTexture;
+    uniforms: CurveModifierUniforms;
+    /**
+     * @param {Mesh} mesh The mesh to clone and modify to bend around the curve
+     * @param {number} numberOfCurves The amount of space that should preallocated for additional curves
+     */
+    constructor(mesh: TMesh, numberOfCurves?: number);
+    updateCurve<TCurve extends Curve<any>>(index: number, curve: TCurve): void;
+    moveAlongCurve(amount: number): void;
+}
+/**
+ * A helper class for creating instanced versions of flow, where the instances are placed on the curve.
+ */
+export declare class InstancedFlow<TGeometry extends BufferGeometry = BufferGeometry, TMaterial extends Material = Material> extends Flow<InstancedMesh<TGeometry, TMaterial>> {
+    offsets: number[];
+    whichCurve: number[];
+    /**
+     *
+     * @param {number} count The number of instanced elements
+     * @param {number} curveCount The number of curves to preallocate for
+     * @param {Geometry} geometry The geometry to use for the instanced mesh
+     * @param {Material} material The material to use for the instanced mesh
+     */
+    constructor(count: number, curveCount: number, geometry: TGeometry, material: TMaterial);
+    /**
+     * The extra information about which curve and curve position is stored in the translation components of the matrix for the instanced objects
+     * This writes that information to the matrix and marks it as needing update.
+     *
+     * @param {number} index of the instanced element to update
+     */
+    private writeChanges;
+    /**
+     * Move an individual element along the curve by a specific amount
+     *
+     * @param {number} index Which element to update
+     * @param {number} offset Move by how much
+     */
+    moveIndividualAlongCurve(index: number, offset: number): void;
+    /**
+     * Select which curve to use for an element
+     *
+     * @param {number} index the index of the instanced element to update
+     * @param {number} curveNo the index of the curve it should use
+     */
+    setCurve(index: number, curveNo: number): void;
+}