@kitware/vtk.js 27.5.0 → 28.0.0

package/Widgets/Widgets3D/ResliceCursorWidget/cprBehavior.js

@@ -0,0 +1,92 @@
+import widgetBehavior$1 from './behavior.js';
+import { InteractionMethodsName } from './Constants.js';
+import { updateState } from './helpers.js';
+import { ViewTypes } from '../../Core/WidgetManager/Constants.js';
+import { vec3 } from 'gl-matrix';
+
+function widgetBehavior(publicAPI, model) {
+  // We inherit resliceCursorBehavior
+  widgetBehavior$1(publicAPI, model);
+  var stretchPlaneName = 'Y';
+  var crossPlaneName = 'Z';
+
+  publicAPI.getActiveInteraction = function () {
+    if (model.widgetState.getStatesWithLabel("lineIn".concat(stretchPlaneName)).includes(model.activeState)) {
+      return InteractionMethodsName.TranslateCenterAndUpdatePlanes;
+    }
+
+    if (model.widgetState.getStatesWithLabel("lineIn".concat(crossPlaneName)).includes(model.activeState) || model.widgetState.getStatesWithLabel("rotationIn".concat(crossPlaneName)).includes(model.activeState)) {
+      return InteractionMethodsName.RotateLine;
+    }
+
+    return null;
+  };
+
+  publicAPI[InteractionMethodsName.TranslateCenterAndUpdatePlanes] = function (calldata) {
+    var _model$activeState$ge, _model$activeState, _model$activeState$ge2;
+
+    var manipulator = (_model$activeState$ge = (_model$activeState = model.activeState) === null || _model$activeState === void 0 ? void 0 : (_model$activeState$ge2 = _model$activeState.getManipulator) === null || _model$activeState$ge2 === void 0 ? void 0 : _model$activeState$ge2.call(_model$activeState)) !== null && _model$activeState$ge !== void 0 ? _model$activeState$ge : model.manipulator;
+
+    var _manipulator$handleEv = manipulator.handleEvent(calldata, model._apiSpecificRenderWindow),
+        worldCoords = _manipulator$handleEv.worldCoords,
+        worldDirection = _manipulator$handleEv.worldDirection;
+
+    publicAPI.updateCenterAndPlanes(worldCoords, worldDirection);
+  };
+
+  publicAPI.updateCenterAndPlanes = function (worldCoords, worldDirection) {
+    // Update center
+    var newBoundedCenter = publicAPI.getBoundedCenter(worldCoords);
+    model.widgetState.setCenter(newBoundedCenter); // Update planes if axes are given
+
+    if (worldDirection) {
+      var getAxis = function getAxis(idx) {
+        return vec3.normalize([], worldDirection.slice(3 * idx, 3 * idx + 3));
+      };
+
+      var planes = model.widgetState.getPlanes();
+      Object.keys(planes).forEach(function (viewType) {
+        switch (Number.parseInt(viewType, 10)) {
+          case ViewTypes.YZ_PLANE:
+            planes[viewType] = {
+              normal: getAxis(0),
+              viewUp: getAxis(2)
+            };
+            break;
+
+          case ViewTypes.XZ_PLANE:
+            planes[viewType] = {
+              normal: getAxis(1),
+              viewUp: getAxis(2)
+            };
+            break;
+
+          case ViewTypes.XY_PLANE:
+            planes[viewType] = {
+              normal: getAxis(2),
+              viewUp: getAxis(1)
+            };
+            break;
+        }
+      });
+    }
+
+    updateState(model.widgetState, model._factory.getScaleInPixels(), model._factory.getRotationHandlePosition());
+  };
+
+  publicAPI.translateCenterOnPlaneDirection = function (nbSteps) {
+    var _model$_factory$getMa;
+
+    var handleScroll = (_model$_factory$getMa = model._factory.getManipulator()) === null || _model$_factory$getMa === void 0 ? void 0 : _model$_factory$getMa.handleScroll;
+
+    if (handleScroll) {
+      var _handleScroll = handleScroll(nbSteps),
+          worldCoords = _handleScroll.worldCoords,
+          worldDirection = _handleScroll.worldDirection;
+
+      publicAPI.updateCenterAndPlanes(worldCoords, worldDirection);
+    }
+  };
+}
+
+export { widgetBehavior as default };

package/Widgets/Widgets3D/ResliceCursorWidget/helpers.js

