@kitware/vtk.js 28.10.2 → 28.11.1

package/_virtual/rollup-plugin-worker-loader__module_Sources/Filters/General/PaintFilter/PaintFilter.worker.js

@@ -4,83 +4,6 @@ var WorkerFactory = createInlineWorkerFactory(/* rollup-plugin-web-worker-loader
 (function () {
   '__worker_loader_strict__';
 
-  function _arrayLikeToArray(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-
-    for (var i = 0, arr2 = new Array(len); i < len; i++) {
-      arr2[i] = arr[i];
-    }
-
-    return arr2;
-  }
-
-  function _arrayWithoutHoles(arr) {
-    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-  }
-
-  function _iterableToArray(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-  }
-
-  function _unsupportedIterableToArray(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(o);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-  }
-
-  function _nonIterableSpread() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-  }
-
-  function _toConsumableArray$1(arr) {
-    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-  }
-
-  function _arrayWithHoles(arr) {
-    if (Array.isArray(arr)) return arr;
-  }
-
-  function _iterableToArrayLimit(arr, i) {
-    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
-
-    if (_i == null) return;
-    var _arr = [];
-    var _n = true;
-    var _d = false;
-
-    var _s, _e;
-
-    try {
-      for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
-        _arr.push(_s.value);
-
-        if (i && _arr.length === i) break;
-      }
-    } catch (err) {
-      _d = true;
-      _e = err;
-    } finally {
-      try {
-        if (!_n && _i["return"] != null) _i["return"]();
-      } finally {
-        if (_d) throw _e;
-      }
-    }
-
-    return _arr;
-  }
-
-  function _nonIterableRest() {
-    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-  }
-
-  function _slicedToArray(arr, i) {
-    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
-  }
-
   var register = {exports: {}};
 
   var _createClass$1 = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
@@ -325,7 +248,7 @@ var WorkerFactory = createInlineWorkerFactory(/* rollup-plugin-web-worker-loader
 
   var registerWebworker = register.exports;
 
-  var SlicingMode = {
+  const SlicingMode = {
     NONE: -1,
     I: 0,
     J: 1,
@@ -465,232 +388,197 @@ var WorkerFactory = createInlineWorkerFactory(/* rollup-plugin-web-worker-loader
     };
   })();
 
-  var globals = {
+  const globals = {
     // single-component labelmap
     buffer: null,
     dimensions: [0, 0, 0],
     prevPoint: null,
     slicingMode: null // 2D or 3D painting
+  };
 
-  }; // --------------------------------------------------------------------------
+  // --------------------------------------------------------------------------
 
   function handlePaintRectangle(_ref) {
-    var point1 = _ref.point1,
-        point2 = _ref.point2;
-
-    var _point = _slicedToArray(point1, 3),
-        x1 = _point[0],
-        y1 = _point[1],
-        z1 = _point[2];
-
-    var _point2 = _slicedToArray(point2, 3),
-        x2 = _point2[0],
-        y2 = _point2[1],
-        z2 = _point2[2];
-
-    var xstart = Math.max(Math.min(x1, x2), 0);
-    var xend = Math.min(Math.max(x1, x2), globals.dimensions[0] - 1);
-
+    let {
+      point1,
+      point2
+    } = _ref;
+    const [x1, y1, z1] = point1;
+    const [x2, y2, z2] = point2;
+    const xstart = Math.max(Math.min(x1, x2), 0);
+    const xend = Math.min(Math.max(x1, x2), globals.dimensions[0] - 1);
     if (xstart <= xend) {
-      var ystart = Math.max(Math.min(y1, y2), 0);
-      var yend = Math.min(Math.max(y1, y2), globals.dimensions[1] - 1);
-      var zstart = Math.max(Math.min(z1, z2), 0);
-      var zend = Math.min(Math.max(z1, z2), globals.dimensions[2] - 1);
-      var jStride = globals.dimensions[0];
-      var kStride = globals.dimensions[0] * globals.dimensions[1];
-
-      for (var k = zstart; k <= zend; k++) {
-        for (var j = ystart; j <= yend; j++) {
-          var index = j * jStride + k * kStride;
+      const ystart = Math.max(Math.min(y1, y2), 0);
+      const yend = Math.min(Math.max(y1, y2), globals.dimensions[1] - 1);
+      const zstart = Math.max(Math.min(z1, z2), 0);
+      const zend = Math.min(Math.max(z1, z2), globals.dimensions[2] - 1);
+      const jStride = globals.dimensions[0];
+      const kStride = globals.dimensions[0] * globals.dimensions[1];
+      for (let k = zstart; k <= zend; k++) {
+        for (let j = ystart; j <= yend; j++) {
+          const index = j * jStride + k * kStride;
           globals.buffer.fill(1, index + xstart, index + xend + 1);
         }
       }
     }
-  } // --------------------------------------------------------------------------
-  // center and scale3 are in IJK coordinates
-
+  }
 
+  // --------------------------------------------------------------------------
+  // center and scale3 are in IJK coordinates
   function handlePaintEllipse(_ref2) {
-    var center = _ref2.center,
-        scale3 = _ref2.scale3;
-
-    var radius3 = _toConsumableArray$1(scale3);
-
-    var indexCenter = center.map(function (val) {
-      return Math.round(val);
-    });
-    var sliceAxis = -1;
-
+    let {
+      center,
+      scale3
+    } = _ref2;
+    const radius3 = [...scale3];
+    const indexCenter = center.map(val => Math.round(val));
+    let sliceAxis = -1;
     if (globals.slicingMode != null && globals.slicingMode !== SlicingMode.NONE) {
       sliceAxis = globals.slicingMode % 3;
     }
-
-    var yStride = globals.dimensions[0];
-    var zStride = globals.dimensions[0] * globals.dimensions[1];
-
-    var _indexCenter = _slicedToArray(indexCenter, 3),
-        xmin = _indexCenter[0],
-        ymin = _indexCenter[1],
-        zmin = _indexCenter[2];
-
-    var _indexCenter2 = _slicedToArray(indexCenter, 3),
-        xmax = _indexCenter2[0],
-        ymax = _indexCenter2[1],
-        zmax = _indexCenter2[2];
-
+    const yStride = globals.dimensions[0];
+    const zStride = globals.dimensions[0] * globals.dimensions[1];
+    let [xmin, ymin, zmin] = indexCenter;
+    let [xmax, ymax, zmax] = indexCenter;
     if (sliceAxis !== 2) {
       zmin = Math.round(Math.max(indexCenter[2] - radius3[2], 0));
       zmax = Math.round(Math.min(indexCenter[2] + radius3[2], globals.dimensions[2] - 1));
     }
-
-    for (var z = zmin; z <= zmax; z++) {
-      var dz = 0;
-
+    for (let z = zmin; z <= zmax; z++) {
+      let dz = 0;
       if (sliceAxis !== 2) {
         dz = (indexCenter[2] - z) / radius3[2];
       }
-
-      var dzSquared = dz * dz;
-
+      const dzSquared = dz * dz;
       if (dzSquared <= 1) {
-        var ay = radius3[1] * Math.sqrt(1 - dzSquared);
-
+        const ay = radius3[1] * Math.sqrt(1 - dzSquared);
         if (sliceAxis !== 1) {
           ymin = Math.round(Math.max(indexCenter[1] - ay, 0));
           ymax = Math.round(Math.min(indexCenter[1] + ay, globals.dimensions[1] - 1));
         }
-
-        for (var y = ymin; y <= ymax; y++) {
-          var dy = 0;
-
+        for (let y = ymin; y <= ymax; y++) {
+          let dy = 0;
           if (sliceAxis !== 1) {
             dy = (indexCenter[1] - y) / radius3[1];
           }
-
-          var dySquared = dy * dy;
-
+          const dySquared = dy * dy;
           if (dySquared + dzSquared <= 1) {
             if (sliceAxis !== 0) {
-              var ax = radius3[0] * Math.sqrt(1 - dySquared - dzSquared);
+              const ax = radius3[0] * Math.sqrt(1 - dySquared - dzSquared);
               xmin = Math.round(Math.max(indexCenter[0] - ax, 0));
               xmax = Math.round(Math.min(indexCenter[0] + ax, globals.dimensions[0] - 1));
             }
-
             if (xmin <= xmax) {
-              var index = y * yStride + z * zStride;
+              const index = y * yStride + z * zStride;
               globals.buffer.fill(1, index + xmin, index + xmax + 1);
             }
           }
         }
       }
     }
-  } // --------------------------------------------------------------------------
+  }
 
+  // --------------------------------------------------------------------------
 
   function handlePaint(_ref3) {
-    var point = _ref3.point,
-        radius = _ref3.radius;
-
+    let {
+      point,
+      radius
+    } = _ref3;
     if (!globals.prevPoint) {
       globals.prevPoint = point;
-    } // DDA params
-
-
-    var delta = [point[0] - globals.prevPoint[0], point[1] - globals.prevPoint[1], point[2] - globals.prevPoint[2]];
-    var inc = [1, 1, 1];
+    }
 
-    for (var i = 0; i < 3; i++) {
+    // DDA params
+    const delta = [point[0] - globals.prevPoint[0], point[1] - globals.prevPoint[1], point[2] - globals.prevPoint[2]];
+    const inc = [1, 1, 1];
+    for (let i = 0; i < 3; i++) {
       if (delta[i] < 0) {
         delta[i] = -delta[i];
         inc[i] = -1;
       }
     }
+    const step = Math.max(...delta);
 
-    var step = Math.max.apply(Math, delta); // DDA
-
-    var thresh = [step, step, step];
-
-    var pt = _toConsumableArray$1(globals.prevPoint);
-
-    for (var s = 0; s <= step; s++) {
+    // DDA
+    const thresh = [step, step, step];
+    const pt = [...globals.prevPoint];
+    for (let s = 0; s <= step; s++) {
       handlePaintEllipse({
         center: pt,
         scale3: radius
       });
-
-      for (var ii = 0; ii < 3; ii++) {
+      for (let ii = 0; ii < 3; ii++) {
         thresh[ii] -= delta[ii];
-
         if (thresh[ii] <= 0) {
           thresh[ii] += step;
           pt[ii] += inc[ii];
         }
       }
     }
-
     globals.prevPoint = point;
-  } // --------------------------------------------------------------------------
+  }
 
+  // --------------------------------------------------------------------------
 
   function handlePaintTriangles(_ref4) {
-    var triangleList = _ref4.triangleList;
+    let {
+      triangleList
+    } = _ref4;
     // debugger;
-    var triangleCount = Math.floor(triangleList.length / 9);
-
-    for (var i = 0; i < triangleCount; i++) {
-      var point0 = triangleList.subarray(9 * i + 0, 9 * i + 3);
-      var point1 = triangleList.subarray(9 * i + 3, 9 * i + 6);
-      var point2 = triangleList.subarray(9 * i + 6, 9 * i + 9);
-      var v1 = [0, 0, 0];
-      var v2 = [0, 0, 0];
+
+    const triangleCount = Math.floor(triangleList.length / 9);
+    for (let i = 0; i < triangleCount; i++) {
+      const point0 = triangleList.subarray(9 * i + 0, 9 * i + 3);
+      const point1 = triangleList.subarray(9 * i + 3, 9 * i + 6);
+      const point2 = triangleList.subarray(9 * i + 6, 9 * i + 9);
+      const v1 = [0, 0, 0];
+      const v2 = [0, 0, 0];
       subtract(v1, point1, point0);
       subtract(v2, point2, point0);
-      var step1 = [0, 0, 0];
-      var numStep1 = 2 * Math.max(Math.abs(v1[0]), Math.abs(v1[1]), Math.abs(v1[2]));
+      const step1 = [0, 0, 0];
+      const numStep1 = 2 * Math.max(Math.abs(v1[0]), Math.abs(v1[1]), Math.abs(v1[2]));
       scale(step1, v1, 1 / numStep1);
-      var step2 = [0, 0, 0];
-      var numStep2 = 2 * Math.max(Math.abs(v2[0]), Math.abs(v2[1]), Math.abs(v2[2]));
+      const step2 = [0, 0, 0];
+      const numStep2 = 2 * Math.max(Math.abs(v2[0]), Math.abs(v2[1]), Math.abs(v2[2]));
       scale(step2, v2, 1 / numStep2);
-      var jStride = globals.dimensions[0];
-      var kStride = globals.dimensions[0] * globals.dimensions[1];
-
-      for (var u = 0; u <= numStep1 + 1; u++) {
-        var maxV = numStep2 - u * (numStep2 / numStep1);
-
-        for (var v = 0; v <= maxV + 1; v++) {
-          var point = _toConsumableArray$1(point0);
-
+      const jStride = globals.dimensions[0];
+      const kStride = globals.dimensions[0] * globals.dimensions[1];
+      for (let u = 0; u <= numStep1 + 1; u++) {
+        const maxV = numStep2 - u * (numStep2 / numStep1);
+        for (let v = 0; v <= maxV + 1; v++) {
+          const point = [...point0];
           scaleAndAdd(point, point, step1, u);
           scaleAndAdd(point, point, step2, v);
           point[0] = Math.round(point[0]);
           point[1] = Math.round(point[1]);
           point[2] = Math.round(point[2]);
-
           if (point[0] >= 0 && point[0] < globals.dimensions[0] && point[1] >= 0 && point[1] < globals.dimensions[1] && point[2] >= 0 && point[2] < globals.dimensions[2]) {
             globals.buffer[point[0] + jStride * point[1] + kStride * point[2]] = 1;
           }
         }
       }
     }
-  } // --------------------------------------------------------------------------
-
+  }
 
-  registerWebworker().operation('start', function (_ref5) {
-    var bufferType = _ref5.bufferType,
-        dimensions = _ref5.dimensions,
-        slicingMode = _ref5.slicingMode;
+  // --------------------------------------------------------------------------
 
+  registerWebworker().operation('start', _ref5 => {
+    let {
+      bufferType,
+      dimensions,
+      slicingMode
+    } = _ref5;
     if (!globals.buffer) {
-      var bufferSize = dimensions[0] * dimensions[1] * dimensions[2];
+      const bufferSize = dimensions[0] * dimensions[1] * dimensions[2];
       /* eslint-disable-next-line */
-
       globals.buffer = new self[bufferType](bufferSize);
       globals.dimensions = dimensions;
       globals.prevPoint = null;
       globals.slicingMode = slicingMode;
     }
