@kitware/vtk.js 34.11.3 → 34.13.0

package/Widgets/Widgets3D/ResliceCursorWidget.js

@@ -4,10 +4,10 @@ import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkBox from '../../Common/DataModel/Box.js';
 import vtkPlane from '../../Common/DataModel/Plane.js';
 import vtkPlaneSource from '../../Filters/Sources/PlaneSource.js';
-import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
+import vtkPlaneManipulator 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, x as multiplyScalar, k as add } from '../../Common/Core/Math/index.js';
+import { f as distance2BetweenPoints, m as multiplyAccumulate, s as subtract, l as normalize, x as multiplyScalar, k as add } from '../../Common/Core/Math/index.js';
 import widgetBehavior from './ResliceCursorWidget/behavior.js';
 import generateState from './ResliceCursorWidget/state.js';
 import { updateState, transformPlane, boundPlane } from './ResliceCursorWidget/helpers.js';
@@ -428,7 +428,7 @@ const defaultValues = initialValues => ({
   widgetState: generateState(initialValues.planes),
   rotationHandlePosition: 0.5,
   scaleInPixels: true,
-  manipulator: vtkPlanePointManipulator.newInstance(),
+  manipulator: vtkPlaneManipulator.newInstance(),
   ...initialValues
 });
 

package/Widgets/Widgets3D/ShapeWidget/behavior.js

@@ -1,5 +1,5 @@
 import { m as macro } from '../../../macros2.js';
-import { f as vtkMath } from '../../../Common/Core/Math/index.js';
+import { b as vtkMath } from '../../../Common/Core/Math/index.js';
 import vtkBoundingBox from '../../../Common/DataModel/BoundingBox.js';
 import vtkPlane from '../../../Common/DataModel/Plane.js';
 import { ShapeBehavior, BehaviorCategory, TextPosition } from './Constants.js';

package/Widgets/Widgets3D/SphereWidget.js

