@kitware/vtk.js 28.10.2 → 28.11.0

package/Filters/General/PaintFilter.js

@@ -1,149 +1,148 @@
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import { vec3 } from 'gl-matrix';
 import WebworkerPromise from 'webworker-promise';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkImageData from '../../Common/DataModel/ImageData.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkPolygon from '../../Common/DataModel/Polygon.js';
 import { W as WorkerFactory } from '../../_virtual/rollup-plugin-worker-loader__module_Sources/Filters/General/PaintFilter/PaintFilter.worker.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+const {
+  vtkErrorMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
 // vtkPaintFilter methods
 // ----------------------------------------------------------------------------
 
 function vtkPaintFilter(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkPaintFilter');
-  var worker = null;
-  var workerPromise = null;
-  var history = {}; // --------------------------------------------------------------------------
+  let worker = null;
+  let workerPromise = null;
+  const history = {};
+
+  // --------------------------------------------------------------------------
 
   function resetHistory() {
     history.index = -1;
     history.snapshots = [];
     history.labels = [];
   }
-
   function pushToHistory(snapshot, label) {
     // Clear any "redo" info
-    var spliceIndex = history.index + 1;
-    var spliceLength = history.snapshots.length - history.index;
+    const spliceIndex = history.index + 1;
+    const spliceLength = history.snapshots.length - history.index;
     history.snapshots.splice(spliceIndex, spliceLength);
-    history.labels.splice(spliceIndex, spliceLength); // Push new snapshot
+    history.labels.splice(spliceIndex, spliceLength);
 
+    // Push new snapshot
     history.snapshots.push(snapshot);
     history.labels.push(label);
     history.index++;
-  } // --------------------------------------------------------------------------
+  }
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.startStroke = function () {
+  publicAPI.startStroke = () => {
     if (model.labelMap) {
       if (!workerPromise) {
         worker = new WorkerFactory();
         workerPromise = new WebworkerPromise(worker);
       }
-
       workerPromise.exec('start', {
         bufferType: 'Uint8Array',
         dimensions: model.labelMap.getDimensions(),
         slicingMode: model.slicingMode
       });
     }
-  }; // --------------------------------------------------------------------------
-
+  };
 
