three-stdlib 2.22.7 → 2.22.9

package/dist/misc/Timer.d.ts

@@ -0,0 +1,27 @@
+declare class Timer {
+    private _previousTime;
+    private _currentTime;
+    private _delta;
+    private _elapsed;
+    private _timescale;
+    private _useFixedDelta;
+    private _fixedDelta;
+    private _usePageVisibilityAPI;
+    private _pageVisibilityHandler;
+    constructor();
+    connect(): this;
+    dispose(): this;
+    disableFixedDelta(): this;
+    enableFixedDelta(): this;
+    getDelta(): number;
+    getElapsedTime(): number;
+    getFixedDelta(): number;
+    getTimescale(): number;
+    reset(): this;
+    setFixedDelta(fixedDelta: number): this;
+    setTimescale(timescale: number): this;
+    update(): this;
+    get elapsedTime(): number;
+    private _now;
+}
+export { Timer };

package/dist/misc/Timer.js

@@ -0,0 +1,101 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class Timer {
+  constructor() {
+    __publicField(this, "_previousTime");
+    __publicField(this, "_currentTime");
+    __publicField(this, "_delta");
+    __publicField(this, "_elapsed");
+    __publicField(this, "_timescale");
+    __publicField(this, "_useFixedDelta");
+    __publicField(this, "_fixedDelta");
+    __publicField(this, "_usePageVisibilityAPI");
+    __publicField(this, "_pageVisibilityHandler");
+    this._previousTime = 0;
+    this._currentTime = 0;
+    this._delta = 0;
+    this._elapsed = 0;
+    this._timescale = 1;
+    this._useFixedDelta = false;
+    this._fixedDelta = 16.67;
+    this._usePageVisibilityAPI = typeof document !== "undefined" && document.hidden !== void 0;
+  }
+  // https://github.com/mrdoob/three.js/issues/20575
+  // use Page Visibility API to avoid large time delta values
+  connect() {
+    if (this._usePageVisibilityAPI) {
+      this._pageVisibilityHandler = handleVisibilityChange.bind(this);
+      document.addEventListener("visibilitychange", this._pageVisibilityHandler, false);
+    }
+    return this;
+  }
+  dispose() {
+    if (this._usePageVisibilityAPI && this._pageVisibilityHandler) {
+      document.removeEventListener("visibilitychange", this._pageVisibilityHandler);
+    }
+    return this;
+  }
+  disableFixedDelta() {
+    this._useFixedDelta = false;
+    return this;
+  }
+  enableFixedDelta() {
+    this._useFixedDelta = true;
+    return this;
+  }
+  getDelta() {
+    return this._delta / 1e3;
+  }
+  getElapsedTime() {
+    return this._elapsed / 1e3;
+  }
+  getFixedDelta() {
+    return this._fixedDelta / 1e3;
+  }
+  getTimescale() {
+    return this._timescale;
+  }
+  reset() {
+    this._currentTime = this._now();
+    return this;
+  }
+  setFixedDelta(fixedDelta) {
+    this._fixedDelta = fixedDelta * 1e3;
+    return this;
+  }
+  setTimescale(timescale) {
+    this._timescale = timescale;
+    return this;
+  }
+  update() {
+    if (this._useFixedDelta === true) {
+      this._delta = this._fixedDelta;
+    } else {
+      this._previousTime = this._currentTime;
+      this._currentTime = this._now();
+      this._delta = this._currentTime - this._previousTime;
+    }
+    this._delta *= this._timescale;
+    this._elapsed += this._delta;
+    return this;
+  }
+  // For THREE.Clock backward compatibility
+  get elapsedTime() {
+    return this.getElapsedTime();
+  }
+  // private
+  _now() {
+    return (typeof performance === "undefined" ? Date : performance).now();
+  }
+}
+function handleVisibilityChange() {
+  if (document.hidden === false)
+    this.reset();
+}
+exports.Timer = Timer;

