three-stdlib 2.15.1 → 2.15.2

package/math/Lut.js

@@ -1,11 +1,11 @@
-import { Color } from 'three';
-
-var Lut = function (colormap, numberofcolors) {
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
+var Lut = function(colormap, numberofcolors) {
   this.lut = [];
   this.setColorMap(colormap, numberofcolors);
   return this;
 };
-
 Lut.prototype = {
   constructor: Lut,
   lut: [],
@@ -13,43 +13,40 @@ Lut.prototype = {
   n: 256,
   minV: 0,
   maxV: 1,
-  set: function (value) {
+  set: function(value) {
     if (value instanceof Lut) {
       this.copy(value);
     }
-
     return this;
   },
-  setMin: function (min) {
+  setMin: function(min) {
     this.minV = min;
     return this;
   },
-  setMax: function (max) {
+  setMax: function(max) {
     this.maxV = max;
     return this;
   },
-  setColorMap: function (colormap, numberofcolors) {
+  setColorMap: function(colormap, numberofcolors) {
     this.map = ColorMapKeywords[colormap] || ColorMapKeywords.rainbow;
     this.n = numberofcolors || 32;
-    var step = 1.0 / this.n;
+    var step = 1 / this.n;
     this.lut.length = 0;
-
     for (let i = 0; i <= 1; i += step) {
       for (let j = 0; j < this.map.length - 1; j++) {
         if (i >= this.map[j][0] && i < this.map[j + 1][0]) {
           var min = this.map[j][0];
           var max = this.map[j + 1][0];
-          var minColor = new Color(this.map[j][1]);
-          var maxColor = new Color(this.map[j + 1][1]);
+          var minColor = new THREE.Color(this.map[j][1]);
+          var maxColor = new THREE.Color(this.map[j + 1][1]);
           var color = minColor.lerp(maxColor, (i - min) / (max - min));
           this.lut.push(color);
         }
       }
     }
-
     return this;
   },
-  copy: function (lut) {
+  copy: function(lut) {
     this.lut = lut.lut;
     this.map = lut.map;
     this.n = lut.n;
@@ -57,44 +54,40 @@ Lut.prototype = {
     this.maxV = lut.maxV;
     return this;
   },
-  getColor: function (alpha) {
+  getColor: function(alpha) {
     if (alpha <= this.minV) {
       alpha = this.minV;
     } else if (alpha >= this.maxV) {
       alpha = this.maxV;
     }
-
     alpha = (alpha - this.minV) / (this.maxV - this.minV);
     var colorPosition = Math.round(alpha * this.n);
     colorPosition == this.n ? colorPosition -= 1 : colorPosition;
     return this.lut[colorPosition];
   },
-  addColorMap: function (colormapName, arrayOfColors) {
+  addColorMap: function(colormapName, arrayOfColors) {
     ColorMapKeywords[colormapName] = arrayOfColors;
   },
-  createCanvas: function () {
-    var canvas = document.createElement('canvas');
+  createCanvas: function() {
+    var canvas = document.createElement("canvas");
     canvas.width = 1;
     canvas.height = this.n;
     this.updateCanvas(canvas);
     return canvas;
   },
-  updateCanvas: function (canvas) {
-    var ctx = canvas.getContext('2d', {
-      alpha: false
-    });
+  updateCanvas: function(canvas) {
+    var ctx = canvas.getContext("2d", { alpha: false });
     var imageData = ctx.getImageData(0, 0, 1, this.n);
     var data = imageData.data;
     var k = 0;
-    var step = 1.0 / this.n;
-
+    var step = 1 / this.n;
     for (let i = 1; i >= 0; i -= step) {
       for (let j = this.map.length - 1; j >= 0; j--) {
         if (i < this.map[j][0] && i >= this.map[j - 1][0]) {
           var min = this.map[j - 1][0];
           var max = this.map[j][0];
-          var minColor = new Color(this.map[j - 1][1]);
-          var maxColor = new Color(this.map[j][1]);
+          var minColor = new THREE.Color(this.map[j - 1][1]);
+          var maxColor = new THREE.Color(this.map[j][1]);
           var color = minColor.lerp(maxColor, (i - min) / (max - min));
           data[k * 4] = Math.round(color.r * 255);
           data[k * 4 + 1] = Math.round(color.g * 255);
@@ -104,16 +97,39 @@ Lut.prototype = {
         }
       }
     }
-
     ctx.putImageData(imageData, 0, 0);
     return canvas;
   }
 };
 var ColorMapKeywords = {
-  rainbow: [[0.0, 0x0000ff], [0.2, 0x00ffff], [0.5, 0x00ff00], [0.8, 0xffff00], [1.0, 0xff0000]],
-  cooltowarm: [[0.0, 0x3c4ec2], [0.2, 0x9bbcff], [0.5, 0xdcdcdc], [0.8, 0xf6a385], [1.0, 0xb40426]],
-  blackbody: [[0.0, 0x000000], [0.2, 0x780000], [0.5, 0xe63200], [0.8, 0xffff00], [1.0, 0xffffff]],
-  grayscale: [[0.0, 0x000000], [0.2, 0x404040], [0.5, 0x7f7f80], [0.8, 0xbfbfbf], [1.0, 0xffffff]]
+  rainbow: [
+    [0, 255],
+    [0.2, 65535],
+    [0.5, 65280],
+    [0.8, 16776960],
+    [1, 16711680]
+  ],
+  cooltowarm: [
+    [0, 3952322],
+    [0.2, 10206463],
+    [0.5, 14474460],
+    [0.8, 16163717],
+    [1, 11797542]
+  ],
+  blackbody: [
+    [0, 0],
+    [0.2, 7864320],
+    [0.5, 15086080],
+    [0.8, 16776960],
+    [1, 16777215]
+  ],
+  grayscale: [
+    [0, 0],
+    [0.2, 4210752],
+    [0.5, 8355712],
+    [0.8, 12566463],
+    [1, 16777215]
+  ]
 };
-
-export { ColorMapKeywords, Lut };
+exports.ColorMapKeywords = ColorMapKeywords;
+exports.Lut = Lut;

package/math/Lut.mjs

@@ -0,0 +1,135 @@
+import { Color } from "three";
+var Lut = function(colormap, numberofcolors) {
+  this.lut = [];
+  this.setColorMap(colormap, numberofcolors);
+  return this;
+};
+Lut.prototype = {
+  constructor: Lut,
+  lut: [],
+  map: [],
+  n: 256,
+  minV: 0,
+  maxV: 1,
+  set: function(value) {
+    if (value instanceof Lut) {
+      this.copy(value);
+    }
+    return this;
+  },
+  setMin: function(min) {
+    this.minV = min;
+    return this;
+  },
+  setMax: function(max) {
+    this.maxV = max;
+    return this;
+  },
+  setColorMap: function(colormap, numberofcolors) {
+    this.map = ColorMapKeywords[colormap] || ColorMapKeywords.rainbow;
+    this.n = numberofcolors || 32;
+    var step = 1 / this.n;
+    this.lut.length = 0;
+    for (let i = 0; i <= 1; i += step) {
+      for (let j = 0; j < this.map.length - 1; j++) {
+        if (i >= this.map[j][0] && i < this.map[j + 1][0]) {
+          var min = this.map[j][0];
+          var max = this.map[j + 1][0];
+          var minColor = new Color(this.map[j][1]);
+          var maxColor = new Color(this.map[j + 1][1]);
+          var color = minColor.lerp(maxColor, (i - min) / (max - min));
+          this.lut.push(color);
+        }
+      }
+    }
+    return this;
+  },
+  copy: function(lut) {
+    this.lut = lut.lut;
+    this.map = lut.map;
+    this.n = lut.n;
+    this.minV = lut.minV;
+    this.maxV = lut.maxV;
+    return this;
+  },
+  getColor: function(alpha) {
+    if (alpha <= this.minV) {
+      alpha = this.minV;
+    } else if (alpha >= this.maxV) {
+      alpha = this.maxV;
+    }
+    alpha = (alpha - this.minV) / (this.maxV - this.minV);
+    var colorPosition = Math.round(alpha * this.n);
+    colorPosition == this.n ? colorPosition -= 1 : colorPosition;
+    return this.lut[colorPosition];
+  },
+  addColorMap: function(colormapName, arrayOfColors) {
+    ColorMapKeywords[colormapName] = arrayOfColors;
+  },
+  createCanvas: function() {
+    var canvas = document.createElement("canvas");
+    canvas.width = 1;
+    canvas.height = this.n;
+    this.updateCanvas(canvas);
+    return canvas;
+  },
+  updateCanvas: function(canvas) {
+    var ctx = canvas.getContext("2d", { alpha: false });
+    var imageData = ctx.getImageData(0, 0, 1, this.n);
+    var data = imageData.data;
+    var k = 0;
+    var step = 1 / this.n;
+    for (let i = 1; i >= 0; i -= step) {
+      for (let j = this.map.length - 1; j >= 0; j--) {
+        if (i < this.map[j][0] && i >= this.map[j - 1][0]) {
+          var min = this.map[j - 1][0];
+          var max = this.map[j][0];
+          var minColor = new Color(this.map[j - 1][1]);
+          var maxColor = new Color(this.map[j][1]);
+          var color = minColor.lerp(maxColor, (i - min) / (max - min));
+          data[k * 4] = Math.round(color.r * 255);
+          data[k * 4 + 1] = Math.round(color.g * 255);
+          data[k * 4 + 2] = Math.round(color.b * 255);
+          data[k * 4 + 3] = 255;
+          k += 1;
+        }
+      }
+    }
+    ctx.putImageData(imageData, 0, 0);
+    return canvas;
+  }
+};
+var ColorMapKeywords = {
+  rainbow: [
+    [0, 255],
+    [0.2, 65535],
+    [0.5, 65280],
+    [0.8, 16776960],
+    [1, 16711680]
+  ],
+  cooltowarm: [
+    [0, 3952322],
+    [0.2, 10206463],
+    [0.5, 14474460],
+    [0.8, 16163717],
+    [1, 11797542]
+  ],
+  blackbody: [
+    [0, 0],
+    [0.2, 7864320],
+    [0.5, 15086080],
+    [0.8, 16776960],
+    [1, 16777215]
+  ],
+  grayscale: [
+    [0, 0],
+    [0.2, 4210752],
+    [0.5, 8355712],
+    [0.8, 12566463],
+    [1, 16777215]
+  ]
+};
+export {
+  ColorMapKeywords,
+  Lut
+};

package/math/MeshSurfaceSampler.js

@@ -1,99 +1,70 @@
-import { Triangle, Vector3 } from 'three';
-
-/**
- * Utility class for sampling weighted random points on the surface of a mesh.
- *
- * Building the sampler is a one-time O(n) operation. Once built, any number of
- * random samples may be selected in O(logn) time. Memory usage is O(n).
- *
- * References:
- * - http://www.joesfer.com/?p=84
- * - https://stackoverflow.com/a/4322940/1314762
- */
-
-var MeshSurfaceSampler = function () {
-  var _face = new Triangle();
-
-  var _color = new Vector3();
-
-  function MeshSurfaceSampler(mesh) {
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
+var MeshSurfaceSampler = function() {
+  var _face = new THREE.Triangle();
+  var _color = new THREE.Vector3();
+  function MeshSurfaceSampler2(mesh) {
     var geometry = mesh.geometry;
-
     if (!geometry.isBufferGeometry || geometry.attributes.position.itemSize !== 3) {
-      throw new Error('THREE.MeshSurfaceSampler: Requires BufferGeometry triangle mesh.');
+      throw new Error("THREE.MeshSurfaceSampler: Requires BufferGeometry triangle mesh.");
     }
-
     if (geometry.index) {
-      console.warn('THREE.MeshSurfaceSampler: Converting geometry to non-indexed BufferGeometry.');
+      console.warn("THREE.MeshSurfaceSampler: Converting geometry to non-indexed BufferGeometry.");
       geometry = geometry.toNonIndexed();
     }
-
     this.geometry = geometry;
     this.randomFunction = Math.random;
-    this.positionAttribute = this.geometry.getAttribute('position');
-    this.colorAttribute = this.geometry.getAttribute('color');
+    this.positionAttribute = this.geometry.getAttribute("position");
+    this.colorAttribute = this.geometry.getAttribute("color");
     this.weightAttribute = null;
     this.distribution = null;
   }
-
-  MeshSurfaceSampler.prototype = {
-    constructor: MeshSurfaceSampler,
-    setWeightAttribute: function (name) {
+  MeshSurfaceSampler2.prototype = {
+    constructor: MeshSurfaceSampler2,
+    setWeightAttribute: function(name) {
       this.weightAttribute = name ? this.geometry.getAttribute(name) : null;
       return this;
     },
-    build: function () {
+    build: function() {
       var positionAttribute = this.positionAttribute;
       var weightAttribute = this.weightAttribute;
-      var faceWeights = new Float32Array(positionAttribute.count / 3); // Accumulate weights for each mesh face.
-
+      var faceWeights = new Float32Array(positionAttribute.count / 3);
       for (let i = 0; i < positionAttribute.count; i += 3) {
         var faceWeight = 1;
-
         if (weightAttribute) {
           faceWeight = weightAttribute.getX(i) + weightAttribute.getX(i + 1) + weightAttribute.getX(i + 2);
         }
-
         _face.a.fromBufferAttribute(positionAttribute, i);
-
         _face.b.fromBufferAttribute(positionAttribute, i + 1);
-
         _face.c.fromBufferAttribute(positionAttribute, i + 2);
-
         faceWeight *= _face.getArea();
         faceWeights[i / 3] = faceWeight;
-      } // Store cumulative total face weights in an array, where weight index
-      // corresponds to face index.
-
-
+      }
       this.distribution = new Float32Array(positionAttribute.count / 3);
       var cumulativeTotal = 0;
-
       for (let i = 0; i < faceWeights.length; i++) {
         cumulativeTotal += faceWeights[i];
         this.distribution[i] = cumulativeTotal;
       }
-
       return this;
     },
-    setRandomGenerator: function (randomFunction) {
+    setRandomGenerator: function(randomFunction) {
       this.randomFunction = randomFunction;
       return this;
     },
-    sample: function (targetPosition, targetNormal, targetColor) {
+    sample: function(targetPosition, targetNormal, targetColor) {
       var cumulativeTotal = this.distribution[this.distribution.length - 1];
       var faceIndex = this.binarySearch(this.randomFunction() * cumulativeTotal);
       return this.sampleFace(faceIndex, targetPosition, targetNormal, targetColor);
     },
-    binarySearch: function (x) {
+    binarySearch: function(x) {
       var dist = this.distribution;
       var start = 0;
       var end = dist.length - 1;
       var index = -1;
-
       while (start <= end) {
         var mid = Math.ceil((start + end) / 2);
-
         if (mid === 0 || dist[mid - 1] <= x && dist[mid] > x) {
           index = mid;
           break;
@@ -103,48 +74,34 @@ var MeshSurfaceSampler = function () {
           start = mid + 1;
         }
       }
-
       return index;
     },
-    sampleFace: function (faceIndex, targetPosition, targetNormal, targetColor) {
+    sampleFace: function(faceIndex, targetPosition, targetNormal, targetColor) {
       var u = this.randomFunction();
       var v = this.randomFunction();
-
       if (u + v > 1) {
         u = 1 - u;
         v = 1 - v;
       }
-
       _face.a.fromBufferAttribute(this.positionAttribute, faceIndex * 3);
-
       _face.b.fromBufferAttribute(this.positionAttribute, faceIndex * 3 + 1);
-
       _face.c.fromBufferAttribute(this.positionAttribute, faceIndex * 3 + 2);
-
       targetPosition.set(0, 0, 0).addScaledVector(_face.a, u).addScaledVector(_face.b, v).addScaledVector(_face.c, 1 - (u + v));
-
-      if (targetNormal !== undefined) {
+      if (targetNormal !== void 0) {
         _face.getNormal(targetNormal);
       }
-
-      if (targetColor !== undefined && this.colorAttribute !== undefined) {
+      if (targetColor !== void 0 && this.colorAttribute !== void 0) {
         _face.a.fromBufferAttribute(this.colorAttribute, faceIndex * 3);
-
         _face.b.fromBufferAttribute(this.colorAttribute, faceIndex * 3 + 1);
-
         _face.c.fromBufferAttribute(this.colorAttribute, faceIndex * 3 + 2);
-
         _color.set(0, 0, 0).addScaledVector(_face.a, u).addScaledVector(_face.b, v).addScaledVector(_face.c, 1 - (u + v));
-
         targetColor.r = _color.x;
         targetColor.g = _color.y;
         targetColor.b = _color.z;
       }
-
       return this;
     }
   };
-  return MeshSurfaceSampler;
+  return MeshSurfaceSampler2;
 }();
-
-export { MeshSurfaceSampler };
+exports.MeshSurfaceSampler = MeshSurfaceSampler;

package/math/MeshSurfaceSampler.mjs

@@ -0,0 +1,107 @@
+import { Triangle, Vector3 } from "three";
+var MeshSurfaceSampler = function() {
+  var _face = new Triangle();
+  var _color = new Vector3();
+  function MeshSurfaceSampler2(mesh) {
+    var geometry = mesh.geometry;
+    if (!geometry.isBufferGeometry || geometry.attributes.position.itemSize !== 3) {
+      throw new Error("THREE.MeshSurfaceSampler: Requires BufferGeometry triangle mesh.");
+    }
+    if (geometry.index) {
+      console.warn("THREE.MeshSurfaceSampler: Converting geometry to non-indexed BufferGeometry.");
+      geometry = geometry.toNonIndexed();
+    }
+    this.geometry = geometry;
+    this.randomFunction = Math.random;
+    this.positionAttribute = this.geometry.getAttribute("position");
+    this.colorAttribute = this.geometry.getAttribute("color");
+    this.weightAttribute = null;
+    this.distribution = null;
+  }
+  MeshSurfaceSampler2.prototype = {
+    constructor: MeshSurfaceSampler2,
+    setWeightAttribute: function(name) {
+      this.weightAttribute = name ? this.geometry.getAttribute(name) : null;
+      return this;
+    },
+    build: function() {
+      var positionAttribute = this.positionAttribute;
+      var weightAttribute = this.weightAttribute;
+      var faceWeights = new Float32Array(positionAttribute.count / 3);
+      for (let i = 0; i < positionAttribute.count; i += 3) {
+        var faceWeight = 1;
+        if (weightAttribute) {
+          faceWeight = weightAttribute.getX(i) + weightAttribute.getX(i + 1) + weightAttribute.getX(i + 2);
+        }
+        _face.a.fromBufferAttribute(positionAttribute, i);
+        _face.b.fromBufferAttribute(positionAttribute, i + 1);
+        _face.c.fromBufferAttribute(positionAttribute, i + 2);
+        faceWeight *= _face.getArea();
+        faceWeights[i / 3] = faceWeight;
+      }
+      this.distribution = new Float32Array(positionAttribute.count / 3);
+      var cumulativeTotal = 0;
+      for (let i = 0; i < faceWeights.length; i++) {
+        cumulativeTotal += faceWeights[i];
+        this.distribution[i] = cumulativeTotal;
+      }
+      return this;
+    },
+    setRandomGenerator: function(randomFunction) {
+      this.randomFunction = randomFunction;
+      return this;
+    },
+    sample: function(targetPosition, targetNormal, targetColor) {
+      var cumulativeTotal = this.distribution[this.distribution.length - 1];
+      var faceIndex = this.binarySearch(this.randomFunction() * cumulativeTotal);
+      return this.sampleFace(faceIndex, targetPosition, targetNormal, targetColor);
+    },
+    binarySearch: function(x) {
+      var dist = this.distribution;
+      var start = 0;
+      var end = dist.length - 1;
+      var index = -1;
+      while (start <= end) {
+        var mid = Math.ceil((start + end) / 2);
+        if (mid === 0 || dist[mid - 1] <= x && dist[mid] > x) {
+          index = mid;
+          break;
+        } else if (x < dist[mid]) {
+          end = mid - 1;
+        } else {
+          start = mid + 1;
+        }
+      }
+      return index;
+    },
+    sampleFace: function(faceIndex, targetPosition, targetNormal, targetColor) {
+      var u = this.randomFunction();
+      var v = this.randomFunction();
+      if (u + v > 1) {
+        u = 1 - u;
+        v = 1 - v;
+      }
+      _face.a.fromBufferAttribute(this.positionAttribute, faceIndex * 3);
+      _face.b.fromBufferAttribute(this.positionAttribute, faceIndex * 3 + 1);
+      _face.c.fromBufferAttribute(this.positionAttribute, faceIndex * 3 + 2);
+      targetPosition.set(0, 0, 0).addScaledVector(_face.a, u).addScaledVector(_face.b, v).addScaledVector(_face.c, 1 - (u + v));
+      if (targetNormal !== void 0) {
+        _face.getNormal(targetNormal);
+      }
+      if (targetColor !== void 0 && this.colorAttribute !== void 0) {
+        _face.a.fromBufferAttribute(this.colorAttribute, faceIndex * 3);
+        _face.b.fromBufferAttribute(this.colorAttribute, faceIndex * 3 + 1);
+        _face.c.fromBufferAttribute(this.colorAttribute, faceIndex * 3 + 2);
+        _color.set(0, 0, 0).addScaledVector(_face.a, u).addScaledVector(_face.b, v).addScaledVector(_face.c, 1 - (u + v));
+        targetColor.r = _color.x;
+        targetColor.g = _color.y;
+        targetColor.b = _color.z;
+      }
+      return this;
+    }
+  };
+  return MeshSurfaceSampler2;
+}();
+export {
+  MeshSurfaceSampler
+};