@kitware/vtk.js 28.10.2 → 28.11.1

package/Rendering/Core/HardwareSelector.js

@@ -1,96 +1,63 @@
-import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
-import _regeneratorRuntime from '@babel/runtime/regenerator';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkDataSet from '../../Common/DataModel/DataSet.js';
 
-var FieldAssociations = vtkDataSet.FieldAssociations; // ----------------------------------------------------------------------------
+const {
+  FieldAssociations
+} = vtkDataSet;
+
+// ----------------------------------------------------------------------------
 // vtkHardwareSelector methods
 // ----------------------------------------------------------------------------
 
 function vtkHardwareSelector(publicAPI, model) {
-  model.classHierarchy.push('vtkHardwareSelector'); // get the source data that is used for generating a selection. This
+  model.classHierarchy.push('vtkHardwareSelector');
+
+  // get the source data that is used for generating a selection. This
   // must be called at least once before calling generateSelection. In
   // raster based backends this method will capture the buffers. You can
   // call this once and then make multiple calls to generateSelection.
+  publicAPI.getSourceDataAsync = async (renderer, fx1, fy1, fx2, fy2) => {};
+  publicAPI.selectAsync = async (renderer, fx1, fy1, fx2, fy2) => {
+    const srcData = await publicAPI.getSourceDataAsync(renderer, fx1, fy1, fx2, fy2);
+    if (srcData) {
+      return srcData.generateSelection(fx1, fy1, fx2, fy2);
+    }
+    return [];
+  };
+}
 
-  publicAPI.getSourceDataAsync = /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(renderer, fx1, fy1, fx2, fy2) {
-      return _regeneratorRuntime.wrap(function _callee$(_context) {
-        while (1) {
-          switch (_context.prev = _context.next) {
-            case 0:
-            case "end":
-              return _context.stop();
-          }
-        }
-      }, _callee);
-    }));
-
-    return function (_x, _x2, _x3, _x4, _x5) {
-      return _ref.apply(this, arguments);
-    };
-  }();
-
-  publicAPI.selectAsync = /*#__PURE__*/function () {
-    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(renderer, fx1, fy1, fx2, fy2) {
-      var srcData;
-      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
-        while (1) {
-          switch (_context2.prev = _context2.next) {
-            case 0:
-              _context2.next = 2;
-              return publicAPI.getSourceDataAsync(renderer, fx1, fy1, fx2, fy2);
-
-            case 2:
-              srcData = _context2.sent;
-
-              if (!srcData) {
-                _context2.next = 5;
-                break;
-              }
-
-              return _context2.abrupt("return", srcData.generateSelection(fx1, fy1, fx2, fy2));
-
-            case 5:
-              return _context2.abrupt("return", []);
-
-            case 6:
-            case "end":
-              return _context2.stop();
-          }
-        }
-      }, _callee2);
-    }));
-
-    return function (_x6, _x7, _x8, _x9, _x10) {
-      return _ref2.apply(this, arguments);
-    };
-  }();
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   fieldAssociation: FieldAssociations.FIELD_ASSOCIATION_CELLS,
   captureZValues: false
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Inheritance
   macro.obj(publicAPI, model);
-  macro.setGet(publicAPI, model, ['fieldAssociation', 'captureZValues']); // Object methods
+  macro.setGet(publicAPI, model, ['fieldAssociation', 'captureZValues']);
 
+  // Object methods
   vtkHardwareSelector(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkHardwareSelector'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkHardwareSelector');
+
+// ----------------------------------------------------------------------------
 
 var vtkHardwareSelector$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkHardwareSelector$1 as default, extend, newInstance };

package/Rendering/Core/ImageArrayMapper.js

@@ -1,242 +1,203 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkAbstractImageMapper from './AbstractImageMapper.js';
 import vtkImageMapper from './ImageMapper.js';
 import { F as createUninitializedBounds } from '../../Common/Core/Math/index.js';
 import { intersectWithLineForPointPicking, intersectWithLineForCellPicking } from './AbstractImageMapper/helper.js';
 import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.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 {
+  staticOffsetAPI,
+  otherStaticMethods
+} = CoincidentTopologyHelper;
+const {
+  vtkErrorMacro,
+  vtkWarningMacro
+} = macro;
+const {
+  SlicingMode
+} = vtkImageMapper;
 
