@kitware/vtk.js 28.13.1 → 29.1.0

package/Widgets/Core/WidgetManager.js

@@ -10,8 +10,7 @@ const {
   CaptureOn
 } = WidgetManagerConst;
 const {
-  vtkErrorMacro,
-  vtkWarningMacro
+  vtkErrorMacro
 } = macro;
 let viewIdCount = 1;
 
@@ -203,15 +202,16 @@ function vtkWidgetManager(publicAPI, model) {
   }
   async function captureBuffers(x1, y1, x2, y2) {
     if (model._captureInProgress) {
+      await model._captureInProgress;
       return;
     }
-    model._captureInProgress = true;
     renderPickingBuffer();
     model._capturedBuffers = null;
-    model._capturedBuffers = await model._selector.getSourceDataAsync(model._renderer, x1, y1, x2, y2);
+    model._captureInProgress = model._selector.getSourceDataAsync(model._renderer, x1, y1, x2, y2);
+    model._capturedBuffers = await model._captureInProgress;
+    model._captureInProgress = null;
     model.previousSelectedData = null;
     renderFrontBuffer();
-    model._captureInProgress = false;
   }
   publicAPI.enablePicking = () => {
     model.pickingEnabled = true;
@@ -343,30 +343,6 @@ function vtkWidgetManager(publicAPI, model) {
     }
     return publicAPI.getSelectedData();
   };