package/dist/misc/Timer.mjs

@@ -0,0 +1,101 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Timer {
+  constructor() {
+    __publicField(this, "_previousTime");
+    __publicField(this, "_currentTime");
+    __publicField(this, "_delta");
+    __publicField(this, "_elapsed");
+    __publicField(this, "_timescale");
+    __publicField(this, "_useFixedDelta");
+    __publicField(this, "_fixedDelta");
+    __publicField(this, "_usePageVisibilityAPI");
+    __publicField(this, "_pageVisibilityHandler");
+    this._previousTime = 0;
+    this._currentTime = 0;
+    this._delta = 0;
+    this._elapsed = 0;
+    this._timescale = 1;
+    this._useFixedDelta = false;
+    this._fixedDelta = 16.67;
+    this._usePageVisibilityAPI = typeof document !== "undefined" && document.hidden !== void 0;
+  }
+  // https://github.com/mrdoob/three.js/issues/20575
+  // use Page Visibility API to avoid large time delta values
+  connect() {
+    if (this._usePageVisibilityAPI) {
+      this._pageVisibilityHandler = handleVisibilityChange.bind(this);
+      document.addEventListener("visibilitychange", this._pageVisibilityHandler, false);
+    }
+    return this;
+  }
+  dispose() {
+    if (this._usePageVisibilityAPI && this._pageVisibilityHandler) {
+      document.removeEventListener("visibilitychange", this._pageVisibilityHandler);
+    }
+    return this;
+  }
+  disableFixedDelta() {
+    this._useFixedDelta = false;
+    return this;
+  }
+  enableFixedDelta() {
+    this._useFixedDelta = true;
+    return this;
+  }
+  getDelta() {
+    return this._delta / 1e3;
+  }
+  getElapsedTime() {
+    return this._elapsed / 1e3;
+  }
+  getFixedDelta() {
+    return this._fixedDelta / 1e3;
+  }
+  getTimescale() {
+    return this._timescale;
+  }
+  reset() {
+    this._currentTime = this._now();
+    return this;
+  }
+  setFixedDelta(fixedDelta) {
+    this._fixedDelta = fixedDelta * 1e3;
+    return this;
+  }
+  setTimescale(timescale) {
+    this._timescale = timescale;
+    return this;
+  }
+  update() {
+    if (this._useFixedDelta === true) {
+      this._delta = this._fixedDelta;
+    } else {
+      this._previousTime = this._currentTime;
+      this._currentTime = this._now();
+      this._delta = this._currentTime - this._previousTime;
+    }
+    this._delta *= this._timescale;
+    this._elapsed += this._delta;
+    return this;
+  }
+  // For THREE.Clock backward compatibility
+  get elapsedTime() {
+    return this.getElapsedTime();
+  }
+  // private
+  _now() {
+    return (typeof performance === "undefined" ? Date : performance).now();
+  }
+}
+function handleVisibilityChange() {
+  if (document.hidden === false)
+    this.reset();
+}
+export {
+  Timer
+};

package/dist/misc/TubePainter.d.ts

@@ -0,0 +1,10 @@
+import { Matrix4, Mesh, Vector3 } from 'three'
+
+export class TubePainter {
+  constructor()
+
+  mesh: Mesh
+
+  stroke(position1: Vector3, position2: Vector3, matrix1: Matrix4, matrix2: Matrix4): void
+  updateGeometry(start: number, end: number): void
+}