-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 staticOffsetAPI = CoincidentTopologyHelper.staticOffsetAPI,
-    otherStaticMethods = CoincidentTopologyHelper.otherStaticMethods;
-var vtkErrorMacro = macro.vtkErrorMacro,
-    vtkWarningMacro = macro.vtkWarningMacro;
-var SlicingMode = vtkImageMapper.SlicingMode; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkImageArrayMapper methods
 // ----------------------------------------------------------------------------
 
 function vtkImageArrayMapper(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkImageArrayMapper'); //------------------
-  // Private functions
+  model.classHierarchy.push('vtkImageArrayMapper');
 
-  var _computeSliceToSubSliceMap = function _computeSliceToSubSliceMap() {
-    var inputCollection = publicAPI.getInputData();
+  //------------------
+  // Private functions
 
+  const _computeSliceToSubSliceMap = () => {
+    const inputCollection = publicAPI.getInputData();
     if (!inputCollection || inputCollection.empty()) {
       // clear the map
       if (model.sliceToSubSliceMap.length !== 0) {
         model.sliceToSubSliceMap.length = 0;
         publicAPI.modified();
       }
-
       return;
     }
-
     if (model.sliceToSubSliceMap.length === 0 || inputCollection.getMTime() > publicAPI.getMTime()) {
-      var perImageMap = inputCollection.map(function (image, index) {
-        var dim = image.getDimensions();
-        var out = new Array(dim[model.slicingMode]);
-
-        for (var i = 0; i < out.length; ++i) {
+      const perImageMap = inputCollection.map((image, index) => {
+        const dim = image.getDimensions();
+        const out = new Array(dim[model.slicingMode]);
+        for (let i = 0; i < out.length; ++i) {
           out[i] = {
             imageIndex: index,
             subSlice: i
           };
         }
-
         return out;
       });
       model.sliceToSubSliceMap = perImageMap.flat();
       publicAPI.modified();
     }
   };
+  const _superSetInputData = publicAPI.setInputData;
+  const _superSetInputConnection = publicAPI.setInputConnection;
 
-  var _superSetInputData = publicAPI.setInputData;
-  var _superSetInputConnection = publicAPI.setInputConnection; //------------------
+  //------------------
   // Public functions
 
-  publicAPI.setInputData = function (inputData) {
+  publicAPI.setInputData = inputData => {
     _superSetInputData(inputData);
-
     _computeSliceToSubSliceMap();
   };
-
   publicAPI.setInputConnection = function (outputPort) {
-    var port = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-
+    let port = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
     _superSetInputConnection(outputPort, port);
-
     _computeSliceToSubSliceMap();
   };
-
   publicAPI.getImage = function () {
-    var slice = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : publicAPI.getSlice();
-    var inputCollection = publicAPI.getInputData();
-
+    let slice = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : publicAPI.getSlice();
+    const inputCollection = publicAPI.getInputData();
     if (!inputCollection) {
       vtkWarningMacro('No input set.');
     } else if (slice < 0 || slice >= publicAPI.getTotalSlices()) {
       vtkWarningMacro('Invalid slice number.');
     } else {
       _computeSliceToSubSliceMap();
-
       return inputCollection.getItem(model.sliceToSubSliceMap[slice].imageIndex);
     }
-
     return null;
   };
-
-  publicAPI.getBounds = function () {
-    var image = publicAPI.getCurrentImage();
-
+  publicAPI.getBounds = () => {
+    const image = publicAPI.getCurrentImage();
     if (!image) {
       return createUninitializedBounds();
     }
-
     if (!model.useCustomExtents) {
       return image.getBounds();
     }
-
-    var ex = model.customDisplayExtent.slice(); // use sub-slice of the current image,
+    const ex = model.customDisplayExtent.slice();
+    // use sub-slice of the current image,
     // which is the k-coordinate.
-
-    var nSlice = publicAPI.getSubSlice();
+    const nSlice = publicAPI.getSubSlice();
     ex[4] = nSlice;
     ex[5] = nSlice;
     return image.extentToBounds(ex);
   };
-
   publicAPI.getBoundsForSlice = function () {
-    var slice = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : publicAPI.getSlice();
-    var halfThickness = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    var image = publicAPI.getImage(slice);
-
+    let slice = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : publicAPI.getSlice();
+    let halfThickness = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    const image = publicAPI.getImage(slice);
     if (!image) {
       return createUninitializedBounds();
     }
-
-    var extent = image.getSpatialExtent();
-    var nSlice = publicAPI.getSubSlice(slice);
+    const extent = image.getSpatialExtent();
+    const nSlice = publicAPI.getSubSlice(slice);
     extent[4] = nSlice - halfThickness;
     extent[5] = nSlice + halfThickness;
     return image.extentToBounds(extent);
   };
-
-  publicAPI.getClosestIJKAxis = function () {
-    return {
-      ijkMode: model.slicingMode,
-      flip: false
-    };
-  };
-
-  publicAPI.computeTotalSlices = function () {
-    var inputCollection = publicAPI.getInputData();
-    var collectionLength = inputCollection.getNumberOfItems();
-    var slicesCount = 0;
-
-    for (var i = 0; i < collectionLength; ++i) {
-      var image = inputCollection.getItem(i);
-
+  publicAPI.getClosestIJKAxis = () => ({
+    ijkMode: model.slicingMode,
+    flip: false
+  });
+  publicAPI.computeTotalSlices = () => {
+    const inputCollection = publicAPI.getInputData();
+    const collectionLength = inputCollection.getNumberOfItems();
+    let slicesCount = 0;
+    for (let i = 0; i < collectionLength; ++i) {
+      const image = inputCollection.getItem(i);
       if (image) {
         slicesCount += image.getDimensions()[model.slicingMode];
       }
     }
-
     return slicesCount;
   };
-
-  publicAPI.getTotalSlices = function () {
+  publicAPI.getTotalSlices = () => {
     _computeSliceToSubSliceMap();
-
     return model.sliceToSubSliceMap.length;
-  }; // set slice number in terms of imageIndex and subSlice number.
-
-
-  publicAPI.setSlice = function (slice) {
-    var inputCollection = publicAPI.getInputData();
+  };
 
+  // set slice number in terms of imageIndex and subSlice number.
+  publicAPI.setSlice = slice => {
+    const inputCollection = publicAPI.getInputData();
     if (!inputCollection) {
       // No input is set
       vtkWarningMacro('No input set.');
       return;
     }
-
-    var totalSlices = publicAPI.getTotalSlices();
-
+    const totalSlices = publicAPI.getTotalSlices();
     if (slice >= 0 && slice < totalSlices) {
       model.slice = slice;
       publicAPI.modified();
     } else {
-      vtkErrorMacro("Slice number out of range. Acceptable range is: [0, ".concat(totalSlices > 0 ? totalSlices - 1 : 0, "]slice <= totalSlices"));
+      vtkErrorMacro(`Slice number out of range. Acceptable range is: [0, ${totalSlices > 0 ? totalSlices - 1 : 0}]slice <= totalSlices`);
     }
   };
-
-  publicAPI.computeSlice = function (imageIndex, subSlice) {
+  publicAPI.computeSlice = (imageIndex, subSlice) => {
     _computeSliceToSubSliceMap();
-
-    return model.sliceToSubSliceMap.findIndex(function (x) {
-      return x.imageIndex === imageIndex && x.subSlice === subSlice;
-    });
+    return model.sliceToSubSliceMap.findIndex(x => x.imageIndex === imageIndex && x.subSlice === subSlice);
   };
-
   publicAPI.getImageIndex = function () {
-    var _model$sliceToSubSlic;
-
-    var slice = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : publicAPI.getSlice();
-
+    let slice = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : publicAPI.getSlice();
     _computeSliceToSubSliceMap();
-
-    return (_model$sliceToSubSlic = model.sliceToSubSliceMap[slice]) === null || _model$sliceToSubSlic === void 0 ? void 0 : _model$sliceToSubSlic.imageIndex;
+    return model.sliceToSubSliceMap[slice]?.imageIndex;
   };
-
   publicAPI.getSubSlice = function () {
-    var _model$sliceToSubSlic2;
-
-    var slice = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : publicAPI.getSlice();
-
+    let slice = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : publicAPI.getSlice();
     _computeSliceToSubSliceMap();
-
-    return (_model$sliceToSubSlic2 = model.sliceToSubSliceMap[slice]) === null || _model$sliceToSubSlic2 === void 0 ? void 0 : _model$sliceToSubSlic2.subSlice;
-  };
-
-  publicAPI.getCurrentImage = function () {
-    return publicAPI.getImage(publicAPI.getSlice());
-  };
-
-  publicAPI.intersectWithLineForPointPicking = function (p1, p2) {
-    return intersectWithLineForPointPicking(p1, p2, publicAPI);
-  };
-
-  publicAPI.intersectWithLineForCellPicking = function (p1, p2) {
-    return intersectWithLineForCellPicking(p1, p2, publicAPI);
+    return model.sliceToSubSliceMap[slice]?.subSlice;
   };
-} // ----------------------------------------------------------------------------
+  publicAPI.getCurrentImage = () => publicAPI.getImage(publicAPI.getSlice());
+  publicAPI.intersectWithLineForPointPicking = (p1, p2) => intersectWithLineForPointPicking(p1, p2, publicAPI);
+  publicAPI.intersectWithLineForCellPicking = (p1, p2) => intersectWithLineForCellPicking(p1, p2, publicAPI);
+}
 
-
-var DEFAULT_VALUES = {
+// ----------------------------------------------------------------------------
+const DEFAULT_VALUES = {
   slicingMode: SlicingMode.K,
   sliceToSubSliceMap: []
 };
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
-  vtkAbstractImageMapper.extend(publicAPI, model, initialValues); // Build VTK API
+  // Build VTK API
+  vtkAbstractImageMapper.extend(publicAPI, model, initialValues);
 
+  // Build VTK API
   macro.get(publicAPI, model, ['slicingMode']);
-  CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model); // Object methods
+  CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model);
 
+  // Object methods
   vtkImageArrayMapper(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkImageArrayMapper'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkImageArrayMapper');
 
-var index = _objectSpread(_objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, staticOffsetAPI), otherStaticMethods);
+// ----------------------------------------------------------------------------
+
+var index = {
+  newInstance,
+  extend,
+  ...staticOffsetAPI,
+  ...otherStaticMethods
+};
 
 export { index as default, extend, newInstance };