@kitware/vtk.js 28.10.2 → 28.11.0

package/Interaction/Widgets/OrientationMarkerWidget.js

@@ -1,113 +1,86 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkRenderer from '../../Rendering/Core/Renderer.js';
 import Constants from './OrientationMarkerWidget/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; }
+const {
+  vtkErrorMacro
+} = macro;
+const {
+  Corners
+} = Constants;
 
-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;
-var Corners = Constants.Corners; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkOrientationMarkerWidget
 // ----------------------------------------------------------------------------
 
 function vtkOrientationMarkerWidget(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkOrientationMarkerWidget');
+  const superClass = {
+    ...publicAPI
+  };
 
-  var superClass = _objectSpread({}, publicAPI); // Private variables
-
+  // Private variables
 
-  var previousCameraInput = [];
-  var selfRenderer = vtkRenderer.newInstance();
-  var resizeObserver = new ResizeObserver(function (entries) {
+  const previousCameraInput = [];
+  const selfRenderer = vtkRenderer.newInstance();
+  const resizeObserver = new ResizeObserver(entries => {
     publicAPI.updateViewport();
   });
-  var onCameraChangedSub = null;
-  var onCameraModifiedSub = null;
-  var onAnimationSub = null;
-  var onEndAnimationSub = null;
-  var selfSubscription = null;
-
+  let onCameraChangedSub = null;
+  let onCameraModifiedSub = null;
+  let onAnimationSub = null;
+  let onEndAnimationSub = null;
+  let selfSubscription = null;
   function onCameraModified() {
     // If animating, marker will be updated on Animation event
     if (!model._interactor.isAnimating()) {
       publicAPI.updateMarkerOrientation();
     }
   }
-
-  model._onParentRendererChanged = function () {
-    return publicAPI.updateViewport();
-  };
-
-  publicAPI.computeViewport = function () {
-    var parentRen = model.parentRenderer || model._interactor.getCurrentRenderer();
-
-    var _parentRen$getViewpor = parentRen.getViewport(),
-        _parentRen$getViewpor2 = _slicedToArray(_parentRen$getViewpor, 4),
-        xMin = _parentRen$getViewpor2[0],
-        yMin = _parentRen$getViewpor2[1],
-        xMax = _parentRen$getViewpor2[2],
-        yMax = _parentRen$getViewpor2[3];
-
-    var view = model._interactor.getView();
-
-    var canvasSize = view.getSize();
-
-    var _view$getViewportSize = view.getViewportSize(parentRen),
-        _view$getViewportSize2 = _slicedToArray(_view$getViewportSize, 2),
-        viewXSize = _view$getViewportSize2[0],
-        viewYSize = _view$getViewportSize2[1];
-
-    var minViewSize = Math.min(viewXSize, viewYSize);
-    var pixelSize = model.viewportSize * minViewSize; // clamp pixel size
-
+  model._onParentRendererChanged = () => publicAPI.updateViewport();
+  publicAPI.computeViewport = () => {
+    const parentRen = model.parentRenderer || model._interactor.getCurrentRenderer();
+    const [xMin, yMin, xMax, yMax] = parentRen.getViewport();
+    const view = model._interactor.getView();
+    const canvasSize = view.getSize();
+    const [viewXSize, viewYSize] = view.getViewportSize(parentRen);
+    const minViewSize = Math.min(viewXSize, viewYSize);
+    let pixelSize = model.viewportSize * minViewSize;
+    // clamp pixel size
     pixelSize = Math.max(Math.min(model.minPixelSize, minViewSize), Math.min(model.maxPixelSize, pixelSize));
-    var xFrac = pixelSize / canvasSize[0];
-    var yFrac = pixelSize / canvasSize[1]; // [left bottom right top]
-
+    const xFrac = pixelSize / canvasSize[0];
+    const yFrac = pixelSize / canvasSize[1];
+    // [left bottom right top]
     switch (model.viewportCorner) {
       case Corners.TOP_LEFT:
         return [xMin, yMax - yFrac, xMin + xFrac, yMax];
-
       case Corners.TOP_RIGHT:
         return [xMax - xFrac, yMax - yFrac, xMax, yMax];
-
       case Corners.BOTTOM_LEFT:
         return [xMin, yMin, xMin + xFrac, yMin + yFrac];
-
       case Corners.BOTTOM_RIGHT:
         return [xMax - xFrac, yMin, xMax, yMin + yFrac];
-
       default:
         vtkErrorMacro('Invalid widget corner');
         return null;
     }
   };
-
-  publicAPI.updateViewport = function () {
+  publicAPI.updateViewport = () => {
     if (model.enabled) {
-      selfRenderer.setViewport.apply(selfRenderer, _toConsumableArray(publicAPI.computeViewport()));
-
+      selfRenderer.setViewport(...publicAPI.computeViewport());
       model._interactor.render();
     }
   };
-
-  publicAPI.updateMarkerOrientation = function () {
-    var ren = model.parentRenderer || model._interactor.getCurrentRenderer();
-
-    var currentCamera = ren.getActiveCamera();
-
+  publicAPI.updateMarkerOrientation = () => {
+    const ren = model.parentRenderer || model._interactor.getCurrentRenderer();
+    const currentCamera = ren.getActiveCamera();
     if (!currentCamera) {
       return;
     }
-
-    var position = currentCamera.getReferenceByName('position');
-    var focalPoint = currentCamera.getReferenceByName('focalPoint');
-    var viewUp = currentCamera.getReferenceByName('viewUp');
-
+    const position = currentCamera.getReferenceByName('position');
+    const focalPoint = currentCamera.getReferenceByName('focalPoint');
+    const viewUp = currentCamera.getReferenceByName('viewUp');
     if (previousCameraInput[0] !== position[0] || previousCameraInput[1] !== position[1] || previousCameraInput[2] !== position[2] || previousCameraInput[3] !== focalPoint[0] || previousCameraInput[4] !== focalPoint[1] || previousCameraInput[5] !== focalPoint[2] || previousCameraInput[6] !== viewUp[0] || previousCameraInput[7] !== viewUp[1] || previousCameraInput[8] !== viewUp[2]) {
       previousCameraInput[0] = position[0];
       previousCameraInput[1] = position[1];
@@ -118,54 +91,46 @@ function vtkOrientationMarkerWidget(publicAPI, model) {
       previousCameraInput[6] = viewUp[0];
       previousCameraInput[7] = viewUp[1];
       previousCameraInput[8] = viewUp[2];
-      var activeCamera = selfRenderer.getActiveCamera();
+      const activeCamera = selfRenderer.getActiveCamera();
       activeCamera.setPosition(position[0], position[1], position[2]);
       activeCamera.setFocalPoint(focalPoint[0], focalPoint[1], focalPoint[2]);
       activeCamera.setViewUp(viewUp[0], viewUp[1], viewUp[2]);
       selfRenderer.resetCamera();
     }
   };
+
   /**
    * Enables/Disables the orientation marker.
    */
-
-
-  publicAPI.setEnabled = function (enabling) {
+  publicAPI.setEnabled = enabling => {
     if (enabling) {
       if (model.enabled) {
         return;
       }
-
       if (!model.actor) {
         vtkErrorMacro('Must set actor before enabling orientation marker.');
         return;
       }
-
       if (!model._interactor) {
         vtkErrorMacro('Must set interactor before enabling orientation marker.');
         return;
       }
-
-      var ren = model.parentRenderer || model._interactor.getCurrentRenderer();
-
-      var renderWindow = ren.getRenderWindow();
+      const ren = model.parentRenderer || model._interactor.getCurrentRenderer();
+      const renderWindow = ren.getRenderWindow();
       renderWindow.addRenderer(selfRenderer);
-
       if (renderWindow.getNumberOfLayers() < 2) {
         renderWindow.setNumberOfLayers(2);
-      } // Highest number is foreground
-
-
+      }
+      // Highest number is foreground
       selfRenderer.setLayer(renderWindow.getNumberOfLayers() - 1);
       selfRenderer.setInteractive(false);
       selfRenderer.addViewProp(model.actor);
       model.actor.setVisibility(true);
-      onCameraChangedSub = ren.onEvent(function (event) {
+      onCameraChangedSub = ren.onEvent(event => {
         if (event.type === 'ActiveCameraEvent') {
           if (onCameraModifiedSub) {
             onCameraModifiedSub.unsubscribe();
           }
-
           onCameraModifiedSub = event.camera.onModified(onCameraModified);
         }
       });
@@ -177,12 +142,9 @@ function vtkOrientationMarkerWidget(publicAPI, model) {
       publicAPI.updateMarkerOrientation();
       model.enabled = true;
     } else {
-      var _model$_interactor, _model$_interactor$fi;
-
       if (!model.enabled) {
         return;
       }
-
       model.enabled = false;
       resizeObserver.disconnect();
       onCameraChangedSub.unsubscribe();
@@ -195,96 +157,79 @@ function vtkOrientationMarkerWidget(publicAPI, model) {
       onEndAnimationSub = null;
       model.actor.setVisibility(false);
       selfRenderer.removeViewProp(model.actor);
-
-      var _renderWindow = (_model$_interactor = model._interactor) === null || _model$_interactor === void 0 ? void 0 : (_model$_interactor$fi = _model$_interactor.findPokedRenderer()) === null || _model$_interactor$fi === void 0 ? void 0 : _model$_interactor$fi.getRenderWindow();
-
-      if (_renderWindow) {
-        _renderWindow.removeRenderer(selfRenderer);
+      const renderWindow = model._interactor?.findPokedRenderer()?.getRenderWindow();
+      if (renderWindow) {
+        renderWindow.removeRenderer(selfRenderer);
       }
     }
-
     publicAPI.modified();
   };
+
   /**
    * Sets the viewport corner.
    */
-
-
-  publicAPI.setViewportCorner = function (corner) {
+  publicAPI.setViewportCorner = corner => {
     if (corner === model.viewportCorner) {
       return;
     }
-
     model.viewportCorner = corner;
     publicAPI.updateViewport();
   };
+
   /**
    * Sets the viewport size.
    */
-
-
-  publicAPI.setViewportSize = function (sizeFactor) {
-    var viewportSize = Math.min(1, Math.max(0, sizeFactor));
-
+  publicAPI.setViewportSize = sizeFactor => {
+    const viewportSize = Math.min(1, Math.max(0, sizeFactor));
     if (viewportSize === model.viewportSize) {
       return;
     }
-
     model.viewportSize = viewportSize;
     publicAPI.updateViewport();
   };
-
-  publicAPI.setActor = function (actor) {
-    var previousState = model.enabled;
+  publicAPI.setActor = actor => {
+    const previousState = model.enabled;
     publicAPI.setEnabled(false);
     model.actor = actor;
     publicAPI.setEnabled(previousState);
   };
-
-  publicAPI.getRenderer = function () {
-    return selfRenderer;
-  };
-
-  publicAPI.delete = function () {
+  publicAPI.getRenderer = () => selfRenderer;
+  publicAPI.delete = () => {
     superClass.delete();
-
     if (selfSubscription) {
       selfSubscription.unsubscribe();
       selfSubscription = null;
     }
-
     if (onCameraChangedSub) {
       onCameraChangedSub.unsubscribe();
       onCameraChangedSub = null;
     }
-
     if (onCameraModifiedSub) {
       onCameraModifiedSub.unsubscribe();
       onCameraModifiedSub = null;
     }
-
     if (onAnimationSub) {
       onAnimationSub.unsubscribe();
       onAnimationSub = null;
     }
-
     if (onEndAnimationSub) {
       onEndAnimationSub.unsubscribe();
       onEndAnimationSub = null;
     }
-
     resizeObserver.disconnect();
-  }; // --------------------------------------------------------------------------
-  // update viewport whenever we are updated
+  };
 
+  // --------------------------------------------------------------------------
 
+  // update viewport whenever we are updated
   selfSubscription = publicAPI.onModified(publicAPI.updateViewport);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   // actor: null,
   // _interactor: null,
   viewportCorner: Constants.Corners.BOTTOM_LEFT,
@@ -292,28 +237,38 @@ var DEFAULT_VALUES = {
   minPixelSize: 50,
   maxPixelSize: 200,
   parentRenderer: 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, ['enabled', 'viewportCorner', 'viewportSize']); // NOTE: setting these while the widget is enabled will
-  // not update the widget.
+  macro.get(publicAPI, model, ['enabled', 'viewportCorner', 'viewportSize']);
 
+  // NOTE: setting these while the widget is enabled will
+  // not update the widget.
   macro.setGet(publicAPI, model, ['_interactor', 'minPixelSize', 'maxPixelSize', 'parentRenderer']);
   macro.get(publicAPI, model, ['actor']);
-  macro.moveToProtected(publicAPI, model, ['interactor']); // Object methods
+  macro.moveToProtected(publicAPI, model, ['interactor']);
 
+  // Object methods
   vtkOrientationMarkerWidget(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkOrientationMarkerWidget'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkOrientationMarkerWidget');
+
+// ----------------------------------------------------------------------------
 
-var vtkOrientationMarkerWidget$1 = _objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, Constants);
+var vtkOrientationMarkerWidget$1 = {
+  newInstance,
+  extend,
+  ...Constants
+};
 
 export { DEFAULT_VALUES, vtkOrientationMarkerWidget$1 as default, extend, newInstance };

package/Interaction/Widgets/PiecewiseGaussianWidget/ComputeHistogram.worker.js

@@ -2,7 +2,6 @@ import registerWebworker from 'webworker-promise/lib/register';
 
 /* eslint-disable */
 // prettier-ignore
-
 registerWebworker(function (message, emit) {
   var array = message.array;
   var min = message.min;
@@ -14,11 +13,9 @@ registerWebworker(function (message, emit) {
   var histogram = new Float32Array(numberOfBins);
   histogram.fill(0);
   var len = array.length;
-
   for (var i = offset; i < len; i += step) {
     var idx = Math.floor((numberOfBins - 1) * (Number(array[i]) - min) / delta);
     histogram[idx] += 1;
   }
-
   return Promise.resolve(new registerWebworker.TransferableResponse(histogram, [histogram.buffer]));
 });