-  publicAPI.updateSelectionFromXY = (x, y) => {
-    vtkWarningMacro('updateSelectionFromXY is deprecated, please use getSelectedDataForXY');
-    if (model.pickingEnabled) {
-      // Then pick regular representations.
-      if (model.captureOn === CaptureOn.MOUSE_MOVE) {
-        captureBuffers(x, y, x, y);
-      }
-    }
-  };
-  publicAPI.updateSelectionFromMouseEvent = event => {
-    vtkWarningMacro('updateSelectionFromMouseEvent is deprecated, please use getSelectedDataForXY');
-    const {
-      pageX,
-      pageY
-    } = event;
-    const {
-      top,
-      left,
-      height
-    } = model._apiSpecificRenderWindow.getCanvas().getBoundingClientRect();
-    const x = pageX - left;
-    const y = height - (pageY - top);
-    publicAPI.updateSelectionFromXY(x, y);
-  };
   publicAPI.getSelectedData = () => {
     if (!model.selections || !model.selections.length) {
       model.previousSelectedData = null;

package/Widgets/Widgets3D/AngleWidget.js

@@ -3,7 +3,7 @@ import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
 import vtkPolyLineRepresentation from '../Representations/PolyLineRepresentation.js';
 import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
-import { s as subtract, S as angleBetweenVectors } from '../../Common/Core/Math/index.js';
+import { s as subtract, T as angleBetweenVectors } from '../../Common/Core/Math/index.js';
 import widgetBehavior from './AngleWidget/behavior.js';
 import generateState from './AngleWidget/state.js';
 import { ViewTypes } from '../Core/WidgetManager/Constants.js';

package/Widgets/Widgets3D/ResliceCursorWidget/behavior.js

@@ -1,7 +1,7 @@
 import { m as macro } from '../../../macros2.js';
 import vtkBoundingBox from '../../../Common/DataModel/BoundingBox.js';
 import vtkLine from '../../../Common/DataModel/Line.js';
-import { k as add, l as normalize, s as subtract, d as dot, j as cross, m as multiplyAccumulate, w as multiplyScalar, T as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
+import { k as add, l as normalize, s as subtract, d as dot, j as cross, m as multiplyAccumulate, w as multiplyScalar, U as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
 import { getLineNames, getOtherLineName, updateState, boundPointOnPlane, getLinePlaneName, getLineInPlaneName, rotateVector } from './helpers.js';
 import { InteractionMethodsName, ScrollingMethods, planeNameToViewType } from './Constants.js';
 

package/Widgets/Widgets3D/ResliceCursorWidget/helpers.js

@@ -2,7 +2,7 @@ import vtkBoundingBox, { STATIC } from '../../../Common/DataModel/BoundingBox.js
 import vtkCubeSource from '../../../Filters/Sources/CubeSource.js';
 import vtkCutter from '../../../Filters/Core/Cutter.js';
 import vtkPlane from '../../../Common/DataModel/Plane.js';
-import { s as subtract, l as normalize, j as cross, w as multiplyScalar, m as multiplyAccumulate, T as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
+import { s as subtract, l as normalize, j as cross, w as multiplyScalar, m as multiplyAccumulate, U as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../../Common/Core/MatrixBuilder.js';
 import { viewTypeToPlaneName, planeNameToViewType, planeNames } from './Constants.js';
 

package/Widgets/Widgets3D.js

@@ -1,5 +1,4 @@
 import vtkAngleWidget from './Widgets3D/AngleWidget.js';
-import vtkDistanceWidget from './Widgets3D/DistanceWidget.js';
 import vtkEllipseWidget from './Widgets3D/EllipseWidget.js';
 import vtkImageCroppingWidget from './Widgets3D/ImageCroppingWidget.js';
 import vtkImplicitPlaneWidget from './Widgets3D/ImplicitPlaneWidget.js';
@@ -16,7 +15,6 @@ import vtkSplineWidget from './Widgets3D/SplineWidget.js';
 
 var Widgets3D = {
   vtkAngleWidget,
-  vtkDistanceWidget,
   vtkEllipseWidget,
   vtkImageCroppingWidget,
   vtkImplicitPlaneWidget,

package/index.d.ts

@@ -205,11 +205,12 @@
 /// <reference path="./Rendering/Misc/TextureLODsDownloader.d.ts" />
 /// <reference path="./Rendering/OpenGL/HardwareSelector/Constants.d.ts" />
 /// <reference path="./Rendering/OpenGL/HardwareSelector.d.ts" />
-/// <reference path="./Rendering/OpenGL/RenderWindow/Constants.d.ts" />
 /// <reference path="./Rendering/OpenGL/RenderWindow.d.ts" />
 /// <reference path="./Rendering/SceneGraph/RenderPass.d.ts" />
 /// <reference path="./Rendering/SceneGraph/ViewNode.d.ts" />
 /// <reference path="./Rendering/SceneGraph/ViewNodeFactory.d.ts" />
+/// <reference path="./Rendering/WebXR/RenderWindowHelper/Constants.d.ts" />
+/// <reference path="./Rendering/WebXR/RenderWindowHelper.d.ts" />
 /// <reference path="./Widgets/Core/AbstractWidget.d.ts" />
 /// <reference path="./Widgets/Core/AbstractWidgetFactory.d.ts" />
 /// <reference path="./Widgets/Core/StateBuilder.d.ts" />

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "28.13.1",
+  "version": "29.1.0",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",
@@ -31,6 +31,7 @@
   "module": "./index.js",
   "dependencies": {
     "@babel/runtime": "7.22.11",
+    "@types/webxr": "^0.5.5",
     "commander": "9.2.0",
     "d3-scale": "4.0.2",
     "fast-deep-equal": "^3.1.3",

package/Widgets/Widgets3D/DistanceWidget/behavior.js

@@ -1,133 +0,0 @@
-import { m as macro } from '../../../macros2.js';
-
-const MAX_POINTS = 2;
-function widgetBehavior(publicAPI, model) {
-  model.classHierarchy.push('vtkDistanceWidgetProp');
-  model._isDragging = false;
-
-  // --------------------------------------------------------------------------
-  // Display 2D
-  // --------------------------------------------------------------------------
-
-  publicAPI.setDisplayCallback = callback => model.representations[0].setDisplayCallback(callback);
-
-  // --------------------------------------------------------------------------
-  // Interactor events
-  // --------------------------------------------------------------------------
-
-  function ignoreKey(e) {
-    return e.altKey || e.controlKey || e.shiftKey;
-  }
-
-  // --------------------------------------------------------------------------
-  // Left press: Select handle to drag
-  // --------------------------------------------------------------------------
-
-  publicAPI.handleLeftButtonPress = e => {
-    if (!model.activeState || !model.activeState.getActive() || !model.pickable || ignoreKey(e)) {
-      return macro.VOID;
-    }
-    const manipulator = model.activeState?.getManipulator?.() ?? model.manipulator;
-    if (model.activeState === model.widgetState.getMoveHandle() && model.widgetState.getHandleList().length < MAX_POINTS && manipulator) {
-      const {
-        worldCoords
-      } = manipulator.handleEvent(e, model._apiSpecificRenderWindow);
-      // Commit handle to location
-      const moveHandle = model.widgetState.getMoveHandle();
-      moveHandle.setOrigin(...worldCoords);
-      const newHandle = model.widgetState.addHandle();
-      newHandle.setOrigin(...moveHandle.getOrigin());
-      newHandle.setColor(moveHandle.getColor());
-      newHandle.setScale1(moveHandle.getScale1());
-      newHandle.setManipulator(manipulator);
-    } else if (model.dragable) {
-      model._isDragging = true;
-      model._apiSpecificRenderWindow.setCursor('grabbing');
-      model._interactor.requestAnimation(publicAPI);
-    }
-    publicAPI.invokeStartInteractionEvent();
-    return macro.EVENT_ABORT;
-  };
-
-  // --------------------------------------------------------------------------
-  // Mouse move: Drag selected handle / Handle follow the mouse
-  // --------------------------------------------------------------------------
-
-  publicAPI.handleMouseMove = callData => {
-    const manipulator = model.activeState?.getManipulator?.() ?? model.manipulator;
-    if (manipulator && model.pickable && model.dragable && model.activeState && model.activeState.getActive() && !ignoreKey(callData)) {
-      const {
-        worldCoords
-      } = manipulator.handleEvent(callData, model._apiSpecificRenderWindow);
-      if (worldCoords.length && (model.activeState === model.widgetState.getMoveHandle() || model._isDragging) && model.activeState.setOrigin // e.g. the line is pickable but not draggable
-      ) {
-        model.activeState.setOrigin(worldCoords);
-        publicAPI.invokeInteractionEvent();
-        return macro.EVENT_ABORT;
-      }
-    }
-    return macro.VOID;
-  };
-
-  // --------------------------------------------------------------------------
-  // Left release: Finish drag / Create new handle
-  // --------------------------------------------------------------------------
-
-  publicAPI.handleLeftButtonRelease = () => {
-    if (!model.activeState || !model.activeState.getActive() || !model.pickable) {
-      return macro.VOID;
-    }
-    if (model.hasFocus && model.widgetState.getHandleList().length === MAX_POINTS) {
-      publicAPI.loseFocus();
-      return macro.VOID;
-    }
-    if (model._isDragging) {
-      model._apiSpecificRenderWindow.setCursor('pointer');
-      model.widgetState.deactivate();
-      model._interactor.cancelAnimation(publicAPI);
-      model._isDragging = false;
-    } else if (model.activeState !== model.widgetState.getMoveHandle()) {
-      model.widgetState.deactivate();
-    }
-    if (model.hasFocus && !model.activeState || model.activeState && !model.activeState.getActive()) {
-      model._widgetManager.enablePicking();
-      model._interactor.render();
-    }
-    publicAPI.invokeEndInteractionEvent();
-    return macro.EVENT_ABORT;
-  };
-
-  // --------------------------------------------------------------------------
-  // Focus API - modeHandle follow mouse when widget has focus
-  // --------------------------------------------------------------------------
-
-  publicAPI.grabFocus = () => {
-    if (!model.hasFocus && model.widgetState.getHandleList().length < MAX_POINTS) {
-      model.activeState = model.widgetState.getMoveHandle();
-      model.activeState.activate();
-      model.activeState.setVisible(true);
-      model._interactor.requestAnimation(publicAPI);
-      publicAPI.invokeStartInteractionEvent();
-    }
-    model.hasFocus = true;
-  };
-
-  // --------------------------------------------------------------------------
-
-  publicAPI.loseFocus = () => {
-    if (model.hasFocus) {
-      model._interactor.cancelAnimation(publicAPI);
-      publicAPI.invokeEndInteractionEvent();
-    }
-    model.widgetState.deactivate();
-    model.widgetState.getMoveHandle().deactivate();
-    model.widgetState.getMoveHandle().setVisible(false);
-    model.widgetState.getMoveHandle().setOrigin(null);
-    model.activeState = null;
-    model.hasFocus = false;
-    model._widgetManager.enablePicking();
-    model._interactor.render();
-  };
-}
-
-export { widgetBehavior as default };

package/Widgets/Widgets3D/DistanceWidget/state.js

@@ -1,22 +0,0 @@
-import vtkStateBuilder from '../../Core/StateBuilder.js';
-
-function generateState() {
-  return vtkStateBuilder.createBuilder().addStateFromMixin({
-    labels: ['moveHandle'],
-    mixins: ['origin', 'color', 'scale1', 'visible', 'manipulator'],
-    name: 'moveHandle',
-    initialValues: {
-      scale1: 30,
-      visible: false
-    }
-  }).addDynamicMixinState({
-    labels: ['handles'],
-    mixins: ['origin', 'color', 'scale1', 'visible', 'manipulator'],
-    name: 'handle',
-    initialValues: {
-      scale1: 30
-    }
-  }).build();
-}
-
-export { generateState as default };

package/Widgets/Widgets3D/DistanceWidget.js

@@ -1,109 +0,0 @@
-import { m as macro } from '../../macros2.js';
-import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
-import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
-import vtkPolyLineRepresentation from '../Representations/PolyLineRepresentation.js';
-import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
-import { e as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
-import widgetBehavior from './DistanceWidget/behavior.js';
-import generateState from './DistanceWidget/state.js';
-import { ViewTypes } from '../Core/WidgetManager/Constants.js';
-
-// ----------------------------------------------------------------------------
-// Factory
-// ----------------------------------------------------------------------------
-
-function vtkDistanceWidget(publicAPI, model) {
-  model.classHierarchy.push('vtkDistanceWidget');
-  const superClass = {
-    ...publicAPI
-  };
-
-  // --- Widget Requirement ---------------------------------------------------
-
-  model.methodsToLink = ['activeScaleFactor', 'activeColor', 'useActiveColor', 'glyphResolution', 'defaultScale', 'scaleInPixels'];
-  publicAPI.getRepresentationsForViewType = viewType => {
-    switch (viewType) {
-      case ViewTypes.DEFAULT:
-      case ViewTypes.GEOMETRY:
-      case ViewTypes.SLICE:
-      case ViewTypes.VOLUME:
-      default:
-        return [{
-          builder: vtkSphereHandleRepresentation,
-          labels: ['handles']
-        }, {
-          builder: vtkSphereHandleRepresentation,
-          labels: ['moveHandle']
-        }, {
-          builder: vtkPolyLineRepresentation,
-          labels: ['handles', 'moveHandle']
-        }];
-    }
-  };
-
-  // --- Public methods -------------------------------------------------------
-
-  publicAPI.getDistance = () => {
-    const handles = model.widgetState.getHandleList();
-    if (handles.length !== 2) {
-      return 0;
-    }
-    if (!handles[0].getOrigin() || !handles[1].getOrigin()) {
-      return 0;
-    }
-    return Math.sqrt(distance2BetweenPoints(handles[0].getOrigin(), handles[1].getOrigin()));
-  };
-  publicAPI.setManipulator = manipulator => {
-    superClass.setManipulator(manipulator);
-    model.widgetState.getMoveHandle().setManipulator(manipulator);
-    model.widgetState.getHandleList().forEach(handle => {
-      handle.setManipulator(manipulator);
-    });
-  };
-
-  // --------------------------------------------------------------------------
-  // initialization
-  // --------------------------------------------------------------------------
-
-  model.widgetState.onBoundsChange(bounds => {
-    const center = [(bounds[0] + bounds[1]) * 0.5, (bounds[2] + bounds[3]) * 0.5, (bounds[4] + bounds[5]) * 0.5];
-    model.widgetState.getMoveHandle().setOrigin(center);
-  });
-
-  // Default manipulator
-  publicAPI.setManipulator(model.manipulator || vtkPlanePointManipulator.newInstance({
-    useCameraNormal: true
-  }));
-}
-
-// ----------------------------------------------------------------------------
-
-const defaultValues = initialValues => ({
-  // manipulator: null,
-  behavior: widgetBehavior,
-  widgetState: generateState(),
-  ...initialValues
-});
-
-// ----------------------------------------------------------------------------
-
-function extend(publicAPI, model) {
-  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']);
-  vtkDistanceWidget(publicAPI, model);
-}
-
-// ----------------------------------------------------------------------------
-
-const newInstance = macro.newInstance(extend, 'vtkDistanceWidget');
-
-// ----------------------------------------------------------------------------
-
-var vtkDistanceWidget$1 = {
-  newInstance,
-  extend
-};
-
-export { vtkDistanceWidget$1 as default, extend, newInstance };