@kitware/vtk.js 28.10.2 → 28.11.0

package/Filters/General/OutlineFilter.js

@@ -1,68 +1,86 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro; // prettier-ignore
-
-var BOUNDS_MAP = [0, 2, 4, // pt 0
-1, 2, 4, // pt 1
-0, 3, 4, // pt 2
-1, 3, 4, // pt 3
-0, 2, 5, // pt 4
-1, 2, 5, // pt 5
-0, 3, 5, // pt 6
+const {
+  vtkErrorMacro
+} = macro;
+
+// prettier-ignore
+const BOUNDS_MAP = [0, 2, 4,
+// pt 0
+1, 2, 4,
+// pt 1
+0, 3, 4,
+// pt 2
+1, 3, 4,
+// pt 3
+0, 2, 5,
+// pt 4
+1, 2, 5,
+// pt 5
+0, 3, 5,
+// pt 6
 1, 3, 5 // pt 7
-]; // prettier-ignore
+];
+
+// prettier-ignore
+const LINE_ARRAY = [2, 0, 1, 2, 2, 3, 2, 4, 5, 2, 6, 7, 2, 0, 2, 2, 1, 3, 2, 4, 6, 2, 5, 7, 2, 0, 4, 2, 1, 5, 2, 2, 6, 2, 3, 7];
 
-var LINE_ARRAY = [2, 0, 1, 2, 2, 3, 2, 4, 5, 2, 6, 7, 2, 0, 2, 2, 1, 3, 2, 4, 6, 2, 5, 7, 2, 0, 4, 2, 1, 5, 2, 2, 6, 2, 3, 7]; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkOutlineFilter methods
 // ----------------------------------------------------------------------------
 
 function vtkOutlineFilter(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkOutlineFilter');
-
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     // implement requestData
-    var input = inData[0];
-
+    const input = inData[0];
     if (!input) {
       vtkErrorMacro('Invalid or missing input');
       return;
     }
-
-    var bounds = input.getBounds();
-    var output = vtkPolyData.newInstance();
-    output.getPoints().setData(Float32Array.from(BOUNDS_MAP.map(function (idx) {
-      return bounds[idx];
-    })), 3);
+    const bounds = input.getBounds();
+    const output = vtkPolyData.newInstance();
+    output.getPoints().setData(Float32Array.from(BOUNDS_MAP.map(idx => bounds[idx])), 3);
     output.getLines().setData(Uint16Array.from(LINE_ARRAY));
     outData[0] = output;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
+const DEFAULT_VALUES = {};
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Make this a VTK object
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
-  macro.obj(publicAPI, model); // Also make it an algorithm with one input and one output
+  // Make this a VTK object
+  macro.obj(publicAPI, model);
 
-  macro.algo(publicAPI, model, 1, 1); // Object specific methods
+  // Also make it an algorithm with one input and one output
+  macro.algo(publicAPI, model, 1, 1);
 
+  // Object specific methods
   vtkOutlineFilter(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkOutlineFilter');
 
-var newInstance = macro.newInstance(extend, 'vtkOutlineFilter'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkOutlineFilter$1 = {
-  newInstance: newInstance,
-  extend: extend,
-  BOUNDS_MAP: BOUNDS_MAP,
-  LINE_ARRAY: LINE_ARRAY
+  newInstance,
+  extend,
+  BOUNDS_MAP,
+  LINE_ARRAY
 };
 
 export { BOUNDS_MAP, LINE_ARRAY, vtkOutlineFilter$1 as default, extend, newInstance };

package/Filters/General/PaintFilter/PaintFilter.worker.js

@@ -1,235 +1,198 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import registerWebworker from 'webworker-promise/lib/register';
 import { SlicingMode } from '../../../Rendering/Core/ImageMapper/Constants.js';
 import { vec3 } from 'gl-matrix';
 
-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(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(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];
     vec3.subtract(v1, point1, point0);
     vec3.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]));
     vec3.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]));
     vec3.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(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];
         vec3.scaleAndAdd(point, point, step1, u);
         vec3.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;
 });