@kitware/vtk.js 28.10.2 → 28.11.0

package/Interaction/Manipulators/MouseBoxSelectorManipulator.js

@@ -1,13 +1,8 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-import { newInstance as newInstance$1, obj, event, setGet } from '../../macros.js';
+import { n as newInstance$1, o as obj, f as event, e as setGet } from '../../macros2.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.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; }
-var OUTSIDE_BOUNDS = [-2, -1, -2, -1];
-var DEFAULT_STYLE = {
+const OUTSIDE_BOUNDS = [-2, -1, -2, -1];
+const DEFAULT_STYLE = {
   position: 'absolute',
   zIndex: 1,
   border: '2px solid #F44336',
@@ -15,182 +10,168 @@ var DEFAULT_STYLE = {
   borderRadius: '4px',
   boxSizing: 'border-box'
 };
-
 function applyStyle(element, style) {
-  Object.keys(style).forEach(function (name) {
+  Object.keys(style).forEach(name => {
     element.style[name] = style[name];
   });
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // vtkMouseBoxSelectionManipulator methods
 // ----------------------------------------------------------------------------
 
-
 function vtkMouseBoxSelectionManipulator(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkMouseBoxSelectionManipulator'); // Private variable
-
-  var view = null;
-  var container = null;
-  var previousPosition = null;
-  var currentPosition = null;
-  var div = null;
-  var inDOM = false;
-
+  model.classHierarchy.push('vtkMouseBoxSelectionManipulator');
+
+  // Private variable
+  let view = null;
+  let container = null;
+  let previousPosition = null;
+  let currentPosition = null;
+  let div = null;
+  let inDOM = false;
   function getBounds() {
     if (!previousPosition || !currentPosition) {
       return OUTSIDE_BOUNDS;
     }
-
     return [Math.min(previousPosition.x, currentPosition.x), Math.max(previousPosition.x, currentPosition.x), Math.min(previousPosition.y, currentPosition.y), Math.max(previousPosition.y, currentPosition.y)];
   }
-
   function applyStyleToDiv() {
     if (!view || !container) {
       return;
     }
+    const [viewWidth, viewHeight] = view.getSize();
+    const {
+      width,
+      height
+    } = container.getBoundingClientRect();
+    const [xMin, xMax, yMin, yMax] = getBounds();
+    div.style.left = `${width * xMin / viewWidth}px`;
+    div.style.top = `${height - height * yMax / viewHeight}px`;
+    div.style.width = `${width * (xMax - xMin) / viewWidth}px`;
+    div.style.height = `${height * (yMax - yMin) / viewHeight}px`;
+  }
 
-    var _view$getSize = view.getSize(),
-        _view$getSize2 = _slicedToArray(_view$getSize, 2),
-        viewWidth = _view$getSize2[0],
-        viewHeight = _view$getSize2[1];
-
-    var _container$getBoundin = container.getBoundingClientRect(),
-        width = _container$getBoundin.width,
-        height = _container$getBoundin.height;
-
-    var _getBounds = getBounds(),
-        _getBounds2 = _slicedToArray(_getBounds, 4),
-        xMin = _getBounds2[0],
-        xMax = _getBounds2[1],
-        yMin = _getBounds2[2],
-        yMax = _getBounds2[3];
-
-    div.style.left = "".concat(width * xMin / viewWidth, "px");
-    div.style.top = "".concat(height - height * yMax / viewHeight, "px");
-    div.style.width = "".concat(width * (xMax - xMin) / viewWidth, "px");
-    div.style.height = "".concat(height * (yMax - yMin) / viewHeight, "px");
-  } //-------------------------------------------------------------------------
-
+  //-------------------------------------------------------------------------
 
-  publicAPI.onButtonDown = function (interactor, renderer, position) {
+  publicAPI.onButtonDown = (interactor, renderer, position) => {
     previousPosition = position;
-
     if (model.renderSelection) {
-      var _view;
-
       // Need window size and location to convert to style
       if (!view) {
         view = interactor.getView();
       }
-
-      if (!container && (_view = view) !== null && _view !== void 0 && _view.getContainer) {
+      if (!container && view?.getContainer) {
         container = view.getContainer();
       }
-
       if (!container) {
         container = model.container;
       }
-
       if (!div) {
         div = document.createElement('div');
         applyStyle(div, model.selectionStyle);
       }
-
       applyStyleToDiv();
-
       if (container && !inDOM) {
         inDOM = true;
         container.appendChild(div);
       }
     }
-  }; //-------------------------------------------------------------------------
+  };
 
+  //-------------------------------------------------------------------------
 
-  publicAPI.onMouseMove = function (interactor, renderer, position) {
+  publicAPI.onMouseMove = (interactor, renderer, position) => {
     if (!previousPosition) {
       return;
     }
-
     if (!position) {
       return;
     }
-
     currentPosition = position;
     publicAPI.invokeBoxSelectInput({
-      view: view,
-      container: container,
+      view,
+      container,
       selection: getBounds()
     });
-
     if (model.renderSelection) {
       applyStyleToDiv();
     }
-  }; //-------------------------------------------------------------------------
+  };
 
+  //-------------------------------------------------------------------------
 
-  publicAPI.onButtonUp = function (interactor, renderer) {
+  publicAPI.onButtonUp = (interactor, renderer) => {
     if (!previousPosition || !currentPosition && !model.boxChangeOnClick) {
       return;
-    } // needed because of boxChangeOnClick
-
+    }
 
+    // needed because of boxChangeOnClick
     if (!currentPosition) {
       currentPosition = previousPosition;
     }
-
     publicAPI.invokeBoxSelectChange({
-      view: view,
-      container: container,
+      view,
+      container,
       selection: getBounds()
     });
-
     if (inDOM) {
       div.parentElement.removeChild(div);
       inDOM = false;
-    } // clear positions
-
+    }
 
+    // clear positions
     view = null;
     container = null;
     previousPosition = null;
     currentPosition = null;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
 function DEFAULT_VALUES(initialValues) {
-  return _objectSpread(_objectSpread({
+  return {
     // container: null,
     boxChangeOnClick: false,
-    renderSelection: true
-  }, initialValues), {}, {
-    selectionStyle: _objectSpread(_objectSpread({}, DEFAULT_STYLE), initialValues.selectionStyle)
-  });
-} // ----------------------------------------------------------------------------
+    renderSelection: true,
+    ...initialValues,
+    selectionStyle: {
+      ...DEFAULT_STYLE,
+      ...initialValues.selectionStyle
+    }
+  };
+}
 
+// ----------------------------------------------------------------------------
 
 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
   obj(publicAPI, model);
   vtkCompositeMouseManipulator.extend(publicAPI, model, initialValues);
   event(publicAPI, model, 'BoxSelectChange'); // Trigger at release
-
   event(publicAPI, model, 'BoxSelectInput'); // Trigger while dragging
+  setGet(publicAPI, model, ['renderSelection', 'boxChangeOnClick', 'selectionStyle', 'container']);
 
-  setGet(publicAPI, model, ['renderSelection', 'boxChangeOnClick', 'selectionStyle', 'container']); // Object specific methods
-
+  // Object specific methods
   vtkMouseBoxSelectionManipulator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = newInstance$1(extend, 'vtkMouseBoxSelectionManipulator'); // ----------------------------------------------------------------------------
+const newInstance = newInstance$1(extend, 'vtkMouseBoxSelectionManipulator');
+
+// ----------------------------------------------------------------------------
 
 var vtkMouseBoxSelectorManipulator = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkMouseBoxSelectorManipulator as default, extend, newInstance };

package/Interaction/Manipulators/MouseCameraAxisRotateManipulator.js

@@ -1,80 +1,86 @@
 import { vec3, mat4 } from 'gl-matrix';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkCompositeCameraManipulator from './CompositeCameraManipulator.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
 import { r as radiansFromDegrees, j as cross } from '../../Common/Core/Math/index.js';
 
+// ----------------------------------------------------------------------------
 // vtkMouseCameraAxisRotateManipulator methods
 // ----------------------------------------------------------------------------
 
 function vtkMouseCameraAxisRotateManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkMouseCameraAxisRotateManipulator');
-  var negCameraDir = new Float64Array(3);
-  var newCamPos = new Float64Array(3);
-  var newFp = new Float64Array(3);
-  var newViewUp = new Float64Array(3);
-  var trans = new Float64Array(16);
-  var rotation = new Float64Array(16);
-  var v2 = new Float64Array(3);
-  var centerNeg = new Float64Array(3);
-  var negRotationAxis = new Float64Array(3);
-
-  publicAPI.onButtonDown = function (interactor, renderer, position) {
+  const negCameraDir = new Float64Array(3);
+  const newCamPos = new Float64Array(3);
+  const newFp = new Float64Array(3);
+  const newViewUp = new Float64Array(3);
+  const trans = new Float64Array(16);
+  const rotation = new Float64Array(16);
+  const v2 = new Float64Array(3);
+  const centerNeg = new Float64Array(3);
+  const negRotationAxis = new Float64Array(3);
+  publicAPI.onButtonDown = (interactor, renderer, position) => {
     model.previousPosition = position;
   };
-
-  publicAPI.onMouseMove = function (interactor, renderer, position) {
+  publicAPI.onMouseMove = (interactor, renderer, position) => {
     if (!position) {
       return;
     }
-
-    var camera = renderer.getActiveCamera();
-    var cameraPos = camera.getPosition();
-    var cameraFp = camera.getFocalPoint();
-    var cameraViewUp = camera.getViewUp();
-    var cameraDirection = camera.getDirectionOfProjection();
+    const camera = renderer.getActiveCamera();
+    const cameraPos = camera.getPosition();
+    const cameraFp = camera.getFocalPoint();
+    const cameraViewUp = camera.getViewUp();
+    const cameraDirection = camera.getDirectionOfProjection();
     vec3.negate(negCameraDir, cameraDirection);
     mat4.identity(trans);
     mat4.identity(rotation);
-    var center = model.center,
-        rotationFactor = model.rotationFactor,
-        rotationAxis = model.rotationAxis;
+    const {
+      center,
+      rotationFactor,
+      rotationAxis
+    } = model;
     vec3.negate(negRotationAxis, rotationAxis);
-    var dx = model.previousPosition.x - position.x;
-    var dy = model.previousPosition.y - position.y;
-    var size = interactor.getView().getViewportSize(renderer); // Azimuth
+    const dx = model.previousPosition.x - position.x;
+    const dy = model.previousPosition.y - position.y;
+    const size = interactor.getView().getViewportSize(renderer);
 
-    var azimuthDelta = radiansFromDegrees(360.0 * dx / size[0] * rotationFactor);
-    mat4.rotate(rotation, rotation, azimuthDelta, rotationAxis); // Elevation
+    // Azimuth
+    const azimuthDelta = radiansFromDegrees(360.0 * dx / size[0] * rotationFactor);
+    mat4.rotate(rotation, rotation, azimuthDelta, rotationAxis);
 
+    // Elevation
     cross(cameraDirection, cameraViewUp, v2);
-    var elevationDelta = radiansFromDegrees(-360.0 * dy / size[1] * rotationFactor); // angle of camera to rotation axis on the positive or negative half,
+    let elevationDelta = radiansFromDegrees(-360.0 * dy / size[1] * rotationFactor);
+    // angle of camera to rotation axis on the positive or negative half,
     // relative to the origin.
+    const angleToPosHalf = Math.acos(vec3.dot(negCameraDir, rotationAxis));
+    const angleToNegHalf = Math.acos(vec3.dot(negCameraDir, negRotationAxis));
 
-    var angleToPosHalf = Math.acos(vec3.dot(negCameraDir, rotationAxis));
-    var angleToNegHalf = Math.acos(vec3.dot(negCameraDir, negRotationAxis)); // whether camera is in positive half of the rotation axis or neg half
-
-    var inPosHalf = angleToPosHalf <= angleToNegHalf;
-    var elevationToAxis = Math.min(angleToPosHalf, angleToNegHalf);
-
+    // whether camera is in positive half of the rotation axis or neg half
+    const inPosHalf = angleToPosHalf <= angleToNegHalf;
+    const elevationToAxis = Math.min(angleToPosHalf, angleToNegHalf);
     if (model.useHalfAxis && !inPosHalf) {
       elevationDelta = Math.PI / 2 - angleToPosHalf;
     } else if (inPosHalf && elevationToAxis + elevationDelta < 0) {
-      elevationDelta = -elevationToAxis; // } else if (!inPosHalf && elevationToAxis - elevationDelta < 0) {
+      elevationDelta = -elevationToAxis;
+      // } else if (!inPosHalf && elevationToAxis - elevationDelta < 0) {
     } else if (!inPosHalf && angleToPosHalf + elevationDelta > Math.PI) {
       elevationDelta = elevationToAxis;
     }
+    mat4.rotate(rotation, rotation, elevationDelta, v2);
 
-    mat4.rotate(rotation, rotation, elevationDelta, v2); // Translate from origin
+    // Translate from origin
+    mat4.translate(trans, trans, center);
 
-    mat4.translate(trans, trans, center); // apply rotation
-
-    mat4.multiply(trans, trans, rotation); // Translate to origin
+    // apply rotation
+    mat4.multiply(trans, trans, rotation);
 
+    // Translate to origin
     vec3.negate(centerNeg, center);
-    mat4.translate(trans, trans, centerNeg); // Apply transformation to camera position, focal point, and view up
+    mat4.translate(trans, trans, centerNeg);
 
+    // Apply transformation to camera position, focal point, and view up
     vec3.transformMat4(newCamPos, cameraPos, trans);
     vec3.transformMat4(newFp, cameraFp, trans);
     vec3.transformMat4(newViewUp, cameraViewUp, rotation);
@@ -82,40 +88,47 @@ function vtkMouseCameraAxisRotateManipulator(publicAPI, model) {
     camera.setFocalPoint(newFp[0], newFp[1], newFp[2]);
     camera.setViewUp(newViewUp);
     renderer.resetCameraClippingRange();
-
     if (interactor.getLightFollowCamera()) {
       renderer.updateLightsGeometryToFollowCamera();
     }
-
     model.previousPosition = position;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   rotationAxis: [0, 0, 1],
   useHalfAxis: true
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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, ['rotationAxis', 'useHalfAxis']);
   vtkCompositeMouseManipulator.extend(publicAPI, model, initialValues);
-  vtkCompositeCameraManipulator.extend(publicAPI, model, initialValues); // Object specific methods
+  vtkCompositeCameraManipulator.extend(publicAPI, model, initialValues);
 
+  // Object specific methods
   vtkMouseCameraAxisRotateManipulator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkMouseCameraAxisRotateManipulator'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkMouseCameraAxisRotateManipulator');
+
+// ----------------------------------------------------------------------------
 
 var vtkMouseCameraAxisRotateManipulator$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkMouseCameraAxisRotateManipulator$1 as default, extend, newInstance };

package/Interaction/Manipulators/MouseCameraSliceManipulator.js

@@ -1,100 +1,102 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkCompositeCameraManipulator from './CompositeCameraManipulator.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
 import { r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
 
+// ----------------------------------------------------------------------------
 // vtkMouseCameraSliceManipulator methods
 // ----------------------------------------------------------------------------
 
 function vtkMouseCameraSliceManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkMouseCameraSliceManipulator');
-
-  publicAPI.onButtonDown = function (interactor, renderer, position) {
+  publicAPI.onButtonDown = (interactor, renderer, position) => {
     model.previousPosition = position;
   };
-
-  publicAPI.onMouseMove = function (interactor, renderer, position) {
+  publicAPI.onMouseMove = (interactor, renderer, position) => {
     if (!position) {
       return;
     }
+    const dy = position.y - model.previousPosition.y;
+    const camera = renderer.getActiveCamera();
+    const range = camera.getClippingRange();
+    let distance = camera.getDistance();
 
-    var dy = position.y - model.previousPosition.y;
-    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;
-
+    // 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 = interactor.getView().getViewportSize(renderer);
+    const delta = dy * viewportHeight / size[1];
+    distance += delta;
 
-    var size = interactor.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.previousPosition = position;
   };
-
-  publicAPI.onScroll = function (interactor, renderer, delta) {
+  publicAPI.onScroll = (interactor, renderer, delta) => {
     if (!delta) {
       return;
     }
-
-    var scrollDelta = 1.0 - delta;
+    let scrollDelta = 1.0 - delta;
     scrollDelta *= 25; // TODO: expose factor?
 
-    var camera = renderer.getActiveCamera();
-    var range = camera.getClippingRange();
-    var distance = camera.getDistance();
-    distance += scrollDelta; // clamp the distance to the clipping range
+    const camera = renderer.getActiveCamera();
+    const range = camera.getClippingRange();
+    let distance = camera.getDistance();
+    distance += scrollDelta;
 
+    // clamp the distance to the clipping range
     if (distance < range[0]) {
       distance = range[0];
     }
-
     if (distance > range[1]) {
       distance = range[1];
     }
-
     camera.setDistance(distance);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // 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); // Inheritance
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Inheritance
   macro.obj(publicAPI, model);
   vtkCompositeCameraManipulator.extend(publicAPI, model, initialValues);
-  vtkCompositeMouseManipulator.extend(publicAPI, model, initialValues); // Object specific methods
+  vtkCompositeMouseManipulator.extend(publicAPI, model, initialValues);
 
+  // Object specific methods
   vtkMouseCameraSliceManipulator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkMouseCameraSliceManipulator'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkMouseCameraSliceManipulator');
+
+// ----------------------------------------------------------------------------
 
 var vtkMouseCameraSliceManipulator$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkMouseCameraSliceManipulator$1 as default, extend, newInstance };