@kitware/vtk.js 28.10.2 → 28.11.0

package/Interaction/Misc/DeviceOrientationToCamera.js

@@ -1,111 +1,89 @@
-var listeners = [];
-var orientation = {
+const listeners = [];
+const orientation = {
   device: {},
   screen: window.orientation || 0,
   supported: !!window.DeviceMotionEvent,
   update: false
 };
-var SCREEN_ORIENTATION_MAP = {
+const SCREEN_ORIENTATION_MAP = {
   'landscape-primary': 90,
   'landscape-secondary': -90,
   'portrait-secondary': 180,
   'portrait-primary': 0
 };
-
 function isEventValid(evt) {
   return Number.isFinite(evt.alpha);
 }
-
 function onDeviceOrientationChangeEvent(evt) {
   orientation.device = evt;
-
   if (!Number.isFinite(evt.alpha)) {
     orientation.supported = false;
   }
 }
-
 function onScreenOrientationChangeEvent() {
   orientation.screen = SCREEN_ORIENTATION_MAP[window.screen.orientation || window.screen.mozOrientation] || window.orientation || 0;
 }
-
 function addWindowListeners() {
   window.addEventListener('orientationchange', onScreenOrientationChangeEvent, false);
   window.addEventListener('deviceorientation', onDeviceOrientationChangeEvent, false);
   orientation.update = true;
-  listeners.filter(function (i) {
-    return !!i;
-  }).forEach(function (i) {
-    return i.renderWindowInteractor.requestAnimation(i);
-  });
+  listeners.filter(i => !!i).forEach(i => i.renderWindowInteractor.requestAnimation(i));
 }
-
 function removeWindowListeners() {
   window.removeEventListener('orientationchange', onScreenOrientationChangeEvent, false);
   window.removeEventListener('deviceorientation', onDeviceOrientationChangeEvent, false);
   orientation.update = false;
-  listeners.filter(function (i) {
-    return !!i;
-  }).forEach(function (i) {
-    return i.renderWindowInteractor.cancelAnimation(i);
-  });
+  listeners.filter(i => !!i).forEach(i => i.renderWindowInteractor.cancelAnimation(i));
 }
-
 function addCameraToSynchronize(renderWindowInteractor, camera, onCameraUpdate) {
   function onAnimation() {
     if (orientation.update && isEventValid(orientation.device)) {
-      var _orientation$device = orientation.device,
-          alpha = _orientation$device.alpha,
-          beta = _orientation$device.beta,
-          gamma = _orientation$device.gamma;
-      var screen = orientation.screen;
+      const {
+        alpha,
+        beta,
+        gamma
+      } = orientation.device;
+      const {
+        screen
+      } = orientation;
       camera.setDeviceAngles(alpha, beta, gamma, screen);
-
       if (onCameraUpdate) {
         onCameraUpdate();
       }
     }
   }
-
-  var subscription = renderWindowInteractor.onAnimation(onAnimation);
-  var listener = {
-    subscription: subscription,
-    renderWindowInteractor: renderWindowInteractor
+  const subscription = renderWindowInteractor.onAnimation(onAnimation);
+  const listener = {
+    subscription,
+    renderWindowInteractor
   };
-  var listenerId = listeners.length;
+  const listenerId = listeners.length;
   listeners.push(listener);
-
   if (orientation.update) {
     listener.renderWindowInteractor.requestAnimation(listener);
   }
-
   return listenerId;
 }
-
 function removeCameraToSynchronize(id) {
-  var cancelAnimation = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-  var listener = listeners[id];
-
+  let cancelAnimation = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  const listener = listeners[id];
   if (listener) {
     listener.subscription.unsubscribe();
-
     if (cancelAnimation) {
       listener.renderWindowInteractor.cancelAnimation(listener);
     }
   }
-
   listeners[id] = null;
 }
-
 function isDeviceOrientationSupported() {
   return orientation.supported;
 }
-
 var vtkDeviceOrientationToCamera = {
-  addCameraToSynchronize: addCameraToSynchronize,
-  addWindowListeners: addWindowListeners,
-  isDeviceOrientationSupported: isDeviceOrientationSupported,
-  removeCameraToSynchronize: removeCameraToSynchronize,
-  removeWindowListeners: removeWindowListeners
+  addCameraToSynchronize,
+  addWindowListeners,
+  isDeviceOrientationSupported,
+  removeCameraToSynchronize,
+  removeWindowListeners
 };
 
 export { vtkDeviceOrientationToCamera as default };

package/Interaction/Misc.js

@@ -1,7 +1,7 @@
 import vtkDeviceOrientationToCamera from './Misc/DeviceOrientationToCamera.js';
 
 var Misc = {
-  vtkDeviceOrientationToCamera: vtkDeviceOrientationToCamera
+  vtkDeviceOrientationToCamera
 };
 
 export { Misc as default };

package/Interaction/Style/InteractorStyleImage.js

@@ -1,21 +1,21 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkInteractorStyleTrackballCamera from './InteractorStyleTrackballCamera.js';
 import { r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
 import { States } from '../../Rendering/Core/InteractorStyle/Constants.js';
 
+// ----------------------------------------------------------------------------
 // vtkInteractorStyleImage methods
 // ----------------------------------------------------------------------------
 
 function vtkInteractorStyleImage(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkInteractorStyleImage'); // Public API methods
+  model.classHierarchy.push('vtkInteractorStyleImage');
 
+  // Public API methods
   publicAPI.superHandleMouseMove = publicAPI.handleMouseMove;
-
-  publicAPI.handleMouseMove = function (callData) {
-    var pos = callData.position;
-    var renderer = callData.pokedRenderer;
-
+  publicAPI.handleMouseMove = callData => {
+    const pos = callData.position;
+    const renderer = callData.pokedRenderer;
     switch (model.state) {
       case States.IS_WINDOW_LEVEL:
         publicAPI.windowLevel(renderer, pos);
@@ -23,7 +23,6 @@ function vtkInteractorStyleImage(publicAPI, model) {
           type: 'InteractionEvent'
         });
         break;
-
       case States.IS_SLICE:
         publicAPI.slice(renderer, pos);
         publicAPI.invokeInteractionEvent({
@@ -31,28 +30,23 @@ function vtkInteractorStyleImage(publicAPI, model) {
         });
         break;
     }
-
     publicAPI.superHandleMouseMove(callData);
-  }; //----------------------------------------------------------------------------
-
+  };
 
+  //----------------------------------------------------------------------------
   publicAPI.superHandleLeftButtonPress = publicAPI.handleLeftButtonPress;
-
-  publicAPI.handleLeftButtonPress = function (callData) {
-    var pos = callData.position;
-
+  publicAPI.handleLeftButtonPress = callData => {
+    const pos = callData.position;
     if (!callData.shiftKey && !callData.controlKey) {
       model.windowLevelStartPosition[0] = pos.x;
-      model.windowLevelStartPosition[1] = pos.y; // Get the last (the topmost) image
-
+      model.windowLevelStartPosition[1] = pos.y;
+      // Get the last (the topmost) image
       publicAPI.setCurrentImageNumber(model.currentImageNumber);
-      var property = model.currentImageProperty;
-
+      const property = model.currentImageProperty;
       if (property) {
         model.windowLevelInitial[0] = property.getColorWindow();
         model.windowLevelInitial[1] = property.getColorLevel();
       }
-
       publicAPI.startWindowLevel();
     } else if (model.interactionMode === 'IMAGE3D' && callData.shiftKey) {
       // If ctrl+shift or alt+shift is held down, dolly the camera
@@ -70,61 +64,53 @@ function vtkInteractorStyleImage(publicAPI, model) {
       // The rest of the button + key combinations remain the same
       publicAPI.superHandleLeftButtonPress(callData);
     }
-  }; //--------------------------------------------------------------------------
-
+  };
 
+  //--------------------------------------------------------------------------
   publicAPI.superHandleLeftButtonRelease = publicAPI.handleLeftButtonRelease;
-
-  publicAPI.handleLeftButtonRelease = function () {
+  publicAPI.handleLeftButtonRelease = () => {
     switch (model.state) {
       case States.IS_WINDOW_LEVEL:
         publicAPI.endWindowLevel();
         break;
-
       case States.IS_SLICE:
         publicAPI.endSlice();
         break;
-
       default:
         publicAPI.superHandleLeftButtonRelease();
         break;
     }
-  }; //--------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleStartMouseWheel = function () {
+  //--------------------------------------------------------------------------
+  publicAPI.handleStartMouseWheel = () => {
     publicAPI.startSlice();
-  }; //--------------------------------------------------------------------------
-
+  };
 
-  publicAPI.handleEndMouseWheel = function () {
+  //--------------------------------------------------------------------------
+  publicAPI.handleEndMouseWheel = () => {
     publicAPI.endSlice();
-  }; //--------------------------------------------------------------------------
-
-
-  publicAPI.handleMouseWheel = function (callData) {
-    var camera = callData.pokedRenderer.getActiveCamera();
-    var distance = camera.getDistance();
-    distance += callData.spinY; // clamp the distance to the clipping range
+  };
 
-    var range = camera.getClippingRange();
+  //--------------------------------------------------------------------------
+  publicAPI.handleMouseWheel = callData => {
+    const camera = callData.pokedRenderer.getActiveCamera();
+    let distance = camera.getDistance();
+    distance += callData.spinY;
 
+    // clamp the distance to the clipping range
+    const range = camera.getClippingRange();
     if (distance < range[0]) {
       distance = range[0];
     }
-
     if (distance > range[1]) {
       distance = range[1];
     }
-
     camera.setDistance(distance);
-    var props = callData.pokedRenderer.getViewProps().filter(function (prop) {
-      return prop.isA('vtkImageSlice');
-    });
-    props.forEach(function (prop) {
+    const props = callData.pokedRenderer.getViewProps().filter(prop => prop.isA('vtkImageSlice'));
+    props.forEach(prop => {
       if (prop.getMapper().isA('vtkImageResliceMapper')) {
-        var p = prop.getMapper().getSlicePlane();
-
+        const p = prop.getMapper().getSlicePlane();
         if (p) {
           p.push(callData.spinY);
           p.modified();
@@ -132,140 +118,124 @@ function vtkInteractorStyleImage(publicAPI, model) {
         }
       }
     });
-  }; //----------------------------------------------------------------------------
-
+  };
 
-  publicAPI.windowLevel = function (renderer, position) {
+  //----------------------------------------------------------------------------
+  publicAPI.windowLevel = (renderer, position) => {
     model.windowLevelCurrentPosition[0] = position.x;
     model.windowLevelCurrentPosition[1] = position.y;
-    var rwi = model._interactor;
-
+    const rwi = model._interactor;
     if (model.currentImageProperty) {
-      var size = rwi.getView().getViewportSize(renderer);
-      var mWindow = model.windowLevelInitial[0];
-      var level = model.windowLevelInitial[1]; // Compute normalized delta
+      const size = rwi.getView().getViewportSize(renderer);
+      const mWindow = model.windowLevelInitial[0];
+      const level = model.windowLevelInitial[1];
 
-      var dx = (model.windowLevelCurrentPosition[0] - model.windowLevelStartPosition[0]) * 4.0 / size[0];
-      var dy = (model.windowLevelStartPosition[1] - model.windowLevelCurrentPosition[1]) * 4.0 / size[1]; // Scale by current values
+      // Compute normalized delta
+      let dx = (model.windowLevelCurrentPosition[0] - model.windowLevelStartPosition[0]) * 4.0 / size[0];
+      let dy = (model.windowLevelStartPosition[1] - model.windowLevelCurrentPosition[1]) * 4.0 / size[1];
 
+      // Scale by current values
       if (Math.abs(mWindow) > 0.01) {
         dx *= mWindow;
       } else {
         dx *= mWindow < 0 ? -0.01 : 0.01;
       }
-
       if (Math.abs(level) > 0.01) {
         dy *= level;
       } else {
         dy *= level < 0 ? -0.01 : 0.01;
-      } // Abs so that direction does not flip
-
+      }
 
+      // Abs so that direction does not flip
       if (mWindow < 0.0) {
         dx *= -1;
       }
-
       if (level < 0.0) {
         dy *= -1;
-      } // Compute new mWindow level
-
-
-      var newWindow = dx + mWindow;
-      var newLevel = level - dy;
+      }
 
+      // Compute new mWindow level
+      let newWindow = dx + mWindow;
+      const newLevel = level - dy;
       if (newWindow < 0.01) {
         newWindow = 0.01;
       }
-
       model.currentImageProperty.setColorWindow(newWindow);
       model.currentImageProperty.setColorLevel(newLevel);
     }
-  }; //----------------------------------------------------------------------------
-
-
-  publicAPI.slice = function (renderer, position) {
-    var rwi = model._interactor;
-    var dy = position.y - model.lastSlicePosition;
-    var camera = renderer.getActiveCamera();
-    var range = camera.getClippingRange();
-    var distance = camera.getDistance(); // scale the interaction by the height of the viewport
+  };
 
-    var viewportHeight = 0.0;
+  //----------------------------------------------------------------------------
+  publicAPI.slice = (renderer, position) => {
+    const rwi = model._interactor;
+    const dy = position.y - model.lastSlicePosition;
+    const camera = renderer.getActiveCamera();
+    const range = camera.getClippingRange();
+    let distance = camera.getDistance();
 
+    // scale the interaction by the height of the viewport
+    let viewportHeight = 0.0;
     if (camera.getParallelProjection()) {
       viewportHeight = 2.0 * camera.getParallelScale();
     } else {
-      var angle = radiansFromDegrees(camera.getViewAngle());
+      const angle = radiansFromDegrees(camera.getViewAngle());
       viewportHeight = 2.0 * distance * Math.tan(0.5 * angle);
     }
+    const size = rwi.getView().getViewportSize(renderer);
+    const delta = dy * viewportHeight / size[1];
+    distance += delta;
 
-    var size = rwi.getView().getViewportSize(renderer);
-    var delta = dy * viewportHeight / size[1];
-    distance += delta; // clamp the distance to the clipping range
-
+    // clamp the distance to the clipping range
     if (distance < range[0]) {
       distance = range[0] + viewportHeight * 1e-3;
     }
-
     if (distance > range[1]) {
       distance = range[1] - viewportHeight * 1e-3;
     }
-
     camera.setDistance(distance);
     model.lastSlicePosition = position.y;
-  }; //----------------------------------------------------------------------------
+  };
+
+  //----------------------------------------------------------------------------
   // This is a way of dealing with images as if they were layers.
   // It looks through the renderer's list of props and sets the
   // interactor ivars from the Nth image that it finds.  You can
   // also use negative numbers, i.e. -1 will return the last image,
   // -2 will return the second-to-last image, etc.
-
-
-  publicAPI.setCurrentImageNumber = function (i) {
+  publicAPI.setCurrentImageNumber = i => {
     if (i === null) {
       return;
     }
-
-    var renderer = model._interactor.getCurrentRenderer();
-
+    const renderer = model._interactor.getCurrentRenderer();
     if (!renderer) {
       return;
     }
-
     model.currentImageNumber = i;
-
     function propMatch(j, prop, targetIndex) {
       return j === targetIndex && prop.getNestedPickable();
     }
-
-    var props = renderer.getViewProps().filter(function (prop) {
-      return prop.isA('vtkImageSlice');
-    });
-    var targetIndex = i;
-
+    const props = renderer.getViewProps().filter(prop => prop.isA('vtkImageSlice'));
+    let targetIndex = i;
     if (i < 0) {
       targetIndex += props.length;
     }
-
-    var imageProp = props.find(function (prop, index) {
-      return propMatch(index, prop, targetIndex);
-    });
-
+    const imageProp = props.find((prop, index) => propMatch(index, prop, targetIndex));
     if (imageProp) {
       publicAPI.setCurrentImageProperty(imageProp.getProperty());
     }
-  }; //----------------------------------------------------------------------------
-
+  };
 
-  publicAPI.setCurrentImageProperty = function (imageProperty) {
+  //----------------------------------------------------------------------------
+  publicAPI.setCurrentImageProperty = imageProperty => {
     model.currentImageProperty = imageProperty;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   windowLevelStartPosition: [0, 0],
   windowLevelCurrentPosition: [0, 0],
   lastSlicePosition: 0,
@@ -279,26 +249,36 @@ var DEFAULT_VALUES = {
   yViewUpVector: [0, 0, -1],
   zViewRightVector: [1, 0, 0],
   zViewUpVector: [0, 1, 0]
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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);
 
-  vtkInteractorStyleTrackballCamera.extend(publicAPI, model, initialValues); // Create get-set macros
+  // Inheritance
+  vtkInteractorStyleTrackballCamera.extend(publicAPI, model, initialValues);
 
+  // Create get-set macros
   macro.setGet(publicAPI, model, ['interactionMode']);
-  macro.get(publicAPI, model, ['currentImageProperty']); // For more macro methods, see "Sources/macros.js"
-  // Object specific methods
+  macro.get(publicAPI, model, ['currentImageProperty']);
 
+  // For more macro methods, see "Sources/macros.js"
+
+  // Object specific methods
   vtkInteractorStyleImage(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkInteractorStyleImage'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkInteractorStyleImage');
+
+// ----------------------------------------------------------------------------
 
 var vtkInteractorStyleImage$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkInteractorStyleImage$1 as default, extend, newInstance };