@kitware/vtk.js 28.10.2 → 28.11.0

package/Filters/General/Calculator.js

@@ -1,142 +1,99 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import vtk from '../../vtk.js';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkPoints from '../../Common/Core/Points.js';
 import { FieldDataTypes } from '../../Common/DataModel/DataSet/Constants.js';
 import { AttributeTypes } from '../../Common/DataModel/DataSetAttributes/Constants.js';
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+const {
+  vtkWarningMacro
+} = macro;
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-var vtkWarningMacro = macro.vtkWarningMacro; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkCalculator methods
 // ----------------------------------------------------------------------------
 
 function vtkCalculator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkCalculator');
-
-  publicAPI.setFormula = function (formula) {
+  publicAPI.setFormula = formula => {
     if (formula === model.formula) {
       return false;
     }
-
     model.formula = formula;
     publicAPI.modified();
     return true;
   };
-
-  publicAPI.getFormula = function () {
-    return model.formula;
-  };
-
-  publicAPI.augmentInputArrays = function (locn, arraysIn) {
-    var arraysOut = arraysIn.slice(0); // shallow-copy the inputs
+  publicAPI.getFormula = () => model.formula;
+  publicAPI.augmentInputArrays = (locn, arraysIn) => {
+    const arraysOut = arraysIn.slice(0); // shallow-copy the inputs
     // Make point coordinates available whenever the field-data is associated with
     // points or graph vertices:
-
     if (locn === FieldDataTypes.POINT || locn === FieldDataTypes.VERTEX) {
       arraysOut.push({
         location: FieldDataTypes.COORDINATE
       });
-    } // TODO: Make cell connectivity available when field-data is associated with
+    }
+    // TODO: Make cell connectivity available when field-data is associated with
     // cells or graph edges.
-
-
     return arraysOut;
   };
-
   publicAPI.createSimpleFormulaObject = function (locn, arrNames, resultName, singleValueFormula) {
-    var options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+    let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
     return {
-      getArrays: function getArrays() {
-        return {
-          input: publicAPI.augmentInputArrays(locn, arrNames.map(function (x) {
-            return {
-              location: locn,
-              name: x
-            };
-          })),
-          output: [{
-            location: locn,
-            name: resultName,
-            attribute: 'outputAttributeType' in options ? options.outputAttributeType : AttributeTypes.SCALARS,
-            numberOfComponents: 'numberOfOutputComponents' in options ? options.numberOfOutputComponents : 1
-          }]
-        };
-      },
-      evaluate: function evaluate(arraysIn, arraysOut) {
-        var tuples = new Array(arraysIn.length);
-        var arrayInAccessors = arraysIn.map(function (x, jj) {
-          var nc = x.getNumberOfComponents();
-          var rawData = x.getData();
-          return nc === 1 ? function (ii) {
-            return rawData[ii];
-          } : function (ii) {
-            return x.getTuple(ii, tuples[jj]);
-          };
+      getArrays: () => ({
+        input: publicAPI.augmentInputArrays(locn, arrNames.map(x => ({
+          location: locn,
+          name: x
+        }))),
+        output: [{
+          location: locn,
+          name: resultName,
+          attribute: 'outputAttributeType' in options ? options.outputAttributeType : AttributeTypes.SCALARS,
+          numberOfComponents: 'numberOfOutputComponents' in options ? options.numberOfOutputComponents : 1
+        }]
+      }),
+      evaluate: (arraysIn, arraysOut) => {
+        const tuples = new Array(arraysIn.length);
+        const arrayInAccessors = arraysIn.map((x, jj) => {
+          const nc = x.getNumberOfComponents();
+          const rawData = x.getData();
+          return nc === 1 ? ii => rawData[ii] : ii => x.getTuple(ii, tuples[jj]);
         });
-        var arrayOut = arraysOut[0];
-        var arrayOutRaw = arrayOut.getData();
-        var nc = arrayOut.getNumberOfComponents();
-        var tupleOut = new Array(nc);
-
+        const arrayOut = arraysOut[0];
+        const arrayOutRaw = arrayOut.getData();
+        const nc = arrayOut.getNumberOfComponents();
+        let tupleOut = new Array(nc);
         if (nc === 1) {
-          arrayOutRaw.forEach(function (xxx, ii) {
-            arrayOutRaw[ii] = singleValueFormula.apply(void 0, _toConsumableArray(arrayInAccessors.map(function (x) {
-              return x(ii);
-            })).concat([ii, tupleOut]));
+          arrayOutRaw.forEach((xxx, ii) => {
+            arrayOutRaw[ii] = singleValueFormula(...arrayInAccessors.map(x => x(ii)), ii, tupleOut);
           });
         } else {
-          var nt = arrayOut.getNumberOfTuples();
-
-          var _loop = function _loop(ii) {
-            tupleOut = singleValueFormula.apply(void 0, _toConsumableArray(arrayInAccessors.map(function (x) {
-              return x(ii);
-            })).concat([ii, tupleOut]));
+          const nt = arrayOut.getNumberOfTuples();
+          for (let ii = 0; ii < nt; ++ii) {
+            tupleOut = singleValueFormula(...arrayInAccessors.map(x => x(ii)), ii, tupleOut);
             arrayOut.setTuple(ii, tupleOut);
-          };
-
-          for (var ii = 0; ii < nt; ++ii) {
-            _loop(ii);
           }
         }
       }
     };
   };
-
   publicAPI.setFormulaSimple = function (locn, arrNames, resultName, formula) {
-    var options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+    let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
     return publicAPI.setFormula(publicAPI.createSimpleFormulaObject(locn, arrNames, resultName, formula, options));
   };
-
-  publicAPI.prepareArrays = function (arraySpec, inData, outData) {
-    var arraysIn = [];
-    var arraysOut = [];
-    arraySpec.input.forEach(function (spec) {
+  publicAPI.prepareArrays = (arraySpec, inData, outData) => {
+    const arraysIn = [];
+    const arraysOut = [];
+    arraySpec.input.forEach(spec => {
       if (spec.location === FieldDataTypes.COORDINATE) {
         arraysIn.push(inData.getPoints());
       } else {
-        var fetchArrayContainer = [[FieldDataTypes.UNIFORM, function (x) {
-          return x.getFieldData();
-        }], [FieldDataTypes.POINT, function (x) {
-          return x.getPointData();
-        }], [FieldDataTypes.CELL, function (x) {
-          return x.getCellData();
-        }], [FieldDataTypes.VERTEX, function (x) {
-          return x.getVertexData();
-        }], [FieldDataTypes.EDGE, function (x) {
-          return x.getEdgeData();
-        }], [FieldDataTypes.ROW, function (x) {
-          return x.getRowData();
-        }]].reduce(function (result, value) {
+        const fetchArrayContainer = [[FieldDataTypes.UNIFORM, x => x.getFieldData()], [FieldDataTypes.POINT, x => x.getPointData()], [FieldDataTypes.CELL, x => x.getCellData()], [FieldDataTypes.VERTEX, x => x.getVertexData()], [FieldDataTypes.EDGE, x => x.getEdgeData()], [FieldDataTypes.ROW, x => x.getRowData()]].reduce((result, value) => {
           result[value[0]] = value[1];
           return result;
         }, {});
-        var dsa = 'location' in spec && spec.location in fetchArrayContainer ? fetchArrayContainer[spec.location](inData) : null;
-
+        const dsa = 'location' in spec && spec.location in fetchArrayContainer ? fetchArrayContainer[spec.location](inData) : null;
         if (dsa) {
           if (spec.name) {
             arraysIn.push(dsa.getArrayByName(spec.name));
@@ -145,147 +102,122 @@ function vtkCalculator(publicAPI, model) {
           } else if ('attribute' in spec && spec.location !== FieldDataTypes.UNIFORM) {
             arraysIn.push(dsa.getActiveAttribute(spec.attribute));
           } else {
-            vtkWarningMacro("No matching array for specifier \"".concat(JSON.stringify(spec), "\"."));
+            vtkWarningMacro(`No matching array for specifier "${JSON.stringify(spec)}".`);
             arraysIn.push(null);
           }
         } else {
-          vtkWarningMacro("Specifier \"".concat(JSON.stringify(spec), "\" did not provide a usable location."));
+          vtkWarningMacro(`Specifier "${JSON.stringify(spec)}" did not provide a usable location.`);
           arraysIn.push(null);
         }
       }
     });
-    arraySpec.output.forEach(function (spec) {
-      var fullSpec = _objectSpread({}, spec);
-
-      var ncomp = 'numberOfComponents' in fullSpec ? fullSpec.numberOfComponents : 1;
-
+    arraySpec.output.forEach(spec => {
+      const fullSpec = {
+        ...spec
+      };
+      const ncomp = 'numberOfComponents' in fullSpec ? fullSpec.numberOfComponents : 1;
       if (spec.location === FieldDataTypes.UNIFORM && 'tuples' in fullSpec) {
         fullSpec.size = ncomp * fullSpec.tuples;
       }
-
       if (spec.location === FieldDataTypes.COORDINATE) {
-        var inPts = inData.getPoints();
-        var pts = vtkPoints.newInstance({
+        const inPts = inData.getPoints();
+        const pts = vtkPoints.newInstance({
           dataType: inPts.getDataType()
         });
         pts.setNumberOfPoints(inPts.getNumberOfPoints(), inPts.getNumberOfComponents());
         outData.setPoints(pts);
         arraysOut.push(pts);
       } else {
-        var fetchArrayContainer = [[FieldDataTypes.UNIFORM, function (x) {
-          return x.getFieldData();
-        }, function (x, y) {
-          return 'tuples' in y ? y.tuples : 0;
-        }], [FieldDataTypes.POINT, function (x) {
-          return x.getPointData();
-        }, function (x) {
-          return x.getPoints().getNumberOfPoints();
-        }], [FieldDataTypes.CELL, function (x) {
-          return x.getCellData();
-        }, function (x) {
-          return x.getNumberOfCells();
-        }], [FieldDataTypes.VERTEX, function (x) {
-          return x.getVertexData();
-        }, function (x) {
-          return x.getNumberOfVertices();
-        }], [FieldDataTypes.EDGE, function (x) {
-          return x.getEdgeData();
-        }, function (x) {
-          return x.getNumberOfEdges();
-        }], [FieldDataTypes.ROW, function (x) {
-          return x.getRowData();
-        }, function (x) {
-          return x.getNumberOfRows();
-        }]].reduce(function (result, value) {
+        const fetchArrayContainer = [[FieldDataTypes.UNIFORM, x => x.getFieldData(), (x, y) => 'tuples' in y ? y.tuples : 0], [FieldDataTypes.POINT, x => x.getPointData(), x => x.getPoints().getNumberOfPoints()], [FieldDataTypes.CELL, x => x.getCellData(), x => x.getNumberOfCells()], [FieldDataTypes.VERTEX, x => x.getVertexData(), x => x.getNumberOfVertices()], [FieldDataTypes.EDGE, x => x.getEdgeData(), x => x.getNumberOfEdges()], [FieldDataTypes.ROW, x => x.getRowData(), x => x.getNumberOfRows()]].reduce((result, value) => {
           result[value[0]] = {
             getData: value[1],
             getSize: value[2]
           };
           return result;
         }, {});
-        var dsa = null;
-        var tuples = 0;
-
+        let dsa = null;
+        let tuples = 0;
         if ('location' in spec && spec.location in fetchArrayContainer) {
           dsa = fetchArrayContainer[spec.location].getData(outData);
           tuples = fetchArrayContainer[spec.location].getSize(inData, fullSpec);
         }
-
         if (tuples <= 0) {
-          vtkWarningMacro("Output array size could not be determined for ".concat(JSON.stringify(spec), "."));
+          vtkWarningMacro(`Output array size could not be determined for ${JSON.stringify(spec)}.`);
           arraysOut.push(null);
         } else if (dsa) {
           fullSpec.size = ncomp * tuples;
-          var arrOut = vtkDataArray.newInstance(fullSpec);
-          var arrIdx = dsa.addArray(arrOut);
-
+          const arrOut = vtkDataArray.newInstance(fullSpec);
+          const arrIdx = dsa.addArray(arrOut);
           if ('attribute' in fullSpec && spec.location !== FieldDataTypes.UNIFORM) {
             dsa.setActiveAttributeByIndex(arrIdx, fullSpec.attribute);
           }
-
           arraysOut.push(arrOut);
         } else {
-          vtkWarningMacro("Specifier \"".concat(JSON.stringify(spec), "\" did not provide a usable location."));
+          vtkWarningMacro(`Specifier "${JSON.stringify(spec)}" did not provide a usable location.`);
           arraysOut.push(null);
         }
       }
     });
     return {
-      arraysIn: arraysIn,
-      arraysOut: arraysOut
+      arraysIn,
+      arraysOut
     };
   };
-
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     if (!model.formula) {
       return 0;
     }
-
-    var arraySpec = model.formula.getArrays(inData);
-    var newDataSet = vtk({
+    const arraySpec = model.formula.getArrays(inData);
+    const newDataSet = vtk({
       vtkClass: inData[0].getClassName()
     });
     newDataSet.shallowCopy(inData[0]);
     outData[0] = newDataSet;
-    var arrays = publicAPI.prepareArrays(arraySpec, inData[0], outData[0]);
+    const arrays = publicAPI.prepareArrays(arraySpec, inData[0], outData[0]);
     model.formula.evaluate(arrays.arraysIn, arrays.arraysOut);
     return 1;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   formula: {
-    getArrays: function getArrays() {
-      return {
-        input: [],
-        output: []
-      };
-    },
-    evaluate: function evaluate() {
-      return null;
-    }
+    getArrays: () => ({
+      input: [],
+      output: []
+    }),
+    evaluate: () => 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 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
   vtkCalculator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkCalculator'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkCalculator');
+
+// ----------------------------------------------------------------------------
 
 var vtkCalculator$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkCalculator$1 as default, extend, newInstance };

package/Filters/General/ClipClosedSurface/Constants.js

@@ -1,10 +1,10 @@
-var ScalarMode = {
+const ScalarMode = {
   NONE: 0,
   COLORS: 1,
   LABELS: 2
 };
 var Constants = {
-  ScalarMode: ScalarMode
+  ScalarMode
 };
 
 export { ScalarMode, Constants as default };