package/dist/misc/TubePainter.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+function TubePainter() {
+  const BUFFER_SIZE = 1e6 * 3;
+  const positions = new THREE.BufferAttribute(new Float32Array(BUFFER_SIZE), 3);
+  positions.usage = THREE.DynamicDrawUsage;
+  const normals = new THREE.BufferAttribute(new Float32Array(BUFFER_SIZE), 3);
+  normals.usage = THREE.DynamicDrawUsage;
+  const colors = new THREE.BufferAttribute(new Float32Array(BUFFER_SIZE), 3);
+  colors.usage = THREE.DynamicDrawUsage;
+  const geometry = new THREE.BufferGeometry();
+  geometry.setAttribute("position", positions);
+  geometry.setAttribute("normal", normals);
+  geometry.setAttribute("color", colors);
+  geometry.drawRange.count = 0;
+  const material = new THREE.MeshStandardMaterial({
+    vertexColors: true
+  });
+  const mesh = new THREE.Mesh(geometry, material);
+  mesh.frustumCulled = false;
+  function getPoints(size2) {
+    const PI2 = Math.PI * 2;
+    const sides = 10;
+    const array = [];
+    const radius = 0.01 * size2;
+    for (let i = 0; i < sides; i++) {
+      const angle = i / sides * PI2;
+      array.push(new THREE.Vector3(Math.sin(angle) * radius, Math.cos(angle) * radius, 0));
+    }
+    return array;
+  }
+  const vector1 = new THREE.Vector3();
+  const vector2 = new THREE.Vector3();
+  const vector3 = new THREE.Vector3();
+  const vector4 = new THREE.Vector3();
+  const color = new THREE.Color(16777215);
+  let size = 1;
+  function stroke(position1, position2, matrix12, matrix22) {
+    if (position1.distanceToSquared(position2) === 0)
+      return;
+    let count2 = geometry.drawRange.count;
+    const points = getPoints(size);
+    for (let i = 0, il = points.length; i < il; i++) {
+      const vertex1 = points[i];
+      const vertex2 = points[(i + 1) % il];
+      vector1.copy(vertex1).applyMatrix4(matrix22).add(position2);
+      vector2.copy(vertex2).applyMatrix4(matrix22).add(position2);
+      vector3.copy(vertex2).applyMatrix4(matrix12).add(position1);
+      vector4.copy(vertex1).applyMatrix4(matrix12).add(position1);
+      vector1.toArray(positions.array, (count2 + 0) * 3);
+      vector2.toArray(positions.array, (count2 + 1) * 3);
+      vector4.toArray(positions.array, (count2 + 2) * 3);
+      vector2.toArray(positions.array, (count2 + 3) * 3);
+      vector3.toArray(positions.array, (count2 + 4) * 3);
+      vector4.toArray(positions.array, (count2 + 5) * 3);
+      vector1.copy(vertex1).applyMatrix4(matrix22).normalize();
+      vector2.copy(vertex2).applyMatrix4(matrix22).normalize();
+      vector3.copy(vertex2).applyMatrix4(matrix12).normalize();
+      vector4.copy(vertex1).applyMatrix4(matrix12).normalize();
+      vector1.toArray(normals.array, (count2 + 0) * 3);
+      vector2.toArray(normals.array, (count2 + 1) * 3);
+      vector4.toArray(normals.array, (count2 + 2) * 3);
+      vector2.toArray(normals.array, (count2 + 3) * 3);
+      vector3.toArray(normals.array, (count2 + 4) * 3);
+      vector4.toArray(normals.array, (count2 + 5) * 3);
+      color.toArray(colors.array, (count2 + 0) * 3);
+      color.toArray(colors.array, (count2 + 1) * 3);
+      color.toArray(colors.array, (count2 + 2) * 3);
+      color.toArray(colors.array, (count2 + 3) * 3);
+      color.toArray(colors.array, (count2 + 4) * 3);
+      color.toArray(colors.array, (count2 + 5) * 3);
+      count2 += 6;
+    }
+    geometry.drawRange.count = count2;
+  }
+  const up = new THREE.Vector3(0, 1, 0);
+  const point1 = new THREE.Vector3();
+  const point2 = new THREE.Vector3();
+  const matrix1 = new THREE.Matrix4();
+  const matrix2 = new THREE.Matrix4();
+  function moveTo(position) {
+    point1.copy(position);
+    matrix1.lookAt(point2, point1, up);
+    point2.copy(position);
+    matrix2.copy(matrix1);
+  }
+  function lineTo(position) {
+    point1.copy(position);
+    matrix1.lookAt(point2, point1, up);
+    stroke(point1, point2, matrix1, matrix2);
+    point2.copy(point1);
+    matrix2.copy(matrix1);
+  }
+  function setSize(value) {
+    size = value;
+  }
+  let count = 0;
+  function update() {
+    const start = count;
+    const end = geometry.drawRange.count;
+    if (start === end)
+      return;
+    positions.updateRange.offset = start * 3;
+    positions.updateRange.count = (end - start) * 3;
+    positions.needsUpdate = true;
+    normals.updateRange.offset = start * 3;
+    normals.updateRange.count = (end - start) * 3;
+    normals.needsUpdate = true;
+    colors.updateRange.offset = start * 3;
+    colors.updateRange.count = (end - start) * 3;
+    colors.needsUpdate = true;
+    count = geometry.drawRange.count;
+  }
+  return {
+    mesh,
+    moveTo,
+    lineTo,
+    setSize,
+    update
+  };
+}
+exports.TubePainter = TubePainter;