@@ -5,8 +5,7 @@ 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, S as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../../Common/Core/MatrixBuilder.js';
-import { ViewTypes } from '../../Core/WidgetManager/Constants.js';
-import { planeNames, lineNames, planeNameToViewType } from './Constants.js';
+import { viewTypeToPlaneName, planeNameToViewType, planeNames } from './Constants.js';
 
 var EPSILON = 10e-7;
 /**
@@ -128,6 +127,18 @@ function rotateVector(vectorToBeRotated, axis, angle) {
   vtkMatrixBuilder.buildFromRadian().rotate(angle, axis).apply(rotatedVector);
   return rotatedVector;
 }
+/**
+ * Return ['X', 'Y'] if there are only 2 planes defined in the widget state.
+ * Return ['X', 'Y', 'Z'] if there are 3 planes defined in the widget state.
+ * @param {object} widgetState the state of the widget
+ * @returns An array of plane names
+ */
+
+function getPlaneNames(widgetState) {
+  return Object.keys(widgetState.getPlanes()).map(function (viewType) {
+    return viewTypeToPlaneName[viewType];
+  });
+}
 /**
  * Return X if lineName == XinY|XinZ, Y if lineName == YinX|YinZ and Z otherwise
  * @param {string} lineName name of the line (YinX, ZinX, XinY, ZinY, XinZ, YinZ)
@@ -144,15 +155,39 @@ function getLinePlaneName(lineName) {
 function getLineInPlaneName(lineName) {
   return lineName[3];
 }
+/**
+ * Returns ['XinY', 'YinX'] if planes == ['X', 'Y']
+ * ['XinY', 'XinZ', 'YinX', 'YinZ', 'ZinX', 'ZinY'] if planes == ['X', 'Y', 'Z']
+ * @param {string} planes name of the planes (e.g. ['X', 'Y'])
+ */
+
+function getPlanesLineNames() {
+  var planes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : planeNames;
+  var lines = [];
+  planes.forEach(function (plane) {
+    planes.forEach(function (inPlane) {
+      if (plane !== inPlane) {
+        lines.push("".concat(plane, "in").concat(inPlane));
+      }
+    });
+  });
+  return lines;
+}
+function getLineNames(widgetState) {
+  var planes = Object.keys(widgetState.getPlanes()).map(function (viewType) {
+    return viewTypeToPlaneName[viewType];
+  });
+  return getPlanesLineNames(planes);
+}
 /**
  * Return ZinX if lineName == YinX, YinX if lineName == ZinX, ZinY if lineName == XinY...
  * @param {string} lineName name of the line (YinX, ZinX, XinY, ZinY, XinZ, YinZ)
  */
 
