@kitware/vtk.js 28.10.2 → 28.11.1

package/Imaging/Core.js

@@ -4,10 +4,10 @@ import vtkImagePointDataIterator from './Core/ImagePointDataIterator.js';
 import vtkImageReslice from './Core/ImageReslice.js';
 
 var Core = {
-  vtkAbstractImageInterpolator: vtkAbstractImageInterpolator,
-  vtkImageInterpolator: vtkImageInterpolator,
-  vtkImagePointDataIterator: vtkImagePointDataIterator,
-  vtkImageReslice: vtkImageReslice
+  vtkAbstractImageInterpolator,
+  vtkImageInterpolator,
+  vtkImagePointDataIterator,
+  vtkImageReslice
 };
 
 export { Core as default };

package/Imaging/Hybrid/SampleFunction.js

@@ -1,114 +1,121 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkImageData from '../../Common/DataModel/ImageData.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 {
+  vtkErrorMacro
+} = 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 vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkSampleFunction methods
 // ----------------------------------------------------------------------------
 
 function vtkSampleFunction(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkSampleFunction'); // Capture "parentClass" api for internal use
-
-  var superClass = _objectSpread({}, publicAPI);
+  model.classHierarchy.push('vtkSampleFunction');
 
-  publicAPI.getMTime = function () {
+  // Capture "parentClass" api for internal use
+  const superClass = {
+    ...publicAPI
+  };
+  publicAPI.getMTime = () => {
     if (!(model.implicitFunction && model.implicitFunction.getMTime)) {
       return superClass.getMTime();
     }
-
     return Math.max(superClass.getMTime(), model.implicitFunction.getMTime());
   };
-
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     // implement requestData
-    var imp = model.implicitFunction;
-
+    const imp = model.implicitFunction;
     if (!imp) {
       vtkErrorMacro('An implicit function must be defined');
       return;
-    } // Create a volume
-
-
-    var dims = [model.sampleDimensions[0], model.sampleDimensions[1], model.sampleDimensions[2]];
-    var numScalars = dims[0] * dims[1] * dims[2];
+    }
 
+    // Create a volume
+    const dims = [model.sampleDimensions[0], model.sampleDimensions[1], model.sampleDimensions[2]];
+    const numScalars = dims[0] * dims[1] * dims[2];
     if (numScalars < 1 || dims[1] < 2 || dims[1] < 2 || dims[2] < 2) {
       vtkErrorMacro('Bad volume dimensions');
       return;
     }
-
-    var volume = vtkImageData.newInstance();
-    var origin = [model.modelBounds[0], model.modelBounds[2], model.modelBounds[4]];
-    var spacing = [(model.modelBounds[1] - model.modelBounds[0]) / (dims[0] - 1), (model.modelBounds[3] - model.modelBounds[2]) / (dims[1] - 1), (model.modelBounds[5] - model.modelBounds[4]) / (dims[2] - 1)];
-    var sliceSize = dims[0] * dims[1];
+    const volume = vtkImageData.newInstance();
+    const origin = [model.modelBounds[0], model.modelBounds[2], model.modelBounds[4]];
+    const spacing = [(model.modelBounds[1] - model.modelBounds[0]) / (dims[0] - 1), (model.modelBounds[3] - model.modelBounds[2]) / (dims[1] - 1), (model.modelBounds[5] - model.modelBounds[4]) / (dims[2] - 1)];
+    const sliceSize = dims[0] * dims[1];
     volume.setDimensions(dims);
     volume.setOrigin(origin);
-    volume.setSpacing(spacing); // Create scalars array
+    volume.setSpacing(spacing);
 
-    var s = macro.newTypedArray(model.pointType, numScalars);
-    var scalars = vtkDataArray.newInstance({
+    // Create scalars array
+    const s = macro.newTypedArray(model.pointType, numScalars);
+    const scalars = vtkDataArray.newInstance({
       name: 'Scalars',
       values: s,
       numberOfComponents: 1
     });
-    volume.getPointData().setScalars(scalars); // Now loop over volume dimensions and generate scalar values
+    volume.getPointData().setScalars(scalars);
 
-    var sValue = 0.0;
-    var xyz = [0.0, 0.0, 0.0];
-
-    for (var k = 0; k < dims[2]; k++) {
+    // Now loop over volume dimensions and generate scalar values
+    let sValue = 0.0;
+    const xyz = [0.0, 0.0, 0.0];
+    for (let k = 0; k < dims[2]; k++) {
       xyz[2] = origin[2] + k * spacing[2];
-
-      for (var j = 0; j < dims[1]; j++) {
+      for (let j = 0; j < dims[1]; j++) {
         xyz[1] = origin[1] + j * spacing[1];
-
-        for (var i = 0; i < dims[0]; i++) {
+        for (let i = 0; i < dims[0]; i++) {
           xyz[0] = origin[0] + i * spacing[0];
           sValue = imp.evaluateFunction(xyz);
           s[i + j * dims[0] + k * sliceSize] = sValue;
         }
       }
-    } // Update output
-
+    }
 
+    // Update output
     outData[0] = volume;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   implicitFunction: undefined,
   sampleDimensions: [50, 50, 50],
   modelBounds: [-1.0, 1.0, -1.0, 1.0, -1.0, 1.0],
   pointType: 'Float32Array'
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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); // Generate macros for properties
+  // Also make it an algorithm with one input and one output
+  macro.algo(publicAPI, model, 1, 1);
 
+  // Generate macros for properties
   macro.setGetArray(publicAPI, model, ['sampleDimensions'], 3);
-  macro.setGetArray(publicAPI, model, ['modelBounds'], 6); // Object specific methods
+  macro.setGetArray(publicAPI, model, ['modelBounds'], 6);
 
+  // Object specific methods
   vtkSampleFunction(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkSampleFunction');
 
-var newInstance = macro.newInstance(extend, 'vtkSampleFunction'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkSampleFunction$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkSampleFunction$1 as default, extend, newInstance };

package/Imaging/Hybrid.js

@@ -1,7 +1,7 @@
 import vtkSampleFunction from './Hybrid/SampleFunction.js';
 
 var Hybrid = {
-  vtkSampleFunction: vtkSampleFunction
+  vtkSampleFunction
 };
 
 export { Hybrid as default };

package/Imaging/index.js

@@ -2,8 +2,8 @@ import Core from './Core.js';
 import Hybrid from './Hybrid.js';
 
 var Imaging = {
-  Core: Core,
-  Hybrid: Hybrid
+  Core,
+  Hybrid
 };
 
 export { Imaging as default };

package/Interaction/Animations/TimeStepBasedAnimationHandler.js

@@ -1,123 +1,104 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.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; }
-
-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; }
+// ----------------------------------------------------------------------------
 // vtkTimeStepBasedAnimationHandler methods
 // ----------------------------------------------------------------------------
 
 function vtkTimeStepBasedAnimationHandler(publicAPI, model) {
-  publicAPI.setCurrentTimeStep = function (time) {
+  publicAPI.setCurrentTimeStep = time => {
     if (!model.timeSteps || model.timeSteps.length === 0) {
       return;
     }
-
     if (model.timeSteps.includes(time)) {
       model.currentTimeStep = time;
     } else if (time <= model.timeSteps[0]) {
       model.currentTimeStep = model.timeSteps[0];
     } else {
-      model.currentTimeStep = model.timeSteps.find(function (prevTime, index, array) {
+      model.currentTimeStep = model.timeSteps.find((prevTime, index, array) => {
         if (index === array.length - 1) {
           return true;
         }
-
         return time >= prevTime && time < array[index + 1];
       });
     }
-
     publicAPI.update();
   };
+  publicAPI.setData = data => {
+    model.data = data;
 
-  publicAPI.setData = function (data) {
-    model.data = data; // Refresh timesteps
-
+    // Refresh timesteps
     if (data.timeSteps) {
-      model.timeSteps = data.timeSteps.map(function (timeStep) {
-        return timeStep.time;
-      });
+      model.timeSteps = data.timeSteps.map(timeStep => timeStep.time);
       model.timeRange = [model.timeSteps[0], model.timeSteps[model.timeSteps.length - 1]];
       model.currentTimeStep = model.timeSteps[0];
     }
   };
-
-  publicAPI.setScene = function (scene, originalMetadata, applySettings, renderer) {
+  publicAPI.setScene = (scene, originalMetadata, applySettings, renderer) => {
     model.scene = scene;
     model.originalMetadata = originalMetadata;
     model.applySettings = applySettings;
     model.renderer = renderer;
   };
-
-  publicAPI.setCameraParameters = function (params) {
+  publicAPI.setCameraParameters = params => {
     if (model.renderers) {
-      model.renderers.forEach(function (renderer) {
-        var camera = renderer.getActiveCamera();
-
+      model.renderers.forEach(renderer => {
+        const camera = renderer.getActiveCamera();
         if (camera) {
           camera.set(params);
         }
       });
     }
   };
-
-  publicAPI.setBackground = function (color) {
+  publicAPI.setBackground = color => {
     if (model.renderers) {
-      model.renderers.forEach(function (renderer) {
+      model.renderers.forEach(renderer => {
         renderer.setBackground(color);
       });
     }
   };
-
-  publicAPI.update = function () {
+  publicAPI.update = () => {
     if (!model.data || !model.scene) {
       return;
     }
-
-    var currentScene = model.data.timeSteps.find(function (scene) {
-      return scene.time === model.currentTimeStep;
-    });
-
+    const currentScene = model.data.timeSteps.find(scene => scene.time === model.currentTimeStep);
     if (currentScene.camera) {
-      var camera = _objectSpread({}, model.originalMetadata.camera);
-
+      const camera = {
+        ...model.originalMetadata.camera
+      };
       Object.assign(camera, currentScene.camera);
       publicAPI.setCameraParameters(camera);
     }
-
     if (currentScene.background) {
       publicAPI.setBackground(currentScene.background);
     }
-
     if (model.scene) {
-      model.scene.forEach(function (sceneItem) {
+      model.scene.forEach(sceneItem => {
         if (sceneItem.source.setUpdateTimeStep && sceneItem.source.getTimeSteps().includes(model.currentTimeStep)) {
           sceneItem.source.setUpdateTimeStep(model.currentTimeStep);
         }
-
-        var id = sceneItem.id;
-
+        const id = sceneItem.id;
         if (currentScene[id]) {
-          var settings = _objectSpread({}, sceneItem.defaultSettings);
-
+          const settings = {
+            ...sceneItem.defaultSettings
+          };
           Object.assign(settings, currentScene[id]);
           model.applySettings(sceneItem, settings);
         }
       });
     }
   };
-
-  publicAPI.addRenderer = function (renderer) {
+  publicAPI.addRenderer = renderer => {
     if (renderer && !model.renderers.includes(renderer)) {
       model.renderers.push(renderer);
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   timeSteps: [0.0],
   timeRange: [0.0, 0.0],
   currentTimeStep: 0.0,
@@ -128,20 +109,24 @@ var DEFAULT_VALUES = {
   originalMetadata: null
 };
 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);
 
+  // Build VTK API
   macro.obj(publicAPI, model);
   macro.get(publicAPI, model, ['applySettings', 'currentTimeStep', 'data', 'originalMetada', 'scene', 'timeRange', 'timeSteps']);
-  macro.setGet(publicAPI, model, ['renderers']); // Object methods
+  macro.setGet(publicAPI, model, ['renderers']);
 
+  // Object methods
   vtkTimeStepBasedAnimationHandler(publicAPI, model);
 }
-var newInstance = macro.newInstance(extend, 'vtkTimeStepBasedAnimationHandler'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkTimeStepBasedAnimationHandler');
+
+// ----------------------------------------------------------------------------
 
 var vtkTimeStepBasedAnimationHandler$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkTimeStepBasedAnimationHandler$1 as default, extend, newInstance };

package/Interaction/Manipulators/CompositeCameraManipulator.js

@@ -1,41 +1,50 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 
+// ----------------------------------------------------------------------------
 // vtkCompositeCameraManipulator methods
 // ----------------------------------------------------------------------------
 
 function vtkCompositeCameraManipulator(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkCompositeCameraManipulator'); //-------------------------------------------------------------------------
+  model.classHierarchy.push('vtkCompositeCameraManipulator');
 
-  publicAPI.computeDisplayCenter = function (iObserver, renderer) {
-    var pt = iObserver.computeWorldToDisplay(renderer, model.center[0], model.center[1], model.center[2]);
+  //-------------------------------------------------------------------------
+  publicAPI.computeDisplayCenter = (iObserver, renderer) => {
+    const pt = iObserver.computeWorldToDisplay(renderer, model.center[0], model.center[1], model.center[2]);
     model.displayCenter[0] = pt[0];
     model.displayCenter[1] = pt[1];
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   center: [0, 0, 0],
   rotationFactor: 1,
   displayCenter: [0, 0]
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Create get-set macros
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Create get-set macros
   macro.setGet(publicAPI, model, ['rotationFactor']);
   macro.setGetArray(publicAPI, model, ['displayCenter'], 2);
-  macro.setGetArray(publicAPI, model, ['center'], 3); // Object specific methods
+  macro.setGetArray(publicAPI, model, ['center'], 3);
 
+  // Object specific methods
   vtkCompositeCameraManipulator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
 var vtkCompositeCameraManipulator$1 = {
-  extend: extend
+  extend
 };
 
 export { vtkCompositeCameraManipulator$1 as default, extend };

package/Interaction/Manipulators/CompositeGestureManipulator.js

@@ -1,68 +1,56 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 
+// ----------------------------------------------------------------------------
 // vtkCompositeMouseManipulator methods
 // ----------------------------------------------------------------------------
 
 function vtkCompositeGestureManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkCompositeGestureManipulator');
+  publicAPI.startInteraction = () => {};
+  publicAPI.endInteraction = () => {};
+  publicAPI.onStartPinch = (interactor, scale) => {};
+  publicAPI.onStartRotate = (interactor, rotation) => {};
+  publicAPI.onStartPan = (interactor, translation) => {};
+  publicAPI.onPinch = (interactor, renderer, scale) => {};
+  publicAPI.onRotate = (interactor, renderer, rotation) => {};
+  publicAPI.onPan = (interactor, renderer, translation) => {};
+  publicAPI.onEndPinch = interactor => {};
+  publicAPI.onEndRotate = interactor => {};
+  publicAPI.onEndPan = interactor => {};
+  publicAPI.isPinchEnabled = () => model.pinchEnabled;
+  publicAPI.isPanEnabled = () => model.panEnabled;
+  publicAPI.isRotateEnabled = () => model.rotateEnabled;
+}
 
-  publicAPI.startInteraction = function () {};
-
-  publicAPI.endInteraction = function () {};
-
-  publicAPI.onStartPinch = function (interactor, scale) {};
-
-  publicAPI.onStartRotate = function (interactor, rotation) {};
-
-  publicAPI.onStartPan = function (interactor, translation) {};
-
-  publicAPI.onPinch = function (interactor, renderer, scale) {};
-
-  publicAPI.onRotate = function (interactor, renderer, rotation) {};
-
-  publicAPI.onPan = function (interactor, renderer, translation) {};
-
-  publicAPI.onEndPinch = function (interactor) {};
-
-  publicAPI.onEndRotate = function (interactor) {};
-
-  publicAPI.onEndPan = function (interactor) {};
-
-  publicAPI.isPinchEnabled = function () {
-    return model.pinchEnabled;
-  };
-
-  publicAPI.isPanEnabled = function () {
-    return model.panEnabled;
-  };
-
-  publicAPI.isRotateEnabled = function () {
-    return model.rotateEnabled;
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   pinchEnabled: true,
   panEnabled: true,
   rotateEnabled: true
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Create get-set macros
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Create get-set macros
   macro.set(publicAPI, model, ['pinchEnabled', 'panEnabled', 'rotateEnabled']);
-  macro.setGet(publicAPI, model, ['interactorStyle']); // Object specific methods
+  macro.setGet(publicAPI, model, ['interactorStyle']);
 
+  // Object specific methods
   vtkCompositeGestureManipulator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
 var vtkCompositeGestureManipulator$1 = {
-  extend: extend
+  extend
 };
 
 export { vtkCompositeGestureManipulator$1 as default, extend };

package/Interaction/Manipulators/CompositeKeyboardManipulator.js

@@ -1,31 +1,35 @@
 // ----------------------------------------------------------------------------
 // vtkCompositeKeyboardManipulator methods
 // ----------------------------------------------------------------------------
+
 function vtkCompositeKeyboardManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkCompositeKeyboardManipulator');
+  publicAPI.onKeyPress = (interactor, renderer, key) => {};
+  publicAPI.onKeyDown = (interactor, renderer, key) => {};
+  publicAPI.onKeyUp = (interactor, renderer, key) => {};
+}
 
-  publicAPI.onKeyPress = function (interactor, renderer, key) {};
-
-  publicAPI.onKeyDown = function (interactor, renderer, key) {};
-
-  publicAPI.onKeyUp = function (interactor, renderer, key) {};
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // 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); // Object specific methods
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Object specific methods
   vtkCompositeKeyboardManipulator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
 var vtkCompositeKeyboardManipulator$1 = {
-  extend: extend
+  extend
 };
 
 export { vtkCompositeKeyboardManipulator$1 as default, extend };