-  publicAPI.endStroke = function () {
-    var endStrokePromise;
+  // --------------------------------------------------------------------------
 
+  publicAPI.endStroke = () => {
+    let endStrokePromise;
     if (workerPromise) {
       endStrokePromise = workerPromise.exec('end');
-      endStrokePromise.then(function (strokeBuffer) {
+      endStrokePromise.then(strokeBuffer => {
         publicAPI.applyBinaryMask(strokeBuffer);
         worker.terminate();
         worker = null;
         workerPromise = null;
       });
     }
-
     return endStrokePromise;
   };
-
-  publicAPI.applyBinaryMask = function (maskBuffer) {
-    var scalars = model.labelMap.getPointData().getScalars();
-    var data = scalars.getData();
-    var maskLabelMap = new Uint8Array(maskBuffer);
-    var diffCount = 0;
-
-    for (var i = 0; i < maskLabelMap.length; i++) {
+  publicAPI.applyBinaryMask = maskBuffer => {
+    const scalars = model.labelMap.getPointData().getScalars();
+    const data = scalars.getData();
+    const maskLabelMap = new Uint8Array(maskBuffer);
+    let diffCount = 0;
+    for (let i = 0; i < maskLabelMap.length; i++) {
       // maskLabelMap is a binary mask
       diffCount += maskLabelMap[i];
-    } // Format: [ [index, oldLabel], ...]
+    }
+
+    // Format: [ [index, oldLabel], ...]
     // I could use an ArrayBuffer, which would place limits
     // on the values of index/old, but will be more efficient.
-
-
-    var snapshot = new Array(diffCount);
-    var label = model.label;
-    var diffIdx = 0;
-
+    const snapshot = new Array(diffCount);
+    const label = model.label;
+    let diffIdx = 0;
     if (model.voxelFunc) {
-      var bgScalars = model.backgroundImage.getPointData().getScalars();
-      var voxel = [];
-
-      for (var _i = 0; _i < maskLabelMap.length; _i++) {
-        if (maskLabelMap[_i]) {
-          bgScalars.getTuple(_i, voxel); // might not fill up snapshot
-
-          if (model.voxelFunc(voxel, _i, label)) {
-            snapshot[diffIdx++] = [_i, data[_i]];
-            data[_i] = label;
+      const bgScalars = model.backgroundImage.getPointData().getScalars();
+      const voxel = [];
+      for (let i = 0; i < maskLabelMap.length; i++) {
+        if (maskLabelMap[i]) {
+          bgScalars.getTuple(i, voxel);
+          // might not fill up snapshot
+          if (model.voxelFunc(voxel, i, label)) {
+            snapshot[diffIdx++] = [i, data[i]];
+            data[i] = label;
           }
         }
       }
     } else {
-      for (var _i2 = 0; _i2 < maskLabelMap.length; _i2++) {
-        if (maskLabelMap[_i2]) {
-          if (data[_i2] !== label) {
-            snapshot[diffIdx++] = [_i2, data[_i2]];
-            data[_i2] = label;
+      for (let i = 0; i < maskLabelMap.length; i++) {
+        if (maskLabelMap[i]) {
+          if (data[i] !== label) {
+            snapshot[diffIdx++] = [i, data[i]];
+            data[i] = label;
           }
         }
       }
     }
-
     pushToHistory(snapshot, label);
     scalars.setData(data);
     scalars.modified();
     model.labelMap.modified();
     publicAPI.modified();
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.addPoint = function (point) {
+  publicAPI.addPoint = point => {
     if (workerPromise) {
-      var worldPt = [point[0], point[1], point[2]];
-      var indexPt = [0, 0, 0];
+      const worldPt = [point[0], point[1], point[2]];
+      const indexPt = [0, 0, 0];
       vec3.transformMat4(indexPt, worldPt, model.maskWorldToIndex);
       indexPt[0] = Math.round(indexPt[0]);
       indexPt[1] = Math.round(indexPt[1]);
       indexPt[2] = Math.round(indexPt[2]);
-      var spacing = model.labelMap.getSpacing();
-      var radius = spacing.map(function (s) {
-        return model.radius / s;
-      });
+      const spacing = model.labelMap.getSpacing();
+      const radius = spacing.map(s => model.radius / s);
       workerPromise.exec('paint', {
         point: indexPt,
-        radius: radius
+        radius
       });
     }
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.paintRectangle = function (point1, point2) {
+  publicAPI.paintRectangle = (point1, point2) => {
     if (workerPromise) {
-      var index1 = [0, 0, 0];
-      var index2 = [0, 0, 0];
+      const index1 = [0, 0, 0];
+      const index2 = [0, 0, 0];
       vec3.transformMat4(index1, point1, model.maskWorldToIndex);
       vec3.transformMat4(index2, point2, model.maskWorldToIndex);
       index1[0] = Math.round(index1[0]);
@@ -157,208 +156,188 @@ function vtkPaintFilter(publicAPI, model) {
         point2: index2
       });
     }
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.paintEllipse = function (center, scale3) {
+  publicAPI.paintEllipse = (center, scale3) => {
     if (workerPromise) {
-      var realCenter = [0, 0, 0];
-      var origin = [0, 0, 0];
-      var realScale3 = [0, 0, 0];
+      const realCenter = [0, 0, 0];
+      const origin = [0, 0, 0];
+      let realScale3 = [0, 0, 0];
       vec3.transformMat4(realCenter, center, model.maskWorldToIndex);
       vec3.transformMat4(origin, origin, model.maskWorldToIndex);
       vec3.transformMat4(realScale3, scale3, model.maskWorldToIndex);
       vec3.subtract(realScale3, realScale3, origin);
-      realScale3 = realScale3.map(function (s) {
-        return s === 0 ? 0.25 : Math.abs(s);
-      });
+      realScale3 = realScale3.map(s => s === 0 ? 0.25 : Math.abs(s));
       workerPromise.exec('paintEllipse', {
         center: realCenter,
         scale3: realScale3
       });
     }
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.canUndo = function () {
-    return history.index > -1;
-  }; // --------------------------------------------------------------------------
+  publicAPI.canUndo = () => history.index > -1;
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.paintPolygon = function (pointList) {
+  publicAPI.paintPolygon = pointList => {
     if (workerPromise && pointList.length > 0) {
-      var polygon = vtkPolygon.newInstance();
-      var poly = [];
-
-      for (var i = 0; i < pointList.length / 3; i++) {
+      const polygon = vtkPolygon.newInstance();
+      const poly = [];
+      for (let i = 0; i < pointList.length / 3; i++) {
         poly.push([pointList[3 * i + 0], pointList[3 * i + 1], pointList[3 * i + 2]]);
       }
-
       polygon.setPoints(poly);
-
       if (!polygon.triangulate()) {
         console.log('triangulation failed!');
       }
-
-      var points = polygon.getPointArray();
-      var triangleList = new Float32Array(points.length);
-      var numPoints = Math.floor(triangleList.length / 3);
-
-      for (var _i3 = 0; _i3 < numPoints; _i3++) {
-        var point = points.slice(3 * _i3, 3 * _i3 + 3);
-        var voxel = triangleList.subarray(3 * _i3, 3 * _i3 + 3);
+      const points = polygon.getPointArray();
+      const triangleList = new Float32Array(points.length);
+      const numPoints = Math.floor(triangleList.length / 3);
+      for (let i = 0; i < numPoints; i++) {
+        const point = points.slice(3 * i, 3 * i + 3);
+        const voxel = triangleList.subarray(3 * i, 3 * i + 3);
         vec3.transformMat4(voxel, point, model.maskWorldToIndex);
       }
-
       workerPromise.exec('paintTriangles', {
-        triangleList: triangleList
+        triangleList
       });
     }
-  }; // --------------------------------------------------------------------------
-
+  };
 
-  publicAPI.applyLabelMap = function (labelMap) {
-    var currentMapData = model.labelMap.getPointData().getScalars().getData();
-    var newMapData = labelMap.getPointData().getScalars().getData(); // Compute snapshot
+  // --------------------------------------------------------------------------
 
-    var snapshot = [];
+  publicAPI.applyLabelMap = labelMap => {
+    const currentMapData = model.labelMap.getPointData().getScalars().getData();
+    const newMapData = labelMap.getPointData().getScalars().getData();
 
-    for (var i = 0; i < newMapData.length; ++i) {
+    // Compute snapshot
+    const snapshot = [];
+    for (let i = 0; i < newMapData.length; ++i) {
       if (currentMapData[i] !== newMapData[i]) {
         snapshot.push([i, currentMapData[i]]);
       }
     }
-
     pushToHistory(snapshot, model.label);
     model.labelMap = labelMap;
     publicAPI.modified();
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.undo = function () {
+  publicAPI.undo = () => {
     if (history.index > -1) {
-      var scalars = model.labelMap.getPointData().getScalars();
-      var data = scalars.getData();
-      var snapshot = history.snapshots[history.index];
-
-      for (var i = 0; i < snapshot.length; i++) {
+      const scalars = model.labelMap.getPointData().getScalars();
+      const data = scalars.getData();
+      const snapshot = history.snapshots[history.index];
+      for (let i = 0; i < snapshot.length; i++) {
         if (!snapshot[i]) {
           break;
         }
-
-        var _snapshot$i = _slicedToArray(snapshot[i], 2),
-            index = _snapshot$i[0],
-            oldLabel = _snapshot$i[1];
-
+        const [index, oldLabel] = snapshot[i];
         data[index] = oldLabel;
       }
-
       history.index--;
       scalars.setData(data);
       scalars.modified();
       model.labelMap.modified();
       publicAPI.modified();
     }
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.canRedo = function () {
-    return history.index < history.labels.length - 1;
-  }; // --------------------------------------------------------------------------
+  publicAPI.canRedo = () => history.index < history.labels.length - 1;
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.redo = function () {
+  publicAPI.redo = () => {
     if (history.index < history.labels.length - 1) {
-      var scalars = model.labelMap.getPointData().getScalars();
-      var data = scalars.getData();
-      var redoLabel = history.labels[history.index + 1];
-      var snapshot = history.snapshots[history.index + 1];
-
-      for (var i = 0; i < snapshot.length; i++) {
+      const scalars = model.labelMap.getPointData().getScalars();
+      const data = scalars.getData();
+      const redoLabel = history.labels[history.index + 1];
+      const snapshot = history.snapshots[history.index + 1];
+      for (let i = 0; i < snapshot.length; i++) {
         if (!snapshot[i]) {
           break;
         }
-
-        var _snapshot$i2 = _slicedToArray(snapshot[i], 1),
-            index = _snapshot$i2[0];
-
+        const [index] = snapshot[i];
         data[index] = redoLabel;
       }
-
       history.index++;
       scalars.setData(data);
       scalars.modified();
       model.labelMap.modified();
       publicAPI.modified();
     }
-  }; // --------------------------------------------------------------------------
-
+  };
 
-  var superSetLabelMap = publicAPI.setLabelMap;
+  // --------------------------------------------------------------------------
 
-  publicAPI.setLabelMap = function (lm) {
+  const superSetLabelMap = publicAPI.setLabelMap;
+  publicAPI.setLabelMap = lm => {
     if (superSetLabelMap(lm)) {
       model.maskWorldToIndex = model.labelMap.getWorldToIndex();
       resetHistory();
       return true;
     }
-
     return false;
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     if (!model.backgroundImage) {
       vtkErrorMacro('No background image');
       return;
     }
-
     if (!model.backgroundImage.getPointData().getScalars()) {
       vtkErrorMacro('Background image has no scalars');
       return;
     }
-
     if (!model.labelMap) {
       // clone background image properties
-      var labelMap = vtkImageData.newInstance(model.backgroundImage.get('spacing', 'origin', 'direction'));
+      const labelMap = vtkImageData.newInstance(model.backgroundImage.get('spacing', 'origin', 'direction'));
       labelMap.setDimensions(model.backgroundImage.getDimensions());
-      labelMap.computeTransforms(); // right now only support 256 labels
+      labelMap.computeTransforms();
 
-      var values = new Uint8Array(model.backgroundImage.getNumberOfPoints());
-      var dataArray = vtkDataArray.newInstance({
+      // right now only support 256 labels
+      const values = new Uint8Array(model.backgroundImage.getNumberOfPoints());
+      const dataArray = vtkDataArray.newInstance({
         numberOfComponents: 1,
         // labelmap with single component
-        values: values
+        values
       });
       labelMap.getPointData().setScalars(dataArray);
       publicAPI.setLabelMap(labelMap);
     }
-
     if (!model.maskWorldToIndex) {
       model.maskWorldToIndex = model.labelMap.getWorldToIndex();
     }
-
-    var scalars = model.labelMap.getPointData().getScalars();
-
+    const scalars = model.labelMap.getPointData().getScalars();
     if (!scalars) {
       vtkErrorMacro('Mask image has no scalars');
       return;
     }
-
     model.labelMap.modified();
     outData[0] = model.labelMap;
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Initialization
   // --------------------------------------------------------------------------
 
-
   resetHistory();
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   backgroundImage: null,
   labelMap: null,
   maskWorldToIndex: null,
@@ -366,25 +345,34 @@ var DEFAULT_VALUES = {
   radius: 1,
   label: 0,
   slicingMode: null
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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 no input and one output
+  // Make this a VTK object
+  macro.obj(publicAPI, model);
 
+  // Also make it an algorithm with no input and one output
   macro.algo(publicAPI, model, 0, 1);
-  macro.setGet(publicAPI, model, ['backgroundImage', 'labelMap', 'maskWorldToIndex', 'voxelFunc', 'label', 'radius', 'slicingMode']); // Object specific methods
+  macro.setGet(publicAPI, model, ['backgroundImage', 'labelMap', 'maskWorldToIndex', 'voxelFunc', 'label', 'radius', 'slicingMode']);
 
+  // Object specific methods
   vtkPaintFilter(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkPaintFilter'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkPaintFilter');
+
+// ----------------------------------------------------------------------------
 
 var vtkPaintFilter$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkPaintFilter$1 as default, extend, newInstance };

package/Filters/General/ScalarToRGBA.js

@@ -1,48 +1,44 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkImageData from '../../Common/DataModel/ImageData.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+const {
+  vtkErrorMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
 // vtkScalarToRGBA methods
 // ----------------------------------------------------------------------------
 
 function vtkScalarToRGBA(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkScalarToRGBA');
-
-  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 scalars = input.getPointData().getScalars();
-
+    const scalars = input.getPointData().getScalars();
     if (!scalars) {
       vtkErrorMacro('No scalars from input');
       return;
     }
-
     if (!model.lookupTable) {
       vtkErrorMacro('No lookupTable available');
       return;
     }
-
     if (!model.piecewiseFunction) {
       vtkErrorMacro('No piecewiseFunction available');
       return;
     }
-
-    var rgba = [0, 0, 0, 0];
-    var data = scalars.getData();
-    var rgbaArray = new Uint8Array(data.length * 4);
-    var offset = 0;
-
-    for (var idx = 0; idx < data.length; idx++) {
-      var x = data[idx];
+    const rgba = [0, 0, 0, 0];
+    const data = scalars.getData();
+    const rgbaArray = new Uint8Array(data.length * 4);
+    let offset = 0;
+    for (let idx = 0; idx < data.length; idx++) {
+      const x = data[idx];
       model.lookupTable.getColor(x, rgba);
       rgba[3] = model.piecewiseFunction.getValue(x);
       rgbaArray[offset++] = 255 * rgba[0];
@@ -50,41 +46,50 @@ function vtkScalarToRGBA(publicAPI, model) {
       rgbaArray[offset++] = 255 * rgba[2];
       rgbaArray[offset++] = 255 * rgba[3];
     }
-
-    var colorArray = vtkDataArray.newInstance({
+    const colorArray = vtkDataArray.newInstance({
       name: 'rgba',
       numberOfComponents: 4,
       values: rgbaArray
     });
-    var datasetDefinition = input.get('extent', 'spacing', 'origin', 'direction');
-    var output = vtkImageData.newInstance(datasetDefinition);
+    const datasetDefinition = input.get('extent', 'spacing', 'origin', 'direction');
+    const output = vtkImageData.newInstance(datasetDefinition);
     output.getPointData().setScalars(colorArray);
     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);
 
+  // Also make it an algorithm with one input and one output
   macro.algo(publicAPI, model, 1, 1);
-  macro.setGet(publicAPI, model, ['lookupTable', 'piecewiseFunction']); // Object specific methods
+  macro.setGet(publicAPI, model, ['lookupTable', 'piecewiseFunction']);
 
+  // Object specific methods
   vtkScalarToRGBA(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkScalarToRGBA'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkScalarToRGBA');
+
+// ----------------------------------------------------------------------------
 
 var vtkScalarToRGBA$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkScalarToRGBA$1 as default, extend, newInstance };