-function getOtherLineName(lineName) {
+function getOtherLineName(widgetState, lineName) {
   var linePlaneName = getLinePlaneName(lineName);
   var lineInPlaneName = getLineInPlaneName(lineName);
-  var otherLineName = planeNames.find(function (planeName) {
+  var otherLineName = getPlaneNames(widgetState).find(function (planeName) {
     return planeName !== linePlaneName && planeName !== lineInPlaneName;
   });
   return "".concat(otherLineName, "in").concat(lineInPlaneName);
@@ -165,33 +200,44 @@ function computeRotationHandleOriginOffset(axis, rotationHandlePosition, volumeD
 
 
 function updateState(widgetState, scaleInPixels, rotationHandlePosition) {
-  // Compute line axis
-  var xNormal = widgetState.getPlanes()[ViewTypes.YZ_PLANE].normal;
-  var yNormal = widgetState.getPlanes()[ViewTypes.XZ_PLANE].normal;
-  var zNormal = widgetState.getPlanes()[ViewTypes.XY_PLANE].normal;
-  var axes = {
-    XY: cross(xNormal, yNormal, []),
-    YZ: cross(yNormal, zNormal, []),
-    XZ: cross(zNormal, xNormal, [])
-  };
-  axes.YX = axes.XY;
-  axes.ZY = axes.YZ;
-  axes.ZX = axes.XZ;
+  var planes = Object.keys(widgetState.getPlanes()).map(function (viewType) {
+    return viewTypeToPlaneName[viewType];
+  }); // Generates an object as such:
+  // axes = {'XY': cross(X, Y), 'YX': cross(X, Y), 'YZ': cross(Y, Z)...}
+
+  var axes = planes.reduce(function (res, plane) {
+    planes.filter(function (otherPlane) {
+      return plane !== otherPlane;
+    }).forEach(function (otherPlane) {
+      var cross$1 = cross(widgetState.getPlanes()[planeNameToViewType[plane]].normal, widgetState.getPlanes()[planeNameToViewType[otherPlane]].normal, []);
+      res["".concat(plane).concat(otherPlane)] = cross$1;
+      res["".concat(otherPlane).concat(plane)] = cross$1;
+    });
+    return res;
+  }, {});
   var bounds = widgetState.getImage().getBounds();
   var center = widgetState.getCenter(); // Length of the principal diagonal.
 
   var pdLength = vtkBoundingBox.getDiagonalLength(bounds);
   widgetState.getCenterHandle().setOrigin(center);
-  lineNames.forEach(function (lineName) {
+  getPlanesLineNames(planes).forEach(function (lineName) {
+    var _widgetState$$getMani, _widgetState$$getMani2, _widgetState$$getMani3, _widgetState$$getMani4, _lineHandle$getManipu, _lineHandle$getManipu2;
+
     var planeName = getLinePlaneName(lineName);
     var inPlaneName = getLineInPlaneName(lineName);
     var direction = axes["".concat(planeName).concat(inPlaneName)];
     widgetState["getRotationHandle".concat(lineName, "0")]().setOrigin(center);
+    (_widgetState$$getMani = widgetState["getRotationHandle".concat(lineName, "0")]().getManipulator()) === null || _widgetState$$getMani === void 0 ? void 0 : _widgetState$$getMani.setHandleOrigin(center);
+    (_widgetState$$getMani2 = widgetState["getRotationHandle".concat(lineName, "0")]().getManipulator()) === null || _widgetState$$getMani2 === void 0 ? void 0 : _widgetState$$getMani2.setHandleNormal(widgetState.getPlanes()[planeNameToViewType[planeName]].normal);
     widgetState["getRotationHandle".concat(lineName, "0")]().setOffset(computeRotationHandleOriginOffset(direction, rotationHandlePosition, pdLength, scaleInPixels));
     widgetState["getRotationHandle".concat(lineName, "1")]().setOrigin(center);
+    (_widgetState$$getMani3 = widgetState["getRotationHandle".concat(lineName, "1")]().getManipulator()) === null || _widgetState$$getMani3 === void 0 ? void 0 : _widgetState$$getMani3.setHandleOrigin(center);
+    (_widgetState$$getMani4 = widgetState["getRotationHandle".concat(lineName, "1")]().getManipulator()) === null || _widgetState$$getMani4 === void 0 ? void 0 : _widgetState$$getMani4.setHandleNormal(widgetState.getPlanes()[planeNameToViewType[planeName]].normal);
     widgetState["getRotationHandle".concat(lineName, "1")]().setOffset(computeRotationHandleOriginOffset(direction, -rotationHandlePosition, pdLength, scaleInPixels));
     var lineHandle = widgetState["getAxis".concat(lineName)]();
     lineHandle.setOrigin(center);
+    (_lineHandle$getManipu = lineHandle.getManipulator()) === null || _lineHandle$getManipu === void 0 ? void 0 : _lineHandle$getManipu.setHandleOrigin(center);
+    (_lineHandle$getManipu2 = lineHandle.getManipulator()) === null || _lineHandle$getManipu2 === void 0 ? void 0 : _lineHandle$getManipu2.setHandleNormal(widgetState.getPlanes()[planeNameToViewType[planeName]].normal);
     var scale = normalize(direction);
     var scale3 = lineHandle.getScale3();
     scale3[2] = 2 * scale;
@@ -222,4 +268,4 @@ function transformPlane(planeToTransform, targetCenter, targetNormal, targetView
   planeToTransform.setCenter(targetCenter);
 }
 
-export { boundPlane, boundPoint, boundPointOnPlane, getLineInPlaneName, getLinePlaneName, getOtherLineName, rotateVector, transformPlane, updateState };
+export { boundPlane, boundPoint, boundPointOnPlane, getLineInPlaneName, getLineNames, getLinePlaneName, getOtherLineName, getPlaneNames, getPlanesLineNames, rotateVector, transformPlane, updateState };

package/Widgets/Widgets3D/ResliceCursorWidget/state.js

@@ -1,8 +1,27 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import vtkStateBuilder from '../../Core/StateBuilder.js';
-import { ScrollingMethods, planeNames } from './Constants.js';
-import { ViewTypes } from '../../Core/WidgetManager/Constants.js';
+import { planeNameToViewType, ScrollingMethods, planeNames } from './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; }
+
+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 defaultPlanes = {
+  X: {
+    normal: [1, 0, 0],
+    viewUp: [0, 0, 1],
+    color3: [255, 0, 0]
+  },
+  Y: {
+    normal: [0, -1, 0],
+    viewUp: [0, 0, 1],
+    color3: [0, 255, 0]
+  },
+  Z: {
+    normal: [0, 0, -1],
+    viewUp: [0, -1, 0],
+    color3: [0, 0, 255]
+  }
+};
 var viewsColor3 = {
   X: [255, 0, 0],
   // red
@@ -12,8 +31,7 @@ var viewsColor3 = {
 
 };
 function generateState() {
-  var _initialValue;
-
+  var planes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : planeNames;
   var state = vtkStateBuilder.createBuilder().addField({
     name: 'center',
     initialValue: [0, 0, 0]
@@ -25,16 +43,12 @@ function generateState() {
     initialValue: null
   }).addField({
     name: 'planes',
-    initialValue: (_initialValue = {}, _defineProperty(_initialValue, ViewTypes.YZ_PLANE, {
-      normal: [1, 0, 0],
-      viewUp: [0, 0, 1]
-    }), _defineProperty(_initialValue, ViewTypes.XZ_PLANE, {
-      normal: [0, -1, 0],
-      viewUp: [0, 0, 1]
-    }), _defineProperty(_initialValue, ViewTypes.XY_PLANE, {
-      normal: [0, 0, -1],
-      viewUp: [0, -1, 0]
-    }), _initialValue)
+    initialValue: planes.reduce(function (res, planeName) {
+      return _objectSpread(_objectSpread({}, res), {}, _defineProperty({}, planeNameToViewType[planeName], {
+        normal: defaultPlanes[planeName].normal,
+        viewUp: defaultPlanes[planeName].viewUp
+      }));
+    }, {})
   }).addField({
     name: 'scrollingMethod',
     initialValue: ScrollingMethods.MIDDLE_MOUSE_BUTTON
@@ -53,8 +67,8 @@ function generateState() {
       color3: [255, 255, 255]
     }
   });
-  planeNames.reduce(function (viewState, view) {
-    return planeNames.filter(function (v) {
+  planes.reduce(function (viewState, view) {
+    return planes.filter(function (v) {
       return v !== view;
     }).reduce(function (axisState, axis) {
       // Line handle

package/Widgets/Widgets3D/ResliceCursorWidget.js

@@ -4,6 +4,7 @@ import macro from '../../macros.js';
 import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import vtkPlane from '../../Common/DataModel/Plane.js';
 import vtkPlaneSource from '../../Filters/Sources/PlaneSource.js';
+import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
 import vtkLineHandleRepresentation from '../Representations/LineHandleRepresentation.js';
 import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
 import { e as distance2BetweenPoints, m as multiplyAccumulate, s as subtract, l as normalize, w as multiplyScalar, k as add } from '../../Common/Core/Math/index.js';
@@ -263,11 +264,9 @@ function vtkResliceCursorWidget(publicAPI, model) {
     updateCamera(renderer, normal, viewType, resetFocalPoint, keepCenterFocalDistance);
   };
 
-  publicAPI.updateReslicePlane = function (imageReslice, viewType) {
-    // Calculate appropriate pixel spacing for the reslicing
-    var spacing = model.widgetState.getImage().getSpacing(); // Compute original (i.e. before rotation) plane (i.e. origin, p1, p2)
+  publicAPI.getPlaneSource = function (viewType) {
+    // Compute original (i.e. before rotation) plane (i.e. origin, p1, p2)
     // centered on cursor center.
-
     var planeSource = computeReslicePlaneOrigin(viewType);
     var _model$widgetState$ge = model.widgetState.getPlanes()[viewType],
         normal = _model$widgetState$ge.normal,
@@ -286,18 +285,25 @@ function vtkResliceCursorWidget(publicAPI, model) {
     planeSource.setOrigin.apply(planeSource, _toConsumableArray(boundedOrigin));
     planeSource.setPoint1.apply(planeSource, _toConsumableArray(boundedP1));
     planeSource.setPoint2.apply(planeSource, _toConsumableArray(boundedP2));
-    var o = planeSource.getOrigin();
+    return planeSource;
+  };
+
+  publicAPI.getResliceAxes = function (viewType) {
+    // Compute original (i.e. before rotation) plane (i.e. origin, p1, p2)
+    // centered on cursor center.
+    var planeSource = publicAPI.getPlaneSource(viewType); // TBD: use normal from planeSource ?
+
+    var normal = model.widgetState.getPlanes()[viewType].normal;
+    var planeOrigin = planeSource.getOrigin();
     var p1 = planeSource.getPoint1();
     var planeAxis1 = [];
-    subtract(p1, o, planeAxis1);
+    subtract(p1, planeOrigin, planeAxis1);
+    normalize(planeAxis1);
     var p2 = planeSource.getPoint2();
     var planeAxis2 = [];
-    subtract(p2, o, planeAxis2); // The x,y dimensions of the plane
-
-    var planeSizeX = normalize(planeAxis1);
-    var planeSizeY = normalize(planeAxis2);
+    subtract(p2, planeOrigin, planeAxis2);
+    normalize(planeAxis2);
     var newResliceAxes = mat4.identity(new Float64Array(16));
-    var planeOrigin = planeSource.getOrigin();
 
     for (var i = 0; i < 3; i++) {
       newResliceAxes[i] = planeAxis1[i];
@@ -306,6 +312,21 @@ function vtkResliceCursorWidget(publicAPI, model) {
       newResliceAxes[12 + i] = planeOrigin[i];
     }
 
+    return newResliceAxes;
+  };
+
+  publicAPI.updateReslicePlane = function (imageReslice, viewType) {
+    // Calculate appropriate pixel spacing for the reslicing
+    var spacing = model.widgetState.getImage().getSpacing();
+    var planeSource = publicAPI.getPlaneSource(viewType);
+    var newResliceAxes = publicAPI.getResliceAxes(viewType);
+    var planeOrigin = planeSource.getOrigin();
+    var p1 = planeSource.getPoint1();
+    var planeAxis1 = subtract(p1, planeOrigin, []);
+    var planeSizeX = normalize(planeAxis1);
+    var p2 = planeSource.getPoint2();
+    var planeAxis2 = subtract(p2, planeOrigin, []);
+    var planeSizeY = normalize(planeAxis2);
     var spacingX = Math.abs(planeAxis1[0] * spacing[0]) + Math.abs(planeAxis1[1] * spacing[1]) + Math.abs(planeAxis1[2] * spacing[2]);
     var spacingY = Math.abs(planeAxis2[0] * spacing[0]) + Math.abs(planeAxis2[1] * spacing[1]) + Math.abs(planeAxis2[2] * spacing[2]); // Compute a new set of resliced extents
 
@@ -350,12 +371,7 @@ function vtkResliceCursorWidget(publicAPI, model) {
     modified = imageReslice.setOutputSpacing([outputSpacingX, outputSpacingY, 1]) || modified;
     modified = imageReslice.setOutputOrigin([0.5 * outputSpacingX, 0.5 * outputSpacingY, 0]) || modified;
     modified = imageReslice.setOutputExtent([0, extentX - 1, 0, extentY - 1, 0, 0]) || modified;
-    return {
-      modified: modified,
-      origin: o,
-      point1: p1,
-      point2: p2
-    };
+    return modified;
   };
   /**
    * Returns a plane source with origin at cursor center and
@@ -429,13 +445,20 @@ function vtkResliceCursorWidget(publicAPI, model) {
   });
 } // ----------------------------------------------------------------------------
 
+/**
+ * Initializes the model.
+ * @param {*} initialValues optional object of member variables. initialValues.planes is an optional list of axis names (e.g. ['X', 'Y'])
+ * @returns the initial model object
+ */
+
 
 var defaultValues = function defaultValues(initialValues) {
   return _objectSpread({
     behavior: widgetBehavior,
-    widgetState: generateState(),
+    widgetState: generateState(initialValues.planes),
     rotationHandlePosition: 0.5,
-    scaleInPixels: true
+    scaleInPixels: true,
+    manipulator: vtkPlanePointManipulator.newInstance()
   }, initialValues);
 }; // ----------------------------------------------------------------------------
 
@@ -444,7 +467,7 @@ function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, defaultValues(initialValues));
   vtkAbstractWidgetFactory.extend(publicAPI, model, initialValues);
-  macro.setGet(publicAPI, model, ['scaleInPixels', 'rotationHandlePosition']);
+  macro.setGet(publicAPI, model, ['scaleInPixels', 'rotationHandlePosition', 'manipulator']);
   vtkResliceCursorWidget(publicAPI, model);
 } // ----------------------------------------------------------------------------
 

package/Widgets/Widgets3D/ShapeWidget/behavior.js

@@ -369,7 +369,8 @@ function widgetBehavior(publicAPI, model) {
       model.shapeHandle.setDirection(normal);
     }
 
-    var worldCoords = manipulator.handleEvent(callData, model._apiSpecificRenderWindow);
+    var _manipulator$handleEv = manipulator.handleEvent(callData, model._apiSpecificRenderWindow),
+        worldCoords = _manipulator$handleEv.worldCoords;
 
     if (!worldCoords.length) {
       return macro.VOID;
@@ -413,7 +414,8 @@ function widgetBehavior(publicAPI, model) {
     }
 
     if (model.hasFocus) {
-      var worldCoords = manipulator.handleEvent(e, model._apiSpecificRenderWindow);
+      var _manipulator$handleEv2 = manipulator.handleEvent(e, model._apiSpecificRenderWindow),
+          worldCoords = _manipulator$handleEv2.worldCoords;
 
       if (!model.point1) {
         model.point1Handle.setOrigin(worldCoords);

package/Widgets/Widgets3D/SphereWidget/behavior.js

@@ -56,7 +56,7 @@ function widgetBehavior(publicAPI, model) {
     var _model$activeState$ge, _model$activeState, _model$activeState$ge2;
 
     var manipulator = (_model$activeState$ge = (_model$activeState = model.activeState) === null || _model$activeState === void 0 ? void 0 : (_model$activeState$ge2 = _model$activeState.getManipulator) === null || _model$activeState$ge2 === void 0 ? void 0 : _model$activeState$ge2.call(_model$activeState)) !== null && _model$activeState$ge !== void 0 ? _model$activeState$ge : model.manipulator;
-    return manipulator.handleEvent(e, model._apiSpecificRenderWindow);
+    return manipulator.handleEvent(e, model._apiSpecificRenderWindow).worldCoords;
   } // Update the sphere's center and radius.  Example:
   // handle.setCenterAndRadius([1,2,3], 10);
 

package/Widgets/Widgets3D/SplineWidget/behavior.js

@@ -255,7 +255,9 @@ function widgetBehavior(publicAPI, model) {
       return macro.VOID;
     }
 
-    var worldCoords = manipulator.handleEvent(callData, model._apiSpecificRenderWindow);
+    var _manipulator$handleEv = manipulator.handleEvent(callData, model._apiSpecificRenderWindow),
+        worldCoords = _manipulator$handleEv.worldCoords;
+
     var hoveredHandle = getHoveredHandle();
 
     if (hoveredHandle) {

package/index.d.ts

@@ -52,6 +52,7 @@
 /// <reference path="./Common/DataModel/Spline3D.d.ts" />
 /// <reference path="./Common/DataModel/Triangle.d.ts" />
 /// <reference path="./Common/Transform/LandmarkTransform.d.ts" />
+/// <reference path="./Common/Transform/Transform.d.ts" />
 /// <reference path="./Filters/General/AppendPolyData.d.ts" />
 /// <reference path="./Filters/General/ClipClosedSurface.d.ts" />
 /// <reference path="./Filters/General/ContourTriangulator.d.ts" />
@@ -151,6 +152,7 @@
 /// <reference path="./Rendering/Core/Glyph3DMapper.d.ts" />
 /// <reference path="./Rendering/Core/HardwareSelector.d.ts" />
 /// <reference path="./Rendering/Core/ImageArrayMapper.d.ts" />
+/// <reference path="./Rendering/Core/ImageCPRMapper.d.ts" />
 /// <reference path="./Rendering/Core/ImageMapper/Constants.d.ts" />
 /// <reference path="./Rendering/Core/ImageMapper.d.ts" />
 /// <reference path="./Rendering/Core/ImageProperty/Constants.d.ts" />

package/package.json

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