@kitware/vtk.js 30.7.1 → 30.8.0

package/Interaction/Style/InteractorStyleImage.js

@@ -15,7 +15,7 @@ function vtkInteractorStyleImage(publicAPI, model) {
   publicAPI.superHandleMouseMove = publicAPI.handleMouseMove;
   publicAPI.handleMouseMove = callData => {
     const pos = callData.position;
-    const renderer = callData.pokedRenderer;
+    const renderer = model.getRenderer(callData);
     switch (model.state) {
       case States.IS_WINDOW_LEVEL:
         publicAPI.windowLevel(renderer, pos);
@@ -94,7 +94,7 @@ function vtkInteractorStyleImage(publicAPI, model) {
 
   //--------------------------------------------------------------------------
   publicAPI.handleMouseWheel = callData => {
-    const camera = callData.pokedRenderer.getActiveCamera();
+    const camera = model.getRenderer(callData).getActiveCamera();
     let distance = camera.getDistance();
     distance += callData.spinY;
 
@@ -107,7 +107,7 @@ function vtkInteractorStyleImage(publicAPI, model) {
       distance = range[1];
     }
     camera.setDistance(distance);
-    const props = callData.pokedRenderer.getViewProps().filter(prop => prop.isA('vtkImageSlice'));
+    const props = model.getRenderer(callData).getViewProps().filter(prop => prop.isA('vtkImageSlice'));
     props.forEach(prop => {
       if (prop.getMapper().isA('vtkImageResliceMapper')) {
         const p = prop.getMapper().getSlicePlane();

package/Interaction/Style/InteractorStyleManipulator.js

@@ -251,7 +251,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
     if (manipulator) {
       // register the manipulator for this device
       model.currentVRManipulators.set(ed.device, manipulator);
-      manipulator.onButton3D(publicAPI, ed.pokedRenderer, model.state, ed);
+      manipulator.onButton3D(publicAPI, model.getRenderer(ed), model.state, ed);
       if (ed.pressed) {
         publicAPI.startCameraPose();
       } else {
@@ -271,7 +271,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
   publicAPI.handleMove3D = ed => {
     const manipulator = model.currentVRManipulators.get(ed.device);
     if (manipulator && model.state === States.IS_CAMERA_POSE) {
-      manipulator.onMove3D(publicAPI, ed.pokedRenderer, model.state, ed);
+      manipulator.onMove3D(publicAPI, model.getRenderer(ed), model.state, ed);
     }
   };
 
@@ -292,7 +292,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
         model.currentManipulator.setRotationFactor(model.rotationFactor);
       }
       model.currentManipulator.startInteraction();
-      model.currentManipulator.onButtonDown(model._interactor, callData.pokedRenderer, callData.position);
+      model.currentManipulator.onButtonDown(model._interactor, model.getRenderer(callData), callData.position);
       model._interactor.requestAnimation(publicAPI.onButtonDown);
       publicAPI.invokeStartInteractionEvent(START_INTERACTION_EVENT);
     } else {
@@ -373,7 +373,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
     }
     if (manipulator) {
       model.currentWheelManipulator = manipulator;
-      model.currentWheelManipulator.onStartScroll(model._interactor, callData.pokedRenderer, callData.spinY);
+      model.currentWheelManipulator.onStartScroll(model._interactor, model.getRenderer(callData), callData.spinY);
       model.currentWheelManipulator.startInteraction();
       model._interactor.requestAnimation(publicAPI.handleStartMouseWheel);
       publicAPI.invokeStartInteractionEvent(START_INTERACTION_EVENT);
@@ -399,7 +399,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
   //-------------------------------------------------------------------------
   publicAPI.handleMouseWheel = callData => {
     if (model.currentWheelManipulator && model.currentWheelManipulator.onScroll) {
-      model.currentWheelManipulator.onScroll(model._interactor, callData.pokedRenderer, callData.spinY, model.cachedMousePosition);
+      model.currentWheelManipulator.onScroll(model._interactor, model.getRenderer(callData), callData.spinY, model.cachedMousePosition);
       publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
     }
   };
@@ -408,7 +408,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
   publicAPI.handleMouseMove = callData => {
     model.cachedMousePosition = callData.position;
     if (model.currentManipulator && model.currentManipulator.onMouseMove) {
-      model.currentManipulator.onMouseMove(model._interactor, callData.pokedRenderer, callData.position);
+      model.currentManipulator.onMouseMove(model._interactor, model.getRenderer(callData), callData.position);
       publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
     }
   };
@@ -418,7 +418,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
   //-------------------------------------------------------------------------
   publicAPI.handleKeyPress = callData => {
     model.keyboardManipulators.filter(m => m.onKeyPress).forEach(manipulator => {
-      manipulator.onKeyPress(model._interactor, callData.pokedRenderer, callData.key);
+      manipulator.onKeyPress(model._interactor, model.getRenderer(callData), callData.key);
       publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
     });
   };
@@ -426,7 +426,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
   //-------------------------------------------------------------------------
   publicAPI.handleKeyDown = callData => {
     model.keyboardManipulators.filter(m => m.onKeyDown).forEach(manipulator => {
-      manipulator.onKeyDown(model._interactor, callData.pokedRenderer, callData.key);
+      manipulator.onKeyDown(model._interactor, model.getRenderer(callData), callData.key);
       publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
     });
   };
@@ -434,7 +434,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
   //-------------------------------------------------------------------------
   publicAPI.handleKeyUp = callData => {
     model.keyboardManipulators.filter(m => m.onKeyUp).forEach(manipulator => {
-      manipulator.onKeyUp(model._interactor, callData.pokedRenderer, callData.key);
+      manipulator.onKeyUp(model._interactor, model.getRenderer(callData), callData.key);
       publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
     });
   };
@@ -539,7 +539,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
     while (count--) {
       const manipulator = model.gestureManipulators[count];
       if (manipulator && manipulator.isPinchEnabled()) {
-        manipulator.onPinch(model._interactor, callData.pokedRenderer, callData.scale);
+        manipulator.onPinch(model._interactor, model.getRenderer(callData), callData.scale);
         actionCount++;
       }
     }
@@ -555,7 +555,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
     while (count--) {
       const manipulator = model.gestureManipulators[count];
       if (manipulator && manipulator.isPanEnabled()) {
-        manipulator.onPan(model._interactor, callData.pokedRenderer, callData.translation);
+        manipulator.onPan(model._interactor, model.getRenderer(callData), callData.translation);
         actionCount++;
       }
     }
@@ -571,7 +571,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
     while (count--) {
       const manipulator = model.gestureManipulators[count];
       if (manipulator && manipulator.isRotateEnabled()) {
-        manipulator.onRotate(model._interactor, callData.pokedRenderer, callData.rotation);
+        manipulator.onRotate(model._interactor, model.getRenderer(callData), callData.rotation);
         actionCount++;
       }
     }

package/Interaction/Style/InteractorStyleTrackballCamera.js

@@ -21,7 +21,7 @@ function vtkInteractorStyleTrackballCamera(publicAPI, model) {
   // Public API methods
   publicAPI.handleMouseMove = callData => {
     const pos = callData.position;
-    const renderer = callData.pokedRenderer;
+    const renderer = model.getRenderer(callData);
     switch (model.state) {
       case States.IS_ROTATE:
         publicAPI.handleMouseRotate(renderer, pos);
@@ -73,7 +73,7 @@ function vtkInteractorStyleTrackballCamera(publicAPI, model) {
   publicAPI.updateCameraPose = ed => {
     // move the world in the direction of the
     // controller
-    const camera = ed.pokedRenderer.getActiveCamera();
+    const camera = model.getRenderer(ed).getActiveCamera();
     const oldTrans = camera.getPhysicalTranslation();
 
     // look at the y axis to determine how fast / what direction to move
@@ -169,25 +169,25 @@ function vtkInteractorStyleTrackballCamera(publicAPI, model) {
 
   //----------------------------------------------------------------------------
   publicAPI.handlePinch = callData => {
-    publicAPI.dollyByFactor(callData.pokedRenderer, callData.scale / model.previousScale);
+    publicAPI.dollyByFactor(model.getRenderer(callData), callData.scale / model.previousScale);
     model.previousScale = callData.scale;
   };
 
   //----------------------------------------------------------------------------
   publicAPI.handlePan = callData => {
-    const camera = callData.pokedRenderer.getActiveCamera();
+    const camera = model.getRenderer(callData).getActiveCamera();
 
     // Calculate the focal depth since we'll be using it a lot
     let viewFocus = camera.getFocalPoint();
-    viewFocus = publicAPI.computeWorldToDisplay(callData.pokedRenderer, viewFocus[0], viewFocus[1], viewFocus[2]);
+    viewFocus = publicAPI.computeWorldToDisplay(model.getRenderer(callData), viewFocus[0], viewFocus[1], viewFocus[2]);
     const focalDepth = viewFocus[2];
     const trans = callData.translation;
     const lastTrans = model.previousTranslation;
-    const newPickPoint = publicAPI.computeDisplayToWorld(callData.pokedRenderer, viewFocus[0] + trans[0] - lastTrans[0], viewFocus[1] + trans[1] - lastTrans[1], focalDepth);
+    const newPickPoint = publicAPI.computeDisplayToWorld(model.getRenderer(callData), viewFocus[0] + trans[0] - lastTrans[0], viewFocus[1] + trans[1] - lastTrans[1], focalDepth);
 
     // Has to recalc old mouse point since the viewport has moved,
     // so can't move it outside the loop
-    const oldPickPoint = publicAPI.computeDisplayToWorld(callData.pokedRenderer, viewFocus[0], viewFocus[1], focalDepth);
+    const oldPickPoint = publicAPI.computeDisplayToWorld(model.getRenderer(callData), viewFocus[0], viewFocus[1], focalDepth);
 
     // Camera motion is reversed
     const motionVector = [];
@@ -199,7 +199,7 @@ function vtkInteractorStyleTrackballCamera(publicAPI, model) {
     camera.setFocalPoint(motionVector[0] + viewFocus[0], motionVector[1] + viewFocus[1], motionVector[2] + viewFocus[2]);
     camera.setPosition(motionVector[0] + viewPoint[0], motionVector[1] + viewPoint[1], motionVector[2] + viewPoint[2]);
     if (model._interactor.getLightFollowCamera()) {
-      callData.pokedRenderer.updateLightsGeometryToFollowCamera();
+      model.getRenderer(callData).updateLightsGeometryToFollowCamera();
     }
     camera.orthogonalizeViewUp();
     model.previousTranslation = callData.translation;
@@ -207,7 +207,7 @@ function vtkInteractorStyleTrackballCamera(publicAPI, model) {
 
   //----------------------------------------------------------------------------
   publicAPI.handleRotate = callData => {
-    const camera = callData.pokedRenderer.getActiveCamera();
+    const camera = model.getRenderer(callData).getActiveCamera();
     camera.roll(callData.rotation - model.previousRotation);
     camera.orthogonalizeViewUp();
     model.previousRotation = callData.rotation;
@@ -306,7 +306,7 @@ function vtkInteractorStyleTrackballCamera(publicAPI, model) {
   //----------------------------------------------------------------------------
   publicAPI.handleMouseWheel = callData => {
     const dyf = 1 - callData.spinY / model.zoomFactor;
-    publicAPI.dollyByFactor(callData.pokedRenderer, dyf);
+    publicAPI.dollyByFactor(model.getRenderer(callData), dyf);
   };
 
   //----------------------------------------------------------------------------

package/Interaction/Widgets/OrientationMarkerWidget.d.ts

@@ -145,6 +145,13 @@ export interface vtkOrientationMarkerWidget extends vtkObject {
    * Updates the orientation widget viewport size.
    */
   updateViewport(): void;
+
+  /**
+   * An instance of this class will spawn its own renderer, by default non interactive.
+   * This behavior is configurable through the interactiveRenderer property when initializing the instance.
+   * @returns true if the renderer was created as interactive, false otherwise.
+   */
+  getInteractiveRenderer(): boolean;
 }
 
 /**

package/Interaction/Widgets/OrientationMarkerWidget.js

@@ -123,7 +123,7 @@ function vtkOrientationMarkerWidget(publicAPI, model) {
       }
       // Highest number is foreground
       selfRenderer.setLayer(renderWindow.getNumberOfLayers() - 1);
-      selfRenderer.setInteractive(false);
+      selfRenderer.setInteractive(model.interactiveRenderer);
       selfRenderer.addViewProp(model.actor);
       model.actor.setVisibility(true);
       onCameraChangedSub = ren.onEvent(event => {
@@ -236,7 +236,8 @@ const DEFAULT_VALUES = {
   viewportSize: 0.2,
   minPixelSize: 50,
   maxPixelSize: 200,
-  parentRenderer: null
+  parentRenderer: null,
+  interactiveRenderer: false
 };
 
 // ----------------------------------------------------------------------------
@@ -247,7 +248,7 @@ function extend(publicAPI, model) {
 
   // Build VTK API
   macro.obj(publicAPI, model);
-  macro.get(publicAPI, model, ['enabled', 'viewportCorner', 'viewportSize']);
+  macro.get(publicAPI, model, ['enabled', 'viewportCorner', 'viewportSize', 'interactiveRenderer']);
 
   // NOTE: setting these while the widget is enabled will
   // not update the widget.

package/Rendering/Core/InteractorStyle.d.ts

@@ -1,5 +1,7 @@
 import { EventHandler, vtkSubscription } from './../../interfaces';
+import { Nullable } from './../../types';
 import vtkInteractorObserver from './InteractorObserver';
+import vtkRenderer from './Renderer';
 
 export interface vtkInteractorStyle extends vtkInteractorObserver {
   /**
@@ -210,6 +212,19 @@ export interface vtkInteractorStyle extends vtkInteractorObserver {
    * Handles a keypress.
    */
   handleKeyPress(callData: unknown): void;
+
+  /**
+   * Explicitly defines a renderer to be used for event handling.
+   * If never called or called with null, the pokedRenderer of the event will be used.
+   *
+   * @param {Nullable<vtkRenderer>} renderer
+   */
+  setFocusedRenderer(renderer: Nullable<vtkRenderer>): boolean;
+
+  /**
+   * Get the renderer used for event handling, returns null if not set.
+   */
+  getFocusedRenderer(): Nullable<vtkRenderer>;
 }
 
 export interface IInteractorStyleInitialValues {

package/Rendering/Core/InteractorStyle.js

@@ -64,6 +64,7 @@ function vtkInteractorStyle(publicAPI, model) {
       model._interactor.render();
     };
   });
+  model.getRenderer = callData => model.focusedRenderer || callData.pokedRenderer;
 
   //----------------------------------------------------------------------------
   publicAPI.handleKeyPress = callData => {
@@ -72,12 +73,12 @@ function vtkInteractorStyle(publicAPI, model) {
     switch (callData.key) {
       case 'r':
       case 'R':
-        callData.pokedRenderer.resetCamera();
+        model.getRenderer(callData).resetCamera();
         rwi.render();
         break;
       case 'w':
       case 'W':
-        ac = callData.pokedRenderer.getActors();
+        ac = model.getRenderer(callData).getActors();
         ac.forEach(anActor => {
           const prop = anActor.getProperty();
           if (prop.setRepresentationToWireframe) {
@@ -88,7 +89,7 @@ function vtkInteractorStyle(publicAPI, model) {
         break;
       case 's':
       case 'S':
-        ac = callData.pokedRenderer.getActors();
+        ac = model.getRenderer(callData).getActors();
         ac.forEach(anActor => {
           const prop = anActor.getProperty();
           if (prop.setRepresentationToSurface) {
@@ -99,7 +100,7 @@ function vtkInteractorStyle(publicAPI, model) {
         break;
       case 'v':
       case 'V':
-        ac = callData.pokedRenderer.getActors();
+        ac = model.getRenderer(callData).getActors();
         ac.forEach(anActor => {
           const prop = anActor.getProperty();
           if (prop.setRepresentationToPoints) {
@@ -130,6 +131,7 @@ function extend(publicAPI, model) {
 
   // Inheritance
   vtkInteractorObserver.extend(publicAPI, model, initialValues);
+  macro.setGet(publicAPI, model, ['focusedRenderer']);
 
   // Object specific methods
   vtkInteractorStyle(publicAPI, model);

package/Widgets/Widgets3D/InteractiveOrientationWidget/helpers.d.ts

@@ -0,0 +1,73 @@
+import vtkAbstractWidget from '../../../Widgets/Core/AbstractWidget';
+import vtkCamera from '../../../Rendering/Core/Camera';
+import vtkInteractiveOrientationWidget from '../InteractiveOrientationWidget';
+import vtkOrientationMarkerWidget from '../../../Interaction/Widgets/OrientationMarkerWidget';
+import vtkRenderer from '../../../Rendering/Core/Renderer';
+import vtkRenderWindowInteractor from '../../../Rendering/Core/RenderWindowInteractor';
+import vtkWidgetManager from '../../../Widgets/Core/WidgetManager';
+import { vtkSubscription } from '../../../interfaces';
+import { Bounds, Vector3 } from '../../../types';
+
+export function majorAxis(
+  vec3: Vector3,
+  idxA: number,
+  idxB: number
+): [number, number, number];
+
+/**
+ * Create a new vtkOrientationMarkerWidget instance from the provided interactor and parentRenderer and sensible defaults.
+ *
+ * @param {vtkRenderWindowInteractor} interactor
+ * @param {vtkRenderer} parentRenderer
+ * @returns {vtkOrientationMarkerWidget}
+ */
+export function createOrientationMarkerWidget(
+  interactor: vtkRenderWindowInteractor,
+  parentRenderer: vtkRenderer
+): vtkOrientationMarkerWidget;
+
+/**
+ * Create a new vtkInteractiveOrientationWidget instance and place it at the given bounds.
+ *
+ * @param {Bounds} bounds
+ * @returns {vtkInteractiveOrientationWidget}
+ */
+export function createInteractiveOrientationWidget(
+  bounds: Bounds
+): vtkInteractiveOrientationWidget;
+
+/**
+ * Create a new vtkOrientationMarkerWidget alongside with a new vtkInteractiveOrientationWidget with sensible defaults.
+ *
+ * @param {vtkWidgetManager} widgetManager
+ * @param {vtkRenderWindowInteractor} interactor
+ * @param {vtkRenderer} mainRenderer
+ * @returns {Object} the constructed widget instances
+ */
+export function createInteractiveOrientationMarkerWidget(
+  widgetManager: vtkWidgetManager,
+  interactor: vtkRenderWindowInteractor,
+  mainRenderer: vtkRenderer
+): {
+  interactiveOrientationWidget: vtkInteractiveOrientationWidget;
+  orientationMarkerWidget: vtkOrientationMarkerWidget;
+};
+
+/**
+ * Listen to OrientationChange events on the given view widget.
+ * The event handler will align the provided camera and update the provided vtkOrientationMarkerWidget instance.
+ *
+ * @param {vtkAbstractWidget} viewWidget Must be a vtkInteractiveOrientationWidget view widget
+ * @param {vtkCamera} camera The camera instance to upate when orientation changes
+ * @param {vtkOrientationMarkerWidget} orientationMarkerWidget The instance to update when orientation changes
+ * @param {vtkWidgetManager} widgetManager
+ * @param {Function} render A callback that should render the view
+ * @returns {vtkSubscription} the corresponding event subscription, can be used to unsubscribe from the event
+ */
+export function alignCameraOnViewWidgetOrientationChange(
+  viewWidget: vtkAbstractWidget,
+  camera: vtkCamera,
+  orientationMarkerWidget: vtkOrientationMarkerWidget,
+  widgetManager: vtkWidgetManager,
+  render: () => void
+): vtkSubscription;

package/Widgets/Widgets3D/InteractiveOrientationWidget/helpers.js

@@ -0,0 +1,71 @@
+import * as vtkMath from '@kitware/vtk.js/Common/Core/Math';
+import vtkOrientationMarkerWidget from '@kitware/vtk.js/Interaction/Widgets/OrientationMarkerWidget';
+import vtkAxesActor from '@kitware/vtk.js/Rendering/Core/AxesActor';
+import vtkInteractiveOrientationWidget from '@kitware/vtk.js/Widgets/Widgets3D/InteractiveOrientationWidget';
+
+function majorAxis(vec3, idxA, idxB) {
+  const axis = [0, 0, 0];
+  const idx = Math.abs(vec3[idxA]) > Math.abs(vec3[idxB]) ? idxA : idxB;
+  const value = vec3[idx] > 0 ? 1 : -1;
+  axis[idx] = value;
+  return axis;
+}
+function createOrientationMarkerWidget(interactor, parentRenderer) {
+  const axes = vtkAxesActor.newInstance();
+  const orientationWidget = vtkOrientationMarkerWidget.newInstance({
+    actor: axes,
+    interactor,
+    interactiveRenderer: true,
+    viewportSize: 0.1,
+    minPixelSize: 100,
+    maxPixelSize: 300,
+    parentRenderer
+  });
+  orientationWidget.setEnabled(true);
+  orientationWidget.setViewportCorner(vtkOrientationMarkerWidget.Corners.BOTTOM_LEFT);
+  return orientationWidget;
+}
+function createInteractiveOrientationWidget(bounds) {
+  const widget = vtkInteractiveOrientationWidget.newInstance();
+  widget.placeWidget(bounds);
+  widget.setBounds(bounds.map(v => v * 0.45));
+  return widget;
+}
+function createInteractiveOrientationMarkerWidget(widgetManager, interactor, mainRenderer) {
+  const orientationMarkerWidget = createOrientationMarkerWidget(interactor, mainRenderer);
+  interactor.getInteractorStyle().setFocusedRenderer(mainRenderer);
+  widgetManager.setRenderer(orientationMarkerWidget.getRenderer());
+  const widget = createInteractiveOrientationWidget(orientationMarkerWidget.getActor().getBounds());
+  return {
+    interactiveOrientationWidget: widget,
+    orientationMarkerWidget
+  };
+}
+function alignCameraOnViewWidgetOrientationChange(viewWidget, camera, orientationMarkerWidget, widgetManager, render) {
+  return viewWidget.onOrientationChange(_ref => {
+    let {
+      up,
+      direction,
+      action,
+      event
+    } = _ref;
+    const focalPoint = camera.getFocalPoint();
+    const position = camera.getPosition();
+    const viewUp = camera.getViewUp();
+    const distance = Math.sqrt(vtkMath.distance2BetweenPoints(position, focalPoint));
+    camera.setPosition(focalPoint[0] + direction[0] * distance, focalPoint[1] + direction[1] * distance, focalPoint[2] + direction[2] * distance);
+    if (direction[0]) {
+      camera.setViewUp(majorAxis(viewUp, 1, 2));
+    }
+    if (direction[1]) {
+      camera.setViewUp(majorAxis(viewUp, 0, 2));
+    }
+    if (direction[2]) {
+      camera.setViewUp(majorAxis(viewUp, 0, 1));
+    }
+    orientationMarkerWidget.updateMarkerOrientation();
+    render();
+  });
+}
+
+export { alignCameraOnViewWidgetOrientationChange, createInteractiveOrientationMarkerWidget, createInteractiveOrientationWidget, createOrientationMarkerWidget, majorAxis };

package/index.d.ts

@@ -234,6 +234,7 @@
 /// <reference path="./Widgets/Manipulators/PlaneManipulator.d.ts" />
 /// <reference path="./Widgets/Manipulators/TrackballManipulator.d.ts" />
 /// <reference path="./Widgets/Representations/WidgetRepresentation.d.ts" />
+/// <reference path="./Widgets/Widgets3D/InteractiveOrientationWidget/helpers.d.ts" />
 /// <reference path="./Widgets/Widgets3D/InteractiveOrientationWidget.d.ts" />
 /// <reference path="./Widgets/Widgets3D/ResliceCursorWidget/Constants.d.ts" />
 /// <reference path="./Widgets/Widgets3D/ResliceCursorWidget/behavior.d.ts" />

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "30.7.1",
+  "version": "30.8.0",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",