@kitware/vtk.js 28.10.1 → 28.11.0

package/Widgets/Widgets3D/SplineWidget/behavior.js

@@ -1,59 +1,56 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import macro from '../../../macros.js';
+import { m as macro } from '../../../macros2.js';
 import { vec3 } from 'gl-matrix';
 
 function widgetBehavior(publicAPI, model) {
   model.classHierarchy.push('vtkSplineWidgetProp');
   model._isDragging = false;
   model.keysDown = {};
-  model.moveHandle = model.widgetState.getMoveHandle(); // --------------------------------------------------------------------------
+  model.moveHandle = model.widgetState.getMoveHandle();
+
+  // --------------------------------------------------------------------------
   // Private methods
   // --------------------------------------------------------------------------
 
-  var updateHandlesSize = function updateHandlesSize() {
+  const updateHandlesSize = () => {
     if (publicAPI.getHandleSizeInPixels() != null) {
-      var scale = publicAPI.getHandleSizeInPixels();
+      const scale = publicAPI.getHandleSizeInPixels();
       model.moveHandle.setScale1(scale);
-      model.widgetState.getHandleList().forEach(function (handle) {
+      model.widgetState.getHandleList().forEach(handle => {
         handle.setScale1(scale);
       });
     }
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  var addPoint = function addPoint() {
+  const addPoint = () => {
     // Commit handle to location
     if (!model.lastHandle || model.keysDown.Control || !model.freeHand || vec3.squaredDistance(model.moveHandle.getOrigin(), model.lastHandle.getOrigin()) > publicAPI.getFreehandMinDistance() * publicAPI.getFreehandMinDistance()) {
-      var _model$lastHandle;
-
       model.lastHandle = model.widgetState.addHandle();
       model.lastHandle.setVisible(false);
-
-      (_model$lastHandle = model.lastHandle).setOrigin.apply(_model$lastHandle, _toConsumableArray(model.moveHandle.getOrigin()));
-
+      model.lastHandle.setOrigin(...model.moveHandle.getOrigin());
       model.lastHandle.setColor(model.moveHandle.getColor());
       model.lastHandle.setScale1(model.moveHandle.getScale1());
       model.lastHandle.setManipulator(model.manipulator);
-
       if (!model.firstHandle) {
         model.firstHandle = model.lastHandle;
       }
-
       model._apiSpecificRenderWindow.setCursor('grabbing');
     }
-  }; // --------------------------------------------------------------------------
-
+  };
 
-  var getHoveredHandle = function getHoveredHandle() {
-    var handles = model.widgetState.getHandleList();
-    var scale = model.moveHandle.getScale1() * vec3.distance(model._apiSpecificRenderWindow.displayToWorld(0, 0, 0, model._renderer), model._apiSpecificRenderWindow.displayToWorld(1, 0, 0, model._renderer));
-    return handles.reduce(function (_ref, handle) {
-      var closestHandle = _ref.closestHandle,
-          closestDistance = _ref.closestDistance;
+  // --------------------------------------------------------------------------
 
+  const getHoveredHandle = () => {
+    const handles = model.widgetState.getHandleList();
+    const scale = model.moveHandle.getScale1() * vec3.distance(model._apiSpecificRenderWindow.displayToWorld(0, 0, 0, model._renderer), model._apiSpecificRenderWindow.displayToWorld(1, 0, 0, model._renderer));
+    return handles.reduce((_ref, handle) => {
+      let {
+        closestHandle,
+        closestDistance
+      } = _ref;
       if (handle !== model.moveHandle && model.moveHandle.getOrigin() && handle.getOrigin()) {
-        var distance = vec3.squaredDistance(model.moveHandle.getOrigin(), handle.getOrigin());
-
+        const distance = vec3.squaredDistance(model.moveHandle.getOrigin(), handle.getOrigin());
         if (distance < closestDistance) {
           return {
             closestHandle: handle,
@@ -61,27 +58,26 @@ function widgetBehavior(publicAPI, model) {
           };
         }
       }
-
       return {
-        closestHandle: closestHandle,
-        closestDistance: closestDistance
+        closestHandle,
+        closestDistance
       };
     }, {
       closestHandle: null,
       closestDistance: scale * scale
     }).closestHandle;
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Display 2D
   // --------------------------------------------------------------------------
 
+  publicAPI.setDisplayCallback = callback => model.representations[0].setDisplayCallback(callback);
 
-  publicAPI.setDisplayCallback = function (callback) {
-    return model.representations[0].setDisplayCallback(callback);
-  }; // --------------------------------------------------------------------------
+  // --------------------------------------------------------------------------
   // Public methods
   // --------------------------------------------------------------------------
 
-
   publicAPI.setResetAfterPointPlacement = model._factory.setResetAfterPointPlacement;
   publicAPI.getResetAfterPointPlacement = model._factory.getResetAfterPointPlacement;
   publicAPI.setResetAfterPointPlacement(publicAPI.getResetAfterPointPlacement());
@@ -93,84 +89,78 @@ function widgetBehavior(publicAPI, model) {
   publicAPI.setAllowFreehand(publicAPI.getAllowFreehand());
   publicAPI.setDefaultCursor = model._factory.setDefaultCursor;
   publicAPI.getDefaultCursor = model._factory.getDefaultCursor;
-  publicAPI.setDefaultCursor(publicAPI.getDefaultCursor()); // --------------------------------------------------------------------------
+  publicAPI.setDefaultCursor(publicAPI.getDefaultCursor());
 
-  publicAPI.setHandleSizeInPixels = function (size) {
-    model._factory.setHandleSizeInPixels(size);
+  // --------------------------------------------------------------------------
 
+  publicAPI.setHandleSizeInPixels = size => {
+    model._factory.setHandleSizeInPixels(size);
     updateHandlesSize();
   };
-
   publicAPI.getHandleSizeInPixels = model._factory.getHandleSizeInPixels;
   publicAPI.setHandleSizeInPixels(model._factory.getHandleSizeInPixels()); // set initial value
+
   // --------------------------------------------------------------------------
 
-  publicAPI.setResolution = function (resolution) {
+  publicAPI.setResolution = resolution => {
     model._factory.setResolution(resolution);
-
     model.representations[1].setResolution(resolution);
   };
-
   publicAPI.setResolution(model._factory.getResolution()); // set initial value
+
   // --------------------------------------------------------------------------
 
-  publicAPI.getPoints = function () {
-    return model.representations[1].getOutputData().getPoints().getData();
-  }; // --------------------------------------------------------------------------
+  publicAPI.getPoints = () => model.representations[1].getOutputData().getPoints().getData();
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.reset = function () {
+  publicAPI.reset = () => {
     model.widgetState.clearHandleList();
     model.lastHandle = null;
     model.firstHandle = null;
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Right click: Delete handle
   // --------------------------------------------------------------------------
 
-
-  publicAPI.handleRightButtonPress = function (e) {
+  publicAPI.handleRightButtonPress = e => {
     if (!model.activeState || !model.activeState.getActive() || !model.pickable) {
       return macro.VOID;
     }
-
     if (model.activeState !== model.moveHandle) {
       model._interactor.requestAnimation(publicAPI);
-
       model.activeState.deactivate();
       model.widgetState.removeHandle(model.activeState);
       model.activeState = null;
-
       model._interactor.cancelAnimation(publicAPI);
     } else {
-      var handle = getHoveredHandle();
-
+      const handle = getHoveredHandle();
       if (handle) {
         model.widgetState.removeHandle(handle);
       } else if (model.lastHandle) {
         model.widgetState.removeHandle(model.lastHandle);
-        var handles = model.widgetState.getHandleList();
+        const handles = model.widgetState.getHandleList();
         model.lastHandle = handles[handles.length - 1];
       }
     }
-
     publicAPI.invokeInteractionEvent();
     return macro.EVENT_ABORT;
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Left press: Add new point
   // --------------------------------------------------------------------------
 
-
-  publicAPI.handleLeftButtonPress = function (e) {
+  publicAPI.handleLeftButtonPress = e => {
     if (!model.activeState || !model.activeState.getActive() || !model.pickable) {
       return macro.VOID;
     }
-
     if (model.activeState === model.moveHandle) {
       if (model.widgetState.getHandleList().length === 0) {
         addPoint();
       } else {
-        var hoveredHandle = getHoveredHandle();
-
+        const hoveredHandle = getHoveredHandle();
         if (hoveredHandle && !model.keysDown.Control) {
           model.moveHandle.deactivate();
           model.moveHandle.setVisible(false);
@@ -182,47 +172,36 @@ function widgetBehavior(publicAPI, model) {
           addPoint();
         }
       }
-
       model.freeHand = publicAPI.getAllowFreehand() && !model._isDragging;
     } else if (model.dragable) {
       model._isDragging = true;
-
       model._apiSpecificRenderWindow.setCursor('grabbing');
-
       model._interactor.requestAnimation(publicAPI);
     }
-
     publicAPI.invokeStartInteractionEvent();
     return macro.EVENT_ABORT;
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Left release
   // --------------------------------------------------------------------------
 
-
-  publicAPI.handleLeftButtonRelease = function (e) {
+  publicAPI.handleLeftButtonRelease = e => {
     if (model._isDragging) {
       if (!model.hasFocus) {
         model._apiSpecificRenderWindow.setCursor(model.defaultCursor);
-
         model.widgetState.deactivate();
-
         model._interactor.cancelAnimation(publicAPI);
-
         publicAPI.invokeEndInteractionEvent();
       } else {
-        var _model$moveHandle;
-
-        (_model$moveHandle = model.moveHandle).setOrigin.apply(_model$moveHandle, _toConsumableArray(model.activeState.getOrigin()));
-
+        model.moveHandle.setOrigin(...model.activeState.getOrigin());
         model.activeState.deactivate();
         model.moveHandle.activate();
         model.activeState = model.moveHandle;
-
         if (!model.draggedPoint) {
           if (vec3.squaredDistance(model.moveHandle.getOrigin(), model.lastHandle.getOrigin()) < model.moveHandle.getScale1() * model.moveHandle.getScale1() || vec3.squaredDistance(model.moveHandle.getOrigin(), model.firstHandle.getOrigin()) < model.moveHandle.getScale1() * model.moveHandle.getScale1()) {
             model.lastHandle.setVisible(true);
             publicAPI.invokeEndInteractionEvent();
-
             if (publicAPI.getResetAfterPointPlacement()) {
               publicAPI.reset();
             } else {
@@ -230,82 +209,69 @@ function widgetBehavior(publicAPI, model) {
             }
           }
         }
-
         model._interactor.render();
       }
     } else if (model.activeState !== model.moveHandle) {
       model.widgetState.deactivate();
     }
-
     model.freeHand = false;
     model.draggedPoint = false;
     model._isDragging = false;
     return model.hasFocus ? macro.EVENT_ABORT : macro.VOID;
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Mouse move: Drag selected handle / Handle follow the mouse
   // --------------------------------------------------------------------------
 
-
-  publicAPI.handleMouseMove = function (callData) {
-    var _model$activeState$ge, _model$activeState, _model$activeState$ge2;
-
-    var manipulator = (_model$activeState$ge = (_model$activeState = model.activeState) === null || _model$activeState === void 0 ? void 0 : (_model$activeState$ge2 = _model$activeState.getManipulator) === null || _model$activeState$ge2 === void 0 ? void 0 : _model$activeState$ge2.call(_model$activeState)) !== null && _model$activeState$ge !== void 0 ? _model$activeState$ge : model.manipulator;
-
+  publicAPI.handleMouseMove = callData => {
+    const manipulator = model.activeState?.getManipulator?.() ?? model.manipulator;
     if (!manipulator || !model.activeState || !model.activeState.getActive() || !model.pickable) {
       return macro.VOID;
     }
-
-    var _manipulator$handleEv = manipulator.handleEvent(callData, model._apiSpecificRenderWindow),
-        worldCoords = _manipulator$handleEv.worldCoords;
-
-    var hoveredHandle = getHoveredHandle();
-
+    const {
+      worldCoords
+    } = manipulator.handleEvent(callData, model._apiSpecificRenderWindow);
+    const hoveredHandle = getHoveredHandle();
     if (hoveredHandle) {
       model.moveHandle.setVisible(false);
-
       if (hoveredHandle !== model.firstHandle) {
         model._apiSpecificRenderWindow.setCursor('grabbing');
       }
     } else if (!model._isDragging && model.hasFocus) {
       model.moveHandle.setVisible(true);
-
       model._apiSpecificRenderWindow.setCursor(model.defaultCursor);
     }
-
     if (model.lastHandle) {
       model.lastHandle.setVisible(true);
     }
-
     if (worldCoords.length && (model._isDragging || model.activeState === model.moveHandle)) {
       model.activeState.setOrigin(worldCoords);
-
       if (model._isDragging) {
         model.draggedPoint = true;
       }
-
       if (model.freeHand && model.activeState === model.moveHandle) {
         addPoint();
       }
     }
-
     return model.hasFocus ? macro.EVENT_ABORT : macro.VOID;
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Mofifier keys
   // --------------------------------------------------------------------------
 
-
-  publicAPI.handleKeyDown = function (_ref2) {
-    var key = _ref2.key;
+  publicAPI.handleKeyDown = _ref2 => {
+    let {
+      key
+    } = _ref2;
     model.keysDown[key] = true;
-
     if (!model.hasFocus) {
       return;
     }
-
     if (key === 'Enter') {
       if (model.widgetState.getHandleList().length > 0) {
         publicAPI.invokeEndInteractionEvent();
-
         if (publicAPI.getResetAfterPointPlacement()) {
           publicAPI.reset();
         } else {
@@ -319,48 +285,47 @@ function widgetBehavior(publicAPI, model) {
     } else if (key === 'Delete' || key === 'Backspace') {
       if (model.lastHandle) {
         model.widgetState.removeHandle(model.lastHandle);
-        var handleList = model.widgetState.getHandleList();
+        const handleList = model.widgetState.getHandleList();
         model.lastHandle = handleList[handleList.length - 1];
       }
     }
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.handleKeyUp = function (_ref3) {
-    var key = _ref3.key;
+  publicAPI.handleKeyUp = _ref3 => {
+    let {
+      key
+    } = _ref3;
     model.keysDown[key] = false;
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Focus API - modeHandle follow mouse when widget has focus
   // --------------------------------------------------------------------------
 
-
-  publicAPI.grabFocus = function () {
+  publicAPI.grabFocus = () => {
     if (!model.hasFocus) {
       model.activeState = model.moveHandle;
       model.activeState.activate();
       model.activeState.setVisible(true);
-
       model._interactor.requestAnimation(publicAPI);
-
       updateHandlesSize();
     }
-
     model.hasFocus = true;
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.loseFocus = function () {
+  publicAPI.loseFocus = () => {
     if (model.hasFocus) {
       model._interactor.cancelAnimation(publicAPI);
     }
-
     model.widgetState.deactivate();
     model.moveHandle.deactivate();
     model.moveHandle.setVisible(false);
     model.activeState = null;
-
     model._interactor.render();
-
     model.hasFocus = false;
   };
 }

package/Widgets/Widgets3D/SplineWidget.js

@@ -1,5 +1,4 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
 import vtkSplineContextRepresentation from '../Representations/SplineContextRepresentation.js';
@@ -8,21 +7,20 @@ import widgetBehavior from './SplineWidget/behavior.js';
 import generateState from './SplineWidget/state.js';
 import { ViewTypes } from '../Core/WidgetManager/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; }
-
-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; }
+// ----------------------------------------------------------------------------
 // Factory
 // ----------------------------------------------------------------------------
 
 function vtkSplineWidget(publicAPI, model) {
   model.classHierarchy.push('vtkSplineWidget');
+  const superClass = {
+    ...publicAPI
+  };
 
-  var superClass = _objectSpread({}, publicAPI); // --- Widget Requirement ---------------------------------------------------
-
+  // --- Widget Requirement ---------------------------------------------------
 
   model.methodsToLink = ['boundaryCondition', 'close', 'outputBorder', 'fill', 'borderColor', 'errorBorderColor', 'scaleInPixels'];
-
-  publicAPI.getRepresentationsForViewType = function (viewType) {
+  publicAPI.getRepresentationsForViewType = viewType => {
     switch (viewType) {
       case ViewTypes.DEFAULT:
       case ViewTypes.GEOMETRY:
@@ -37,57 +35,63 @@ function vtkSplineWidget(publicAPI, model) {
           labels: ['handles', 'moveHandle']
         }];
     }
-  }; // --- Public methods -------------------------------------------------------
-
+  };
 
-  publicAPI.setManipulator = function (manipulator) {
+  // --- Public methods -------------------------------------------------------
+  publicAPI.setManipulator = manipulator => {
     superClass.setManipulator(manipulator);
     model.widgetState.getMoveHandle().setManipulator(manipulator);
-    model.widgetState.getHandleList().forEach(function (handle) {
+    model.widgetState.getHandleList().forEach(handle => {
       handle.setManipulator(manipulator);
     });
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // initialization
   // --------------------------------------------------------------------------
-  // Default manipulator
-
 
+  // Default manipulator
   publicAPI.setManipulator(model.manipulator || model.manipulator || vtkPlanePointManipulator.newInstance({
     useCameraNormal: true
   }));
-} // ----------------------------------------------------------------------------
-
-
-var defaultValues = function defaultValues(initialValues) {
-  return _objectSpread({
-    // manipulator: null,
-    freehandMinDistance: 0.1,
-    allowFreehand: true,
-    resolution: 32,
-    // propagates to SplineContextRepresentation
-    defaultCursor: 'pointer',
-    handleSizeInPixels: 10,
-    // propagates to SplineContextRepresentation
-    resetAfterPointPlacement: false,
-    behavior: widgetBehavior,
-    widgetState: generateState()
-  }, initialValues);
-}; // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
+const defaultValues = initialValues => ({
+  // manipulator: null,
+  freehandMinDistance: 0.1,
+  allowFreehand: true,
+  resolution: 32,
+  // propagates to SplineContextRepresentation
+  defaultCursor: 'pointer',
+  handleSizeInPixels: 10,
+  // propagates to SplineContextRepresentation
+  resetAfterPointPlacement: false,
+  behavior: widgetBehavior,
+  widgetState: generateState(),
+  ...initialValues
+});
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, defaultValues(initialValues));
   vtkAbstractWidgetFactory.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['manipulator', 'freehandMinDistance', 'allowFreehand', 'resolution', 'defaultCursor', 'handleSizeInPixels', 'resetAfterPointPlacement']);
   vtkSplineWidget(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkSplineWidget'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkSplineWidget');
+
+// ----------------------------------------------------------------------------
 
 var vtkSplineWidget$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkSplineWidget$1 as default, extend, newInstance };

package/Widgets/Widgets3D.js

@@ -15,21 +15,21 @@ import vtkSphereWidget from './Widgets3D/SphereWidget.js';
 import vtkSplineWidget from './Widgets3D/SplineWidget.js';
 
 var Widgets3D = {
-  vtkAngleWidget: vtkAngleWidget,
-  vtkDistanceWidget: vtkDistanceWidget,
-  vtkEllipseWidget: vtkEllipseWidget,
-  vtkImageCroppingWidget: vtkImageCroppingWidget,
-  vtkImplicitPlaneWidget: vtkImplicitPlaneWidget,
-  vtkInteractiveOrientationWidget: vtkInteractiveOrientationWidget,
-  vtkLabelWidget: vtkLabelWidget,
-  vtkLineWidget: vtkLineWidget,
-  vtkPaintWidget: vtkPaintWidget,
-  vtkPolyLineWidget: vtkPolyLineWidget,
-  vtkRectangleWidget: vtkRectangleWidget,
-  vtkResliceCursorWidget: vtkResliceCursorWidget,
-  vtkShapeWidget: vtkShapeWidget,
-  vtkSphereWidget: vtkSphereWidget,
-  vtkSplineWidget: vtkSplineWidget
+  vtkAngleWidget,
+  vtkDistanceWidget,
+  vtkEllipseWidget,
+  vtkImageCroppingWidget,
+  vtkImplicitPlaneWidget,
+  vtkInteractiveOrientationWidget,
+  vtkLabelWidget,
+  vtkLineWidget,
+  vtkPaintWidget,
+  vtkPolyLineWidget,
+  vtkRectangleWidget,
+  vtkResliceCursorWidget,
+  vtkShapeWidget,
+  vtkSphereWidget,
+  vtkSplineWidget
 };
 
 export { Widgets3D as default };

package/Widgets/index.js

@@ -4,10 +4,10 @@ import Representations from './Representations.js';
 import Widgets3D from './Widgets3D.js';
 
 var Widgets = {
-  Core: Core,
-  Manipulators: Manipulators,
-  Representations: Representations,
-  Widgets3D: Widgets3D
+  Core,
+  Manipulators,
+  Representations,
+  Widgets3D
 };
 
 export { Widgets as default };