-  }).operation('paint', handlePaint).operation('paintRectangle', handlePaintRectangle).operation('paintEllipse', handlePaintEllipse).operation('paintTriangles', handlePaintTriangles).operation('end', function () {
-    var response = new registerWebworker.TransferableResponse(globals.buffer.buffer, [globals.buffer.buffer]);
+  }).operation('paint', handlePaint).operation('paintRectangle', handlePaintRectangle).operation('paintEllipse', handlePaintEllipse).operation('paintTriangles', handlePaintTriangles).operation('end', () => {
+    const response = new registerWebworker.TransferableResponse(globals.buffer.buffer, [globals.buffer.buffer]);
     globals.buffer = null;
     return response;
   });

package/_virtual/rollup-plugin-worker-loader__module_Sources/Interaction/Widgets/PiecewiseGaussianWidget/ComputeHistogram.worker.js

@@ -250,7 +250,6 @@ var WorkerFactory = createInlineWorkerFactory(/* rollup-plugin-web-worker-loader
 
   /* eslint-disable */
   // prettier-ignore
-
   registerWebworker(function (message, emit) {
     var array = message.array;
     var min = message.min;
@@ -262,12 +261,10 @@ var WorkerFactory = createInlineWorkerFactory(/* rollup-plugin-web-worker-loader
     var histogram = new Float32Array(numberOfBins);
     histogram.fill(0);
     var len = array.length;
-
     for (var i = offset; i < len; i += step) {
       var idx = Math.floor((numberOfBins - 1) * (Number(array[i]) - min) / delta);
       histogram[idx] += 1;
     }
-
     return Promise.resolve(new registerWebworker.TransferableResponse(histogram, [histogram.buffer]));
   });
 

package/favicon.js

@@ -1,11 +1,10 @@
-var head = document.querySelector('head');
-
+const head = document.querySelector('head');
 if (head) {
-  [16, 32, 96, 160, 196].forEach(function (resolution) {
-    var link = document.createElement('link');
+  [16, 32, 96, 160, 196].forEach(resolution => {
+    const link = document.createElement('link');
     link.setAttribute('rel', 'icon');
-    link.setAttribute('href', "https://kitware.github.io/vtk-js/icon/favicon-".concat(resolution, "x").concat(resolution, ".png"));
-    link.setAttribute('sizes', "".concat(resolution, "x").concat(resolution));
+    link.setAttribute('href', `https://kitware.github.io/vtk-js/icon/favicon-${resolution}x${resolution}.png`);
+    link.setAttribute('sizes', `${resolution}x${resolution}`);
     link.setAttribute('type', 'image/png');
     head.appendChild(link);
   });

package/index.d.ts

@@ -218,12 +218,14 @@
 /// <reference path="./Widgets/Core/WidgetState.d.ts" />
 /// <reference path="./Widgets/Manipulators/AbstractManipulator.d.ts" />
 /// <reference path="./Widgets/Manipulators/LineManipulator.d.ts" />
+/// <reference path="./Widgets/Manipulators/PickerManipulator.d.ts" />
 /// <reference path="./Widgets/Manipulators/PlaneManipulator.d.ts" />
 /// <reference path="./Widgets/Manipulators/TrackballManipulator.d.ts" />
 /// <reference path="./Widgets/Representations/WidgetRepresentation.d.ts" />
 /// <reference path="./Widgets/Widgets3D/InteractiveOrientationWidget.d.ts" />
 /// <reference path="./Widgets/Widgets3D/ResliceCursorWidget.d.ts" />
+/// <reference path="./Widgets/Widgets3D/SeedWidget.d.ts" />
 /// <reference path="./Widgets/Widgets3D/SphereWidget.d.ts" />
-/// <reference path="./macros.d.ts" />
 /// <reference path="./vtk.d.ts" />
-/// <reference path="./Common/Core/Math.d.ts" />
+/// <reference path="./Common/Core/Math.d.ts" />
+/// <reference path="./macros.d.ts" />

package/index.js

@@ -6,7 +6,7 @@ import IO from './IO/index.js';
 import Rendering from './Rendering/index.js';
 import VTKProxy from './Proxy/index.js';
 import Widgets from './Widgets/index.js';
-import macro from './macros.js';
+import { m as macro } from './macros2.js';
 import vtk from './vtk.js';
 
 vtk.Common = Common;
@@ -18,7 +18,8 @@ vtk.Proxy = VTKProxy;
 vtk.Rendering = Rendering;
 vtk.Widgets = Widgets;
 vtk.mtime = macro.getCurrentGlobalMTime;
-vtk.macro = macro; // Expose vtk to global scope without exporting it so nested namespace
-// do not pollute the global one.
+vtk.macro = macro;
 
+// Expose vtk to global scope without exporting it so nested namespace
+// do not pollute the global one.
 window.vtk = vtk;