@@ -1,6 +1,6 @@
-import { e as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
+import { f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
 import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
-import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
+import vtkPlaneManipulator from '../Manipulators/PlaneManipulator.js';
 import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
 import vtkSphereContextRepresentation from '../Representations/SphereContextRepresentation.js';
 import { m as macro } from '../../macros2.js';
@@ -45,7 +45,7 @@ function vtkSphereWidget(publicAPI, model) {
   // initialization
   // --------------------------------------------------------------------------
 
-  publicAPI.setManipulator(model.manipulator || vtkPlanePointManipulator.newInstance({
+  publicAPI.setManipulator(model.manipulator || vtkPlaneManipulator.newInstance({
     useCameraNormal: true
   }));
 }

package/Widgets/Widgets3D/SplineWidget.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 vtkSplineContextRepresentation from '../Representations/SplineContextRepresentation.js';
 import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
 import widgetBehavior from './SplineWidget/behavior.js';
@@ -51,7 +51,7 @@ function vtkSplineWidget(publicAPI, model) {
   // --------------------------------------------------------------------------
 
   // Default manipulator
-  publicAPI.setManipulator(model.manipulator || model.manipulator || vtkPlanePointManipulator.newInstance({
+  publicAPI.setManipulator(model.manipulator || model.manipulator || vtkPlaneManipulator.newInstance({
     useCameraNormal: true
   }));
 }

package/Widgets/Widgets3D/TransformControlsWidget/behavior.js

@@ -0,0 +1,180 @@
+import { quat, vec3 } from 'gl-matrix';
+import { m as macro } from '../../../macros2.js';
+import vtkBoundingBox from '../../../Common/DataModel/BoundingBox.js';
+import vtkPlaneManipulator from '../../Manipulators/PlaneManipulator.js';
+import vtkLineManipulator from '../../Manipulators/LineManipulator.js';
+
+function widgetBehavior(publicAPI, model) {
+  let isDragging = false;
+  model.rotationManipulator = vtkPlaneManipulator.newInstance();
+  model.lineManipulator = vtkLineManipulator.newInstance();
+  const rotateState = {
+    startQuat: quat.create(),
+    dragStartVec: [0, 0, 0]
+  };
+  const scaleState = {
+    startDistFromOrigin: 0,
+    startScale: 1
+  };
+  const translateState = {
+    startPos: 0,
+    dragStartCoord: [0, 0, 0]
+  };
+  publicAPI.getBounds = () => [...vtkBoundingBox.INIT_BOUNDS];
+  publicAPI.setDisplayCallback = callback => model.representations[0].setDisplayCallback(callback);
+  publicAPI.handleLeftButtonPress = callData => {
+    if (!model.activeState || !model.activeState.getActive() || !model.pickable) {
+      return macro.VOID;
+    }
+    const [type, axis] = model.activeState.getName().split(':');
+    const axisIndex = 'XYZ'.indexOf(axis);
+    if (type === 'translate') {
+      publicAPI.handleTranslateStartEvent(callData, axis, axisIndex);
+    } else if (type === 'scale') {
+      publicAPI.handleScaleStartEvent(callData, axis, axisIndex);
+    } else if (type === 'rotate') {
+      publicAPI.handleRotateStartEvent(callData, axis, axisIndex);
+    }
+    model._interactor.requestAnimation(publicAPI);
+    return macro.EVENT_ABORT;
+  };
+  publicAPI.handleTranslateStartEvent = (callData, axis, axisIndex) => {
+    model.lineManipulator.setHandleOrigin(model.activeState.getOrigin());
+    model.lineManipulator.setHandleNormal(model.activeState.getDirection());
+    const {
+      worldCoords
+    } = model.lineManipulator.handleEvent(callData, model._apiSpecificRenderWindow);
+    if (worldCoords.length) {
+      isDragging = true;
+      translateState.dragStartCoord = worldCoords;
+      translateState.startPos = model.widgetState.getTransform().getTranslation()[axisIndex];
+    }
+  };
+  publicAPI.handleScaleStartEvent = (callData, axis, axisIndex) => {
+    model.lineManipulator.setHandleOrigin(model.activeState.getOrigin());
+    model.lineManipulator.setHandleNormal(model.activeState.getDirection());
+    const {
+      worldCoords
+    } = model.lineManipulator.handleEvent(callData, model._apiSpecificRenderWindow);
+    if (worldCoords.length) {
+      isDragging = true;
+      scaleState.startScale = model.widgetState.getTransform().getScale()[axisIndex];
+      scaleState.startDistFromOrigin = vec3.dist(worldCoords, model.activeState.getOrigin()) || 0.0001;
+    }
+  };
+  publicAPI.handleRotateStartEvent = (callData, axis) => {
+    model.rotationManipulator.setHandleOrigin(model.activeState.getOrigin());
+    model.rotationManipulator.setHandleNormal(model.activeState.getDirection());
+
+    // compute unit vector from center of rotation
+    // to the click point on the plane defined by
+    // the center of rotation and the rotation normal.
+    const {
+      worldCoords
+    } = model.rotationManipulator.handleEvent(callData, model._apiSpecificRenderWindow);
+    if (worldCoords.length) {
+      isDragging = true;
+      vec3.sub(rotateState.dragStartVec, worldCoords, model.activeState.getOrigin());
+      vec3.normalize(rotateState.dragStartVec, rotateState.dragStartVec);
+      rotateState.startQuat = model.widgetState.getTransform().getRotation();
+    }
+  };
+  publicAPI.handleMouseMove = callData => {
+    if (isDragging && model.pickable) {
+      return publicAPI.handleEvent(callData);
+    }
+    return macro.VOID;
+  };
+  publicAPI.handleLeftButtonRelease = () => {
+    if (isDragging && model.pickable) {
+      model._interactor.cancelAnimation(publicAPI);
+    }
+    isDragging = false;
+    model.widgetState.deactivate();
+  };
+  publicAPI.handleEvent = callData => {
+    if (model.pickable && model.activeState && model.activeState.getActive()) {
+      const [type, axis] = model.activeState.getName().split(':');
+      const axisIndex = 'XYZ'.indexOf(axis);
+      if (type === 'translate') {
+        return publicAPI.handleTranslateEvent(callData, axis, axisIndex);
+      }
+      if (type === 'scale') {
+        return publicAPI.handleScaleEvent(callData, axis, axisIndex);
+      }
+      if (type === 'rotate') {
+        return publicAPI.handleRotateEvent(callData, axis, axisIndex);
+      }
+    }
+    return macro.VOID;
+  };
+  publicAPI.handleTranslateEvent = (callData, axis, axisIndex) => {
+    model.lineManipulator.setHandleOrigin(model.activeState.getOrigin());
+    model.lineManipulator.setHandleNormal(model.activeState.getDirection());
+    const {
+      worldCoords
+    } = model.lineManipulator.handleEvent(callData, model._apiSpecificRenderWindow);
+    if (worldCoords.length) {
+      const positiveDir = [0, 0, 0];
+      positiveDir[axisIndex] = 1;
+      const toWorldCoords = [0, 0, 0];
+      vec3.sub(toWorldCoords, worldCoords, translateState.dragStartCoord);
+      const dir = Math.sign(vec3.dot(positiveDir, toWorldCoords));
+      const dist = vec3.len(toWorldCoords);
+      const delta = dir * dist;
+      const translation = model.widgetState.getTransform().getTranslation();
+      translation[axisIndex] = translateState.startPos + delta;
+      model.widgetState.getTransform().setTranslation(translation);
+    }
+  };
+  publicAPI.handleScaleEvent = (callData, axis, axisIndex) => {
+    model.lineManipulator.setHandleOrigin(model.activeState.getOrigin());
+    model.lineManipulator.setHandleNormal(model.activeState.getDirection());
+    const {
+      worldCoords
+    } = model.lineManipulator.handleEvent(callData, model._apiSpecificRenderWindow);
+    if (worldCoords.length) {
+      const dist = vec3.dist(model.activeState.getOrigin(), worldCoords);
+      const scale = dist / scaleState.startDistFromOrigin * scaleState.startScale;
+      const scales = model.widgetState.getTransform().getScale();
+      scales[axisIndex] = scale;
+      model.widgetState.getTransform().setScale(scales);
+    }
+  };
+  publicAPI.handleRotateEvent = callData => {
+    model.rotationManipulator.setHandleOrigin(model.activeState.getOrigin());
+    model.rotationManipulator.setHandleNormal(model.activeState.getDirection());
+    const {
+      worldCoords
+    } = model.rotationManipulator.handleEvent(callData, model._apiSpecificRenderWindow);
+    const curPointerVec = [0, 0, 0];
+    if (worldCoords.length) {
+      vec3.sub(curPointerVec, worldCoords, model.activeState.getOrigin());
+      vec3.normalize(curPointerVec, curPointerVec);
+      const angle = vec3.angle(rotateState.dragStartVec, curPointerVec);
+      const signVec = [0, 0, 0];
+      vec3.cross(signVec, curPointerVec, rotateState.dragStartVec);
+      vec3.normalize(signVec, signVec);
+      const sign = vec3.dot(signVec, model.activeState.getDirection());
+      const q = quat.create();
+      quat.setAxisAngle(q, model.activeState.getDirection(), -sign * angle);
+      quat.mul(q, q, rotateState.startQuat);
+      quat.normalize(q, q);
+
+      // do not amplify fp errors when editing a particular direction
+      const direction = model.activeState.getDirection();
+      model.widgetState.getTransform().setRotation(q);
+      model.activeState.setDirection(direction);
+    }
+    return macro.EVENT_ABORT;
+  };
+
+  // --------------------------------------------------------------------------
+  // initialization
+  // --------------------------------------------------------------------------
+
+  model.camera = model._renderer.getActiveCamera();
+  model.classHierarchy.push('vtkTransformControlsWidgetProp');
+}
+
+export { widgetBehavior as default };

package/Widgets/Widgets3D/TransformControlsWidget/constants.js

@@ -0,0 +1,15 @@
+const ROTATE_HANDLE_PIXEL_SCALE = 240;
+const TRANSLATE_HANDLE_RADIUS = 3;
+const SCALE_HANDLE_RADIUS = 3;
+const SCALE_HANDLE_CUBE_SIDE_LENGTH = 20;
+const SCALE_HANDLE_PIXEL_SCALE = 320;
+const TransformMode = {
+  TRANSLATE: 'translate',
+  SCALE: 'scale',
+  ROTATE: 'rotate'
+};
+var constants = {
+  TransformMode
+};
+
+export { ROTATE_HANDLE_PIXEL_SCALE, SCALE_HANDLE_CUBE_SIDE_LENGTH, SCALE_HANDLE_PIXEL_SCALE, SCALE_HANDLE_RADIUS, TRANSLATE_HANDLE_RADIUS, TransformMode, constants as default };

package/Widgets/Widgets3D/TransformControlsWidget/state.js

@@ -0,0 +1,157 @@
+import vtkStateBuilder from '../../Core/StateBuilder.js';
+import { SCALE_HANDLE_PIXEL_SCALE, ROTATE_HANDLE_PIXEL_SCALE } from './constants.js';
+
+function stateGenerator() {
+  const transformState = vtkStateBuilder.createBuilder().addField({
+    name: 'translation',
+    initialValue: [0, 0, 0]
+  }).addField({
+    name: 'scale',
+    initialValue: [1, 1, 1]
+  }).addField({
+    name: 'rotation',
+    initialValue: [0, 0, 0, 1]
+  }).build();
+  return vtkStateBuilder.createBuilder().addStateFromInstance({
+    labels: [],
+    name: 'transform',
+    instance: transformState
+  })
+
+  // translate state
+  .addStateFromMixin({
+    labels: ['handles', 'translateHandles'],
+    mixins: ['name', 'origin', 'color3', 'scale3', 'orientation', 'visible'],
+    name: 'translateHandleZ',
+    initialValues: {
+      name: 'translate:Z',
+      scale3: [1, 1, SCALE_HANDLE_PIXEL_SCALE],
+      origin: [0, 0, 0],
+      color3: [0, 255, 0],
+      // these are fixed to the world axes
+      up: [0, 1, 0],
+      right: [1, 0, 0],
+      direction: [0, 0, 1]
+    }
+  }).addStateFromMixin({
+    labels: ['handles', 'translateHandles'],
+    mixins: ['name', 'origin', 'color3', 'scale3', 'orientation', 'visible'],
+    name: 'translateHandleX',
+    initialValues: {
+      name: 'translate:X',
+      scale3: [1, 1, SCALE_HANDLE_PIXEL_SCALE],
+      origin: [0, 0, 0],
+      color3: [0, 0, 255],
+      // these are fixed to the world axes
+      up: [0, 1, 0],
+      right: [0, 0, -1],
+      direction: [1, 0, 0]
+    }
+  }).addStateFromMixin({
+    labels: ['handles', 'translateHandles'],
+    mixins: ['name', 'origin', 'color3', 'scale3', 'orientation', 'visible'],
+    name: 'translateHandleY',
+    initialValues: {
+      name: 'translate:Y',
+      scale3: [1, 1, SCALE_HANDLE_PIXEL_SCALE],
+      origin: [0, 0, 0],
+      color3: [255, 0, 0],
+      // these are fixed to the world axes
+      up: [0, 0, 1],
+      right: [1, 0, 0],
+      direction: [0, 1, 0]
+    }
+  })
+
+  // scale state
+  .addStateFromMixin({
+    labels: ['handles', 'scaleHandles'],
+    mixins: ['name', 'origin', 'color3', 'scale3', 'orientation', 'visible'],
+    name: 'scaleHandleZ',
+    initialValues: {
+      name: 'scale:Z',
+      scale3: [1, 1, SCALE_HANDLE_PIXEL_SCALE],
+      origin: [0, 0, 0],
+      color3: [0, 255, 0],
+      // these are set via setHandleOrientationsFromQuat
+      up: [0, 0, 1],
+      right: [0, 1, 0],
+      direction: [1, 0, 0]
+    }
+  }).addStateFromMixin({
+    labels: ['handles', 'scaleHandles'],
+    mixins: ['name', 'origin', 'color3', 'scale3', 'orientation', 'visible'],
+    name: 'scaleHandleX',
+    initialValues: {
+      name: 'scale:X',
+      scale3: [1, 1, SCALE_HANDLE_PIXEL_SCALE],
+      origin: [0, 0, 0],
+      color3: [0, 0, 255],
+      // these are set via setHandleOrientationsFromQuat
+      up: [1, 0, 0],
+      right: [0, -1, 0],
+      direction: [0, 0, 1]
+    }
+  }).addStateFromMixin({
+    labels: ['handles', 'scaleHandles'],
+    mixins: ['name', 'origin', 'color3', 'scale3', 'orientation', 'visible'],
+    name: 'scaleHandleY',
+    initialValues: {
+      name: 'scale:Y',
+      scale3: [1, 1, SCALE_HANDLE_PIXEL_SCALE],
+      origin: [0, 0, 0],
+      color3: [255, 0, 0],
+      // these are set via setHandleOrientationsFromQuat
+      up: [0, 1, 0],
+      right: [1, 0, 0],
+      direction: [0, 0, 1]
+    }
+  })
+
+  // rotation state
+  .addStateFromMixin({
+    labels: ['handles', 'rotateHandles'],
+    mixins: ['name', 'origin', 'color3', 'scale1', 'orientation', 'visible'],
+    name: 'rotateHandleZ',
+    initialValues: {
+      name: 'rotate:Z',
+      scale1: ROTATE_HANDLE_PIXEL_SCALE,
+      origin: [0, 0, 0],
+      color3: [0, 255, 0],
+      // these are set via setHandleOrientationsFromQuat
+      up: [0, 1, 0],
+      right: [1, 0, 0],
+      direction: [0, 0, 1]
+    }
+  }).addStateFromMixin({
+    labels: ['handles', 'rotateHandles'],
+    mixins: ['name', 'origin', 'color3', 'scale1', 'orientation', 'visible'],
+    name: 'rotateHandleX',
+    initialValues: {
+      name: 'rotate:X',
+      scale1: ROTATE_HANDLE_PIXEL_SCALE,
+      origin: [0, 0, 0],
+      color3: [0, 0, 255],
+      // these are set via setHandleOrientationsFromQuat
+      up: [0, 1, 0],
+      right: [0, 0, -1],
+      direction: [1, 0, 0]
+    }
+  }).addStateFromMixin({
+    labels: ['handles', 'rotateHandles'],
+    mixins: ['name', 'origin', 'color3', 'scale1', 'orientation', 'visible'],
+    name: 'rotateHandleY',
+    initialValues: {
+      name: 'rotate:Y',
+      scale1: ROTATE_HANDLE_PIXEL_SCALE,
+      origin: [0, 0, 0],
+      color3: [255, 0, 0],
+      // these are set via setHandleOrientationsFromQuat
+      up: [0, 0, 1],
+      right: [1, 0, 0],
+      direction: [0, 1, 0]
+    }
+  }).build();
+}
+
+export { stateGenerator as default };

package/Widgets/Widgets3D/TransformControlsWidget.js

@@ -0,0 +1,147 @@
+import { mat3 } from 'gl-matrix';
+import { m as macro } from '../../macros2.js';
+import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
+import vtkTranslateTransformHandleRepresentation from '../Representations/TranslateTransformHandleRepresentation.js';
+import vtkScaleTransformHandleRepresentation from '../Representations/ScaleTransformHandleRepresentation.js';
+import vtkRotateTransformHandleRepresentation from '../Representations/RotateTransformHandleRepresentation.js';
+import { TransformMode, TRANSLATE_HANDLE_RADIUS, SCALE_HANDLE_RADIUS, SCALE_HANDLE_CUBE_SIDE_LENGTH, SCALE_HANDLE_PIXEL_SCALE } from './TransformControlsWidget/constants.js';
+import widgetBehavior from './TransformControlsWidget/behavior.js';
+import stateGenerator from './TransformControlsWidget/state.js';
+
+function updateHandleTransforms(widgetState) {
+  const transformState = widgetState.getTransform();
+  const sx = widgetState.getScaleHandleX();
+  const sy = widgetState.getScaleHandleY();
+  const sz = widgetState.getScaleHandleZ();
+  const hx = widgetState.getRotateHandleX();
+  const hy = widgetState.getRotateHandleY();
+  const hz = widgetState.getRotateHandleZ();
+
+  // translation
+  widgetState.getStatesWithLabel('handles').forEach(state => {
+    state.setOrigin(transformState.getTranslation());
+  });
+
+  // rotation
+  const m3 = mat3.create();
+  mat3.fromQuat(m3, transformState.getRotation());
+  [sx, hx].forEach(state => {
+    state.setDirection(m3.slice(0, 3));
+    state.setUp(m3.slice(3, 6).map(c => -c));
+    state.setRight(m3.slice(6, 9));
+  });
+  [sy, hy].forEach(state => {
+    state.setDirection(m3.slice(3, 6));
+    state.setUp(m3.slice(6, 9));
+    state.setRight(m3.slice(0, 3));
+  });
+  [sz, hz].forEach(state => {
+    state.setDirection(m3.slice(6, 9));
+    state.setUp(m3.slice(3, 6));
+    state.setRight(m3.slice(0, 3));
+  });
+}
+
+// ----------------------------------------------------------------------------
+// Factory
+// ----------------------------------------------------------------------------
+
+function vtkTransformControlsWidget(publicAPI, model) {
+  model.classHierarchy.push('vtkTransformControlsWidget');
+
+  // --- Widget Requirement ---------------------------------------------------
+
+  model.behavior = widgetBehavior;
+  model.widgetState = stateGenerator();
+  model.methodsToLink = ['scaleInPixels', 'activeScaleFactor', 'useActiveColor', 'activeColor'];
+  publicAPI.getRepresentationsForViewType = viewType => {
+    switch (viewType) {
+      default:
+        return [{
+          builder: vtkTranslateTransformHandleRepresentation,
+          labels: ['translateHandles'],
+          initialValues: {
+            radius: TRANSLATE_HANDLE_RADIUS,
+            glyphResolution: 12,
+            coneSource: {
+              radius: 8,
+              height: 0.05,
+              direction: [0, 1, 0]
+            }
+          }
+        }, {
+          builder: vtkScaleTransformHandleRepresentation,
+          labels: ['scaleHandles'],
+          initialValues: {
+            radius: SCALE_HANDLE_RADIUS,
+            glyphResolution: 12,
+            cubeSource: {
+              xLength: SCALE_HANDLE_CUBE_SIDE_LENGTH,
+              yLength: SCALE_HANDLE_CUBE_SIDE_LENGTH / SCALE_HANDLE_PIXEL_SCALE,
+              zLength: SCALE_HANDLE_CUBE_SIDE_LENGTH
+            }
+          }
+        }, {
+          builder: vtkRotateTransformHandleRepresentation,
+          labels: ['rotateHandles']
+        }];
+    }
+  };
+  publicAPI.updateHandleVisibility = () => {
+    model.widgetState.getStatesWithLabel('translateHandles').forEach(state => {
+      state.setVisible(model.mode === 'translate');
+    });
+    model.widgetState.getStatesWithLabel('scaleHandles').forEach(state => {
+      state.setVisible(model.mode === 'scale');
+    });
+    model.widgetState.getStatesWithLabel('rotateHandles').forEach(state => {
+      state.setVisible(model.mode === 'rotate');
+    });
+  };
+  model._onModeChanged = () => {
+    publicAPI.updateHandleVisibility();
+  };
+
+  // --- Widget Requirement ---------------------------------------------------
+
+  // sync translation/scale/rotation states to the handle states
+  const transformSubscription = model.widgetState.getTransform().onModified(state => {
+    updateHandleTransforms(model.widgetState);
+  });
+  publicAPI.delete = macro.chain(publicAPI.delete, () => {
+    transformSubscription.unsubscribe();
+  });
+  updateHandleTransforms(model.widgetState);
+  publicAPI.updateHandleVisibility();
+}
+
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  mode: TransformMode.TRANSLATE
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+  vtkAbstractWidgetFactory.extend(publicAPI, model, initialValues);
+  macro.setGet(publicAPI, model, ['mode']);
+  macro.get(publicAPI, model, ['lineManipulator', 'rotateManipulator']);
+  vtkTransformControlsWidget(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkTransformControlsWidget');
+
+// ----------------------------------------------------------------------------
+
+var vtkTransformControlsWidget$1 = {
+  newInstance,
+  extend,
+  TransformMode
+};
+
+export { vtkTransformControlsWidget$1 as default, extend, newInstance };

package/Widgets/Widgets3D.js

@@ -12,6 +12,7 @@ import vtkResliceCursorWidget from './Widgets3D/ResliceCursorWidget.js';
 import vtkShapeWidget from './Widgets3D/ShapeWidget.js';
 import vtkSphereWidget from './Widgets3D/SphereWidget.js';
 import vtkSplineWidget from './Widgets3D/SplineWidget.js';
+import vtkTransformControlsWidget from './Widgets3D/TransformControlsWidget.js';
 
 var Widgets3D = {
   vtkAngleWidget,
@@ -27,7 +28,8 @@ var Widgets3D = {
   vtkResliceCursorWidget,
   vtkShapeWidget,
   vtkSphereWidget,
-  vtkSplineWidget
+  vtkSplineWidget,
+  vtkTransformControlsWidget
 };
 
 export { Widgets3D as default };

package/index.d.ts

@@ -58,6 +58,7 @@
 /// <reference path="./Common/DataModel/TriangleStrip.d.ts" />
 /// <reference path="./Common/Transform/LandmarkTransform.d.ts" />
 /// <reference path="./Common/Transform/Transform.d.ts" />
+/// <reference path="./Filters/Core/CleanPolyData.d.ts" />
 /// <reference path="./Filters/Core/ThresholdPoints.d.ts" />
 /// <reference path="./Filters/General/AppendPolyData.d.ts" />
 /// <reference path="./Filters/General/ClipClosedSurface.d.ts" />

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "34.11.3",
+  "version": "34.13.0",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",
@@ -121,11 +121,11 @@
     "style-loader": "3.3.1",
     "tape": "5.5.3",
     "typescript": "^5.8.3",
-    "webpack": "5.97.1",
+    "webpack": "^5.97.1",
     "webpack-bundle-analyzer": "4.5.0",
-    "webpack-cli": "5.1.4",
+    "webpack-cli": "^5.1.4",
     "webpack-dashboard": "3.3.7",
-    "webpack-dev-server": "^5.2.2",
+    "webpack-dev-server": "^4.9.0",
     "webpack-merge": "5.8.0",
     "webpack-notifier": "1.15.0",
     "wslink": "1.12.4",