package/dist/misc/TubePainter.mjs

@@ -0,0 +1,123 @@
+import { BufferAttribute, DynamicDrawUsage, BufferGeometry, MeshStandardMaterial, Mesh, Vector3, Color, Matrix4 } from "three";
+function TubePainter() {
+  const BUFFER_SIZE = 1e6 * 3;
+  const positions = new BufferAttribute(new Float32Array(BUFFER_SIZE), 3);
+  positions.usage = DynamicDrawUsage;
+  const normals = new BufferAttribute(new Float32Array(BUFFER_SIZE), 3);
+  normals.usage = DynamicDrawUsage;
+  const colors = new BufferAttribute(new Float32Array(BUFFER_SIZE), 3);
+  colors.usage = DynamicDrawUsage;
+  const geometry = new BufferGeometry();
+  geometry.setAttribute("position", positions);
+  geometry.setAttribute("normal", normals);
+  geometry.setAttribute("color", colors);
+  geometry.drawRange.count = 0;
+  const material = new MeshStandardMaterial({
+    vertexColors: true
+  });
+  const mesh = new Mesh(geometry, material);
+  mesh.frustumCulled = false;
+  function getPoints(size2) {
+    const PI2 = Math.PI * 2;
+    const sides = 10;
+    const array = [];
+    const radius = 0.01 * size2;
+    for (let i = 0; i < sides; i++) {
+      const angle = i / sides * PI2;
+      array.push(new Vector3(Math.sin(angle) * radius, Math.cos(angle) * radius, 0));
+    }
+    return array;
+  }
+  const vector1 = new Vector3();
+  const vector2 = new Vector3();
+  const vector3 = new Vector3();
+  const vector4 = new Vector3();
+  const color = new Color(16777215);
+  let size = 1;
+  function stroke(position1, position2, matrix12, matrix22) {
+    if (position1.distanceToSquared(position2) === 0)
+      return;
+    let count2 = geometry.drawRange.count;
+    const points = getPoints(size);
+    for (let i = 0, il = points.length; i < il; i++) {
+      const vertex1 = points[i];
+      const vertex2 = points[(i + 1) % il];
+      vector1.copy(vertex1).applyMatrix4(matrix22).add(position2);
+      vector2.copy(vertex2).applyMatrix4(matrix22).add(position2);
+      vector3.copy(vertex2).applyMatrix4(matrix12).add(position1);
+      vector4.copy(vertex1).applyMatrix4(matrix12).add(position1);
+      vector1.toArray(positions.array, (count2 + 0) * 3);
+      vector2.toArray(positions.array, (count2 + 1) * 3);
+      vector4.toArray(positions.array, (count2 + 2) * 3);
+      vector2.toArray(positions.array, (count2 + 3) * 3);
+      vector3.toArray(positions.array, (count2 + 4) * 3);
+      vector4.toArray(positions.array, (count2 + 5) * 3);
+      vector1.copy(vertex1).applyMatrix4(matrix22).normalize();
+      vector2.copy(vertex2).applyMatrix4(matrix22).normalize();
+      vector3.copy(vertex2).applyMatrix4(matrix12).normalize();
+      vector4.copy(vertex1).applyMatrix4(matrix12).normalize();
+      vector1.toArray(normals.array, (count2 + 0) * 3);
+      vector2.toArray(normals.array, (count2 + 1) * 3);
+      vector4.toArray(normals.array, (count2 + 2) * 3);
+      vector2.toArray(normals.array, (count2 + 3) * 3);
+      vector3.toArray(normals.array, (count2 + 4) * 3);
+      vector4.toArray(normals.array, (count2 + 5) * 3);
+      color.toArray(colors.array, (count2 + 0) * 3);
+      color.toArray(colors.array, (count2 + 1) * 3);
+      color.toArray(colors.array, (count2 + 2) * 3);
+      color.toArray(colors.array, (count2 + 3) * 3);
+      color.toArray(colors.array, (count2 + 4) * 3);
+      color.toArray(colors.array, (count2 + 5) * 3);
+      count2 += 6;
+    }
+    geometry.drawRange.count = count2;
+  }
+  const up = new Vector3(0, 1, 0);
+  const point1 = new Vector3();
+  const point2 = new Vector3();
+  const matrix1 = new Matrix4();
+  const matrix2 = new Matrix4();
+  function moveTo(position) {
+    point1.copy(position);
+    matrix1.lookAt(point2, point1, up);
+    point2.copy(position);
+    matrix2.copy(matrix1);
+  }
+  function lineTo(position) {
+    point1.copy(position);
+    matrix1.lookAt(point2, point1, up);
+    stroke(point1, point2, matrix1, matrix2);
+    point2.copy(point1);
+    matrix2.copy(matrix1);
+  }
+  function setSize(value) {
+    size = value;
+  }
+  let count = 0;
+  function update() {
+    const start = count;
+    const end = geometry.drawRange.count;
+    if (start === end)
+      return;
+    positions.updateRange.offset = start * 3;
+    positions.updateRange.count = (end - start) * 3;
+    positions.needsUpdate = true;
+    normals.updateRange.offset = start * 3;
+    normals.updateRange.count = (end - start) * 3;
+    normals.needsUpdate = true;
+    colors.updateRange.offset = start * 3;
+    colors.updateRange.count = (end - start) * 3;
+    colors.needsUpdate = true;
+    count = geometry.drawRange.count;
+  }
+  return {
+    mesh,
+    moveTo,
+    lineTo,
+    setSize,
+    update
+  };
+}
+export {
+  TubePainter
+};

package/dist/misc/Volume.d.ts

@@ -0,0 +1,37 @@
+import { Matrix3 } from 'three'
+
+import { VolumeSlice } from './VolumeSlice.js'
+
+export class Volume {
+  constructor(xLength?: number, yLength?: number, zLength?: number, type?: string, arrayBuffer?: ArrayLike<number>)
+
+  xLength: number
+  yLength: number
+  zLength: number
+
+  axisOrder: Array<'x' | 'y' | 'z'>
+
+  data: ArrayLike<number>
+
+  spacing: number[]
+  offset: number[]
+
+  matrix: Matrix3
+
+  lowerThreshold: number
+  upperThreshold: number
+
+  sliceList: VolumeSlice[]
+
+  getData(i: number, j: number, k: number): number
+  access(i: number, j: number, k: number): number
+  reverseAccess(index: number): number[]
+
+  map(functionToMap: () => void, context: this): this
+
+  extractPerpendicularPlane(axis: string, RASIndex: number): object
+  extractSlice(axis: string, index: number): VolumeSlice
+
+  repaintAllSlices(): this
+  computeMinMax(): number[]
+}