@kitware/vtk.js 34.11.2 → 34.12.0

package/Common/DataModel/BoundingBox.js

@@ -234,14 +234,14 @@ function oppositeSign(a, b) {
   return a <= 0 && b >= 0 || a >= 0 && b <= 0;
 }
 function getCorners(bounds, corners) {
-  let count = 0;
-  for (let ix = 0; ix < 2; ix++) {
-    for (let iy = 2; iy < 4; iy++) {
-      for (let iz = 4; iz < 6; iz++) {
-        corners[count++] = [bounds[ix], bounds[iy], bounds[iz]];
-      }
-    }
-  }
+  corners[0] = [bounds[0], bounds[2], bounds[4]];
+  corners[1] = [bounds[0], bounds[2], bounds[5]];
+  corners[2] = [bounds[0], bounds[3], bounds[4]];
+  corners[3] = [bounds[0], bounds[3], bounds[5]];
+  corners[4] = [bounds[1], bounds[2], bounds[4]];
+  corners[5] = [bounds[1], bounds[2], bounds[5]];
+  corners[6] = [bounds[1], bounds[3], bounds[4]];
+  corners[7] = [bounds[1], bounds[3], bounds[5]];
   return corners;
 }
 

package/Filters/Sources/TorusSource.js

@@ -0,0 +1,107 @@
+import { m as macro } from '../../macros2.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
+
+// ----------------------------------------------------------------------------
+// vtkTorusSource methods
+// Adapted from three.js TorusGeometry
+// ----------------------------------------------------------------------------
+
+const TAU = Math.PI * 2;
+function vtkTorusSource(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkTorusSource');
+  function requestData(inData, outData) {
+    let dataset = outData[0];
+
+    // Points
+    const points = macro.newTypedArray(model.pointType, 3 * (model.resolution + 1) * (model.tubeResolution + 1));
+    let pointIdx = 0;
+    for (let ti = 0; ti <= model.tubeResolution; ti++) {
+      const v = ti / model.tubeResolution * TAU;
+      const cosV = Math.cos(v);
+      const sinV = Math.sin(v);
+      for (let ri = 0; ri <= model.resolution; ri++) {
+        const u = ri / model.resolution * model.arcLength;
+        points[pointIdx++] = (model.radius + model.tubeRadius * cosV) * Math.cos(u);
+        points[pointIdx++] = (model.radius + model.tubeRadius * cosV) * Math.sin(u);
+        points[pointIdx++] = model.tubeRadius * sinV;
+      }
+    }
+
+    // Cells
+    const cellArraySize = 4 * 2 * (model.resolution * model.tubeResolution);
+    let cellLocation = 0;
+    const polys = new Uint32Array(cellArraySize);
+    for (let ti = 1; ti <= model.tubeResolution; ti++) {
+      for (let ri = 1; ri <= model.resolution; ri++) {
+        const a = (model.resolution + 1) * ti + ri - 1;
+        const b = (model.resolution + 1) * (ti - 1) + ri - 1;
+        const c = (model.resolution + 1) * (ti - 1) + ri;
+        const d = (model.resolution + 1) * ti + ri;
+        polys[cellLocation++] = 3;
+        polys[cellLocation++] = a;
+        polys[cellLocation++] = b;
+        polys[cellLocation++] = d;
+        polys[cellLocation++] = 3;
+        polys[cellLocation++] = b;
+        polys[cellLocation++] = c;
+        polys[cellLocation++] = d;
+      }
+    }
+
+    // Apply transformation to the points coordinates
+    vtkMatrixBuilder.buildFromRadian().translate(...model.center).rotateFromDirections([1, 0, 0], model.direction).apply(points);
+    dataset = vtkPolyData.newInstance();
+    dataset.getPoints().setData(points, 3);
+    dataset.getPolys().setData(polys, 1);
+
+    // Update output
+    outData[0] = dataset;
+  }
+
+  // Expose methods
+  publicAPI.requestData = requestData;
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  radius: 0.5,
+  tubeRadius: 0.01,
+  resolution: 64,
+  tubeResolution: 64,
+  arcLength: TAU,
+  center: [0, 0, 0],
+  direction: [1.0, 0.0, 0.0],
+  pointType: 'Float64Array'
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Build VTK API
+  macro.obj(publicAPI, model);
+  macro.setGet(publicAPI, model, ['radius', 'tubeRadius', 'resolution', 'tubeResolution', 'arcLength']);
+  macro.setGetArray(publicAPI, model, ['center', 'direction'], 3);
+  macro.algo(publicAPI, model, 0, 1);
+  vtkTorusSource(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkTorusSource');
+
+// ----------------------------------------------------------------------------
+
+var vtkTorusSource$1 = {
+  newInstance,
+  extend
+};
+
+export { vtkTorusSource$1 as default, extend, newInstance };

package/Filters/Sources.js

@@ -16,6 +16,7 @@ import vtkPointSource from './Sources/PointSource.js';
 import vtkRTAnalyticSource from './Sources/RTAnalyticSource.js';
 import vtkSLICSource from './Sources/SLICSource.js';
 import vtkSphereSource from './Sources/SphereSource.js';
+import vtkTorusSource from './Sources/TorusSource.js';
 
 var Sources = {
   vtkArcSource,
@@ -35,7 +36,8 @@ var Sources = {
   vtkPointSource,
   vtkRTAnalyticSource,
   vtkSLICSource,
-  vtkSphereSource
+  vtkSphereSource,
+  vtkTorusSource
 };
 
 export { Sources as default };

package/Interaction/Style/InteractorStyleMPRSlice.js

@@ -1,20 +1,18 @@
 import { m as macro } from '../../macros2.js';
-import { l as normalize, e as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
+import { l as normalize, E as areEquals, e as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
+import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkInteractorStyleManipulator from './InteractorStyleManipulator.js';
 import vtkMouseCameraTrackballRotateManipulator from '../Manipulators/MouseCameraTrackballRotateManipulator.js';
 import vtkMouseCameraTrackballPanManipulator from '../Manipulators/MouseCameraTrackballPanManipulator.js';
 import vtkMouseCameraTrackballZoomManipulator from '../Manipulators/MouseCameraTrackballZoomManipulator.js';
 import vtkMouseRangeManipulator from '../Manipulators/MouseRangeManipulator.js';
+import { mat4 } from 'gl-matrix';
 
 // ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
 
-function boundsToCorners(bounds) {
-  return [[bounds[0], bounds[2], bounds[4]], [bounds[0], bounds[2], bounds[5]], [bounds[0], bounds[3], bounds[4]], [bounds[0], bounds[3], bounds[5]], [bounds[1], bounds[2], bounds[4]], [bounds[1], bounds[2], bounds[5]], [bounds[1], bounds[3], bounds[4]], [bounds[1], bounds[3], bounds[5]]];
-}
-
 // ----------------------------------------------------------------------------
 
 function clamp(value, min, max) {
@@ -120,9 +118,8 @@ function vtkInteractorStyleMPRSlice(publicAPI, model) {
     const camera = renderer.getActiveCamera();
     if (model.volumeMapper) {
       const range = publicAPI.getSliceRange();
-      const bounds = model.volumeMapper.getBounds();
       const clampedSlice = clamp(slice, ...range);
-      const center = [(bounds[0] + bounds[1]) / 2.0, (bounds[2] + bounds[3]) / 2.0, (bounds[4] + bounds[5]) / 2.0];
+      const center = model.volumeMapper.getCenter();
       const distance = camera.getDistance();
       const dop = camera.getDirectionOfProjection();
       normalize(dop);
@@ -137,28 +134,23 @@ function vtkInteractorStyleMPRSlice(publicAPI, model) {
   publicAPI.getSliceRange = () => {
     if (model.volumeMapper) {
       const sliceNormal = publicAPI.getSliceNormal();
-      if (sliceNormal[0] === cache.sliceNormal[0] && sliceNormal[1] === cache.sliceNormal[1] && sliceNormal[2] === cache.sliceNormal[2]) {
+      if (areEquals(sliceNormal, cache.sliceNormal)) {
         return cache.sliceRange;
       }
-      const bounds = model.volumeMapper.getBounds();
-      const points = boundsToCorners(bounds);
 
       // Get rotation matrix from normal to +X (since bounds is aligned to XYZ)
-      const transform = vtkMatrixBuilder.buildFromDegree().identity().rotateFromDirections(sliceNormal, [1, 0, 0]);
-      points.forEach(pt => transform.apply(pt));
+      const sliceOrientation = vtkMatrixBuilder.buildFromDegree().identity().rotateFromDirections(sliceNormal, [1, 0, 0]);
+      const imageAlongSliceNormal = mat4.create();
+      mat4.multiply(imageAlongSliceNormal, sliceOrientation.getMatrix(), model.volumeMapper.getInputData().getIndexToWorld());
+
+      // Transform the 8 corners of the input data's bounding box
+      // to rotate into the slice plane space without the intermediate
+      // axis-aligned box (provided by getBounds) which would grow the bounds.
+      const transformedBounds = vtkBoundingBox.transformBounds(model.volumeMapper.getInputData().getSpatialExtent(), imageAlongSliceNormal);
 
       // range is now maximum X distance
-      let minX = Infinity;
-      let maxX = -Infinity;
-      for (let i = 0; i < 8; i++) {
-        const x = points[i][0];
-        if (x > maxX) {
-          maxX = x;
-        }
-        if (x < minX) {
-          minX = x;
-        }
-      }
+      const minX = transformedBounds[0];
+      const maxX = transformedBounds[1];
       cache.sliceNormal = sliceNormal;
       cache.sliceRange = [minX, maxX];
       return cache.sliceRange;

package/Interaction/Style/InteractorStyleManipulator.js

@@ -355,6 +355,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
       if (!model._interactor.isPointerLocked()) {
         model.currentManipulator = null;
       }
+      model._interactor.cancelAnimation(publicAPI.onButtonDown);
       publicAPI.invokeEndInteractionEvent(END_INTERACTION_EVENT);
     }
   };

package/Proxy/Representations/GlyphRepresentationProxy.js

@@ -25,6 +25,7 @@ import '../../Filters/Sources/PointSource.js';
 import '../../Filters/Sources/RTAnalyticSource.js';
 import '../../Filters/Sources/SLICSource.js';
 import '../../Filters/Sources/SphereSource.js';
+import '../../Filters/Sources/TorusSource.js';
 
 // ----------------------------------------------------------------------------
 // vtkGlyphRepresentationProxy methods

package/Rendering/Core/Prop3D.js

@@ -83,6 +83,16 @@ function vtkProp3D(publicAPI, model) {
     publicAPI.modified();
     return true;
   };
+  publicAPI.setOrientationFromQuaternion = q => {
+    const rotation = mat4.create();
+    mat4.fromQuat(rotation, q);
+    if (!areMatricesEqual(rotation, model.rotation)) {
+      model.rotation = rotation;
+      publicAPI.modified();
+      return true;
+    }
+    return false;
+  };
   publicAPI.setUserMatrix = matrix => {
     if (areMatricesEqual(model.userMatrix, matrix)) {
       return false;
@@ -186,6 +196,12 @@ function vtkProp3D(publicAPI, model) {
     }
     return model.properties[mapperInputPort];
   };
+  publicAPI.getProperties = () => {
+    if (model.properties.length === 0) {
+      model.properties[0] = publicAPI.makeProperty?.();
+    }
+    return model.properties;
+  };
   publicAPI.setProperty = (firstArg, secondArg) => {
     // Two options for argument layout:
     // - (mapperInputPort, property)

package/Widgets/Manipulators/PlaneManipulator.js

@@ -44,10 +44,10 @@ const newInstance = macro.newInstance(extend, 'vtkPlaneManipulator');
 
 // ----------------------------------------------------------------------------
 
-var vtkPlanePointManipulator = {
+var vtkPlaneManipulator$1 = {
   intersectDisplayWithPlane,
   extend,
   newInstance
 };
 
-export { vtkPlanePointManipulator as default, extend, intersectDisplayWithPlane, newInstance };
+export { vtkPlaneManipulator$1 as default, extend, intersectDisplayWithPlane, newInstance };

package/Widgets/Manipulators.js

@@ -1,12 +1,12 @@
 import vtkPickerManipulator from './Manipulators/PickerManipulator.js';
 import vtkLineManipulator from './Manipulators/LineManipulator.js';
-import vtkPlanePointManipulator from './Manipulators/PlaneManipulator.js';
+import vtkPlaneManipulator from './Manipulators/PlaneManipulator.js';
 import vtkTrackballManipulator from './Manipulators/TrackballManipulator.js';
 
 var Manipulators = {
   vtkPickerManipulator,
   vtkLineManipulator,
-  vtkPlaneManipulator: vtkPlanePointManipulator,
+  vtkPlaneManipulator,
   vtkTrackballManipulator
 };
 

package/Widgets/Representations/RotateTransformHandleRepresentation.js

@@ -0,0 +1,46 @@
+import { m as macro } from '../../macros2.js';
+import vtkGlyphRepresentation from './GlyphRepresentation.js';
+import vtkTorusSource from '../../Filters/Sources/TorusSource.js';
+
+// ----------------------------------------------------------------------------
+// vtkRotateTransformHandleRepresentation methods
+// ----------------------------------------------------------------------------
+
+function vtkRotateTransformHandleRepresentation(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkRotateTransformHandleRepresentation');
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+function defaultValues(initialValues) {
+  return {
+    _pipeline: {
+      glyph: vtkTorusSource.newInstance({})
+    },
+    ...initialValues
+  };
+}
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  vtkGlyphRepresentation.extend(publicAPI, model, defaultValues(initialValues));
+
+  // Object specific methods
+  vtkRotateTransformHandleRepresentation(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkRotateTransformHandleRepresentation');
+
+// ----------------------------------------------------------------------------
+
+var vtkRotateTransformHandleRepresentation$1 = {
+  newInstance,
+  extend
+};
+
+export { vtkRotateTransformHandleRepresentation$1 as default, extend, newInstance };

package/Widgets/Representations/ScaleTransformHandleRepresentation.js

@@ -0,0 +1,57 @@
+import { m as macro } from '../../macros2.js';
+import vtkGlyphRepresentation from './GlyphRepresentation.js';
+import vtkCubeSource from '../../Filters/Sources/CubeSource.js';
+import vtkTransformHandleSource from './TranslateTransformHandleRepresentation/TransformHandleSource.js';
+
+// ----------------------------------------------------------------------------
+// vtkScaleTransformHandleRepresentation methods
+// ----------------------------------------------------------------------------
+
+function vtkScaleTransformHandleRepresentation(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkScaleTransformHandleRepresentation');
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+function defaultValues(initialValues) {
+  const source = vtkTransformHandleSource.newInstance({
+    height: initialValues.height ?? 1,
+    radius: initialValues.radius ?? 1,
+    resolution: initialValues.glyphResolution ?? 12,
+    direction: [0, 0, 1]
+  });
+  const cube1 = vtkCubeSource.newInstance(initialValues.cubeSource);
+  const cube2 = vtkCubeSource.newInstance(initialValues.cubeSource);
+  source.addInputConnection(cube1.getOutputPort());
+  source.addInputConnection(cube2.getOutputPort());
+  return {
+    _pipeline: {
+      glyph: source
+    },
+    ...initialValues
+  };
+}
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  vtkGlyphRepresentation.extend(publicAPI, model, defaultValues(initialValues));
+
+  // Object specific methods
+  vtkScaleTransformHandleRepresentation(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkScaleTransformHandleRepresentation');
+
+// ----------------------------------------------------------------------------
+
+var vtkScaleTransformHandleRepresentation$1 = {
+  newInstance,
+  extend
+};
+
+export { vtkScaleTransformHandleRepresentation$1 as default, extend, newInstance };

package/Widgets/Representations/TranslateTransformHandleRepresentation/TransformHandleSource.js

@@ -0,0 +1,85 @@
+import { m as macro } from '../../../macros2.js';
+import vtkMatrixBuilder from '../../../Common/Core/MatrixBuilder.js';
+import vtkAppendPolyData from '../../../Filters/General/AppendPolyData.js';
+import vtkCylinderSource from '../../../Filters/Sources/CylinderSource.js';
+
+function rotatePolyData(pd, direction) {
+  const points = pd.getPoints().getData();
+  vtkMatrixBuilder.buildFromRadian().rotateFromDirections([0, 1, 0], direction).apply(points);
+  pd.getPoints().modified();
+  pd.modified();
+}
+function translatePolyData(pd, translation) {
+  const points = pd.getPoints().getData();
+  vtkMatrixBuilder.buildFromRadian().translate(...translation).apply(points);
+  pd.modified();
+}
+function vtkTransformHandleSource(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkTransformHandleSource');
+  function requestData(inData, outData) {
+    const cylinderSource = vtkCylinderSource.newInstance({
+      height: model.height,
+      initAngle: model.initAngle,
+      radius: model.radius,
+      resolution: model.resolution,
+      capping: model.capping,
+      pointType: model.pointType,
+      center: [0, 0, 0],
+      direction: [0, 1, 0]
+    });
+    const appendFilter = vtkAppendPolyData.newInstance();
+    appendFilter.setInputConnection(cylinderSource.getOutputPort(), 0);
+    if (inData[0]) {
+      translatePolyData(inData[0], [0, model.height / 2, 0]);
+      appendFilter.addInputData(inData[0]);
+    }
+    if (inData[1]) {
+      rotatePolyData(inData[1], [0, -1, 0]);
+      translatePolyData(inData[1], [0, -model.height / 2, 0]);
+      appendFilter.addInputData(inData[1]);
+    }
+    const poly = appendFilter.getOutputData();
+    const points = poly.getPoints().getData();
+
+    // Apply transformation to the points coordinates
+    vtkMatrixBuilder.buildFromRadian().translate(...model.center).rotateFromDirections([0, 1, 0], model.direction).translate(...model.center.map(c => c * -1)).apply(points);
+
+    // Update output
+    outData[0] = poly;
+  }
+
+  // Expose methods
+  publicAPI.requestData = requestData;
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  capPolyData: null
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+  vtkCylinderSource.extend(publicAPI, model, initialValues);
+  macro.algo(publicAPI, model, 2, 1);
+  vtkTransformHandleSource(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkTransformHandleSource');
+
+// ----------------------------------------------------------------------------
+
+var vtkTransformHandleSource$1 = {
+  newInstance,
+  extend
+};
+
+export { vtkTransformHandleSource$1 as default, extend, newInstance };

package/Widgets/Representations/TranslateTransformHandleRepresentation.js

@@ -0,0 +1,57 @@
+import { m as macro } from '../../macros2.js';
+import vtkGlyphRepresentation from './GlyphRepresentation.js';
+import vtkConeSource from '../../Filters/Sources/ConeSource.js';
+import vtkTransformHandleSource from './TranslateTransformHandleRepresentation/TransformHandleSource.js';
+
+// ----------------------------------------------------------------------------
+// vtkTranslateTransformHandleRepresentation methods
+// ----------------------------------------------------------------------------
+
+function vtkTranslateTransformHandleRepresentation(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkTranslateTransformHandleRepresentation');
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+function defaultValues(initialValues) {
+  const source = vtkTransformHandleSource.newInstance({
+    height: initialValues.height ?? 1,
+    radius: initialValues.radius ?? 1,
+    resolution: initialValues.glyphResolution ?? 12,
+    direction: [0, 0, 1]
+  });
+  const cone1 = vtkConeSource.newInstance(initialValues.coneSource);
+  const cone2 = vtkConeSource.newInstance(initialValues.coneSource);
+  source.addInputConnection(cone1.getOutputPort());
+  source.addInputConnection(cone2.getOutputPort());
+  return {
+    _pipeline: {
+      glyph: source
+    },
+    ...initialValues
+  };
+}
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  vtkGlyphRepresentation.extend(publicAPI, model, defaultValues(initialValues));
+
+  // Object specific methods
+  vtkTranslateTransformHandleRepresentation(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkTranslateTransformHandleRepresentation');
+
+// ----------------------------------------------------------------------------
+
+var vtkTranslateTransformHandleRepresentation$1 = {
+  newInstance,
+  extend
+};
+
+export { vtkTranslateTransformHandleRepresentation$1 as default, extend, newInstance };

package/Widgets/Representations.js

@@ -8,8 +8,11 @@ import vtkImplicitPlaneRepresentation from './Representations/ImplicitPlaneRepre
 import vtkLineHandleRepresentation from './Representations/LineHandleRepresentation.js';
 import vtkOutlineContextRepresentation from './Representations/OutlineContextRepresentation.js';
 import vtkPolyLineRepresentation from './Representations/PolyLineRepresentation.js';
+import vtkRotateTransformHandleRepresentation from './Representations/RotateTransformHandleRepresentation.js';
+import vtkScaleTransformHandleRepresentation from './Representations/ScaleTransformHandleRepresentation.js';
 import vtkSphereHandleRepresentation from './Representations/SphereHandleRepresentation.js';
 import vtkSplineContextRepresentation from './Representations/SplineContextRepresentation.js';
+import vtkTranslateTransformHandleRepresentation from './Representations/TranslateTransformHandleRepresentation.js';
 import vtkWidgetRepresentation from './Representations/WidgetRepresentation.js';
 
 var Representations = {
@@ -23,8 +26,11 @@ var Representations = {
   vtkLineHandleRepresentation,
   vtkOutlineContextRepresentation,
   vtkPolyLineRepresentation,
+  vtkRotateTransformHandleRepresentation,
+  vtkScaleTransformHandleRepresentation,
   vtkSphereHandleRepresentation,
   vtkSplineContextRepresentation,
+  vtkTranslateTransformHandleRepresentation,
   vtkWidgetRepresentation
 };
 

package/Widgets/Widgets3D/AngleWidget.js

@@ -1,6 +1,6 @@
 import { m as macro } from '../../macros2.js';
 import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
-import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
+import vtkPlaneManipulator from '../Manipulators/PlaneManipulator.js';
 import vtkPolyLineRepresentation from '../Representations/PolyLineRepresentation.js';
 import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
 import { s as subtract, Z as angleBetweenVectors } from '../../Common/Core/Math/index.js';
@@ -69,7 +69,7 @@ function vtkAngleWidget(publicAPI, model) {
   });
 
   // Default manipulator
-  publicAPI.setManipulator(model.manipulator || vtkPlanePointManipulator.newInstance({
+  publicAPI.setManipulator(model.manipulator || vtkPlaneManipulator.newInstance({
     useCameraNormal: true
   }));
 }

package/Widgets/Widgets3D/EllipseWidget.js

@@ -1,6 +1,6 @@
 import { m as macro } from '../../macros2.js';
 import vtkCircleContextRepresentation from '../Representations/CircleContextRepresentation.js';
-import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
+import vtkPlaneManipulator from '../Manipulators/PlaneManipulator.js';
 import vtkShapeWidget from './ShapeWidget.js';
 import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
 import widgetBehavior from './EllipseWidget/behavior.js';
@@ -39,7 +39,7 @@ function vtkEllipseWidget(publicAPI, model) {
   // initialization
   // --------------------------------------------------------------------------
 
-  publicAPI.setManipulator(model.manipulator || vtkPlanePointManipulator.newInstance({
+  publicAPI.setManipulator(model.manipulator || vtkPlaneManipulator.newInstance({
     useCameraNormal: true
   }));
 }

package/Widgets/Widgets3D/ImageCroppingWidget.js

@@ -1,6 +1,6 @@
 import { m as macro } from '../../macros2.js';
 import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
-import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
+import vtkPlaneManipulator from '../Manipulators/PlaneManipulator.js';
 import vtkLineManipulator from '../Manipulators/LineManipulator.js';
 import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
 import vtkCroppingOutlineRepresentation from '../Representations/CroppingOutlineRepresentation.js';
@@ -129,10 +129,10 @@ function vtkImageCroppingWidget(publicAPI, model) {
   // initialization
   // --------------------------------------------------------------------------
 
-  publicAPI.setCornerManipulator(vtkPlanePointManipulator.newInstance({
+  publicAPI.setCornerManipulator(vtkPlaneManipulator.newInstance({
     useCameraNormal: true
   }));
-  publicAPI.setEdgeManipulator(vtkPlanePointManipulator.newInstance());
+  publicAPI.setEdgeManipulator(vtkPlaneManipulator.newInstance());
   publicAPI.setFaceManipulator(vtkLineManipulator.newInstance());
 }
 

package/Widgets/Widgets3D/ImplicitPlaneWidget.js

@@ -4,7 +4,7 @@ import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import vtkImplicitPlaneRepresentation from '../Representations/ImplicitPlaneRepresentation.js';
 import vtkLineManipulator from '../Manipulators/LineManipulator.js';
 import vtkTrackballManipulator from '../Manipulators/TrackballManipulator.js';
-import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
+import vtkPlaneManipulator from '../Manipulators/PlaneManipulator.js';
 import { ViewTypes } from '../Core/WidgetManager/Constants.js';
 
 // ----------------------------------------------------------------------------
@@ -145,7 +145,7 @@ function widgetBehavior(publicAPI, model) {
   // --------------------------------------------------------------------------
 
   model.lineManipulator = vtkLineManipulator.newInstance();
-  model.planeManipulator = vtkPlanePointManipulator.newInstance();
+  model.planeManipulator = vtkPlaneManipulator.newInstance();
   model.trackballManipulator = vtkTrackballManipulator.newInstance();
 }