@kitware/vtk.js 34.11.3 → 34.12.0

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/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;

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();
 }
 

package/Widgets/Widgets3D/LabelWidget.js

@@ -1,7 +1,7 @@
 import { m as macro } from '../../macros2.js';
 import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
-import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
+import vtkPlaneManipulator from '../Manipulators/PlaneManipulator.js';
 import widgetBehavior from './LabelWidget/behavior.js';
 import generateState from './LabelWidget/state.js';
 import { ViewTypes } from '../Core/WidgetManager/Constants.js';
@@ -45,7 +45,7 @@ function vtkLabelWidget(publicAPI, model) {
   // --------------------------------------------------------------------------
 
   // Default manipulator
-  publicAPI.setManipulator(model.manipulator || vtkPlanePointManipulator.newInstance({
+  publicAPI.setManipulator(model.manipulator || vtkPlaneManipulator.newInstance({
     useCameraNormal: true
   }));
 }

package/Widgets/Widgets3D/LineWidget.js

@@ -3,7 +3,7 @@ import { m as macro } from '../../macros2.js';
 import generateState from './LineWidget/state.js';
 import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import vtkArrowHandleRepresentation from '../Representations/ArrowHandleRepresentation.js';
-import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
+import vtkPlaneManipulator from '../Manipulators/PlaneManipulator.js';
 import vtkPolyLineRepresentation from '../Representations/PolyLineRepresentation.js';
 import widgetBehavior from './LineWidget/behavior.js';
 import { Behavior } from '../Representations/WidgetRepresentation/Constants.js';
@@ -145,7 +145,7 @@ function vtkLineWidget(publicAPI, model) {
   });
 
   // Default manipulator
-  publicAPI.setManipulator(model.manipulator || vtkPlanePointManipulator.newInstance({
+  publicAPI.setManipulator(model.manipulator || vtkPlaneManipulator.newInstance({
     useCameraNormal: true
   }));
   publicAPI.delete = macro.chain(publicAPI.delete, () => {

package/Widgets/Widgets3D/PaintWidget.js

@@ -1,7 +1,7 @@
 import { m as macro } from '../../macros2.js';
 import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import vtkCircleContextRepresentation from '../Representations/CircleContextRepresentation.js';
-import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
+import vtkPlaneManipulator from '../Manipulators/PlaneManipulator.js';
 import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
 import widgetBehavior from './PaintWidget/behavior.js';
 import generateState from './PaintWidget/state.js';
@@ -57,7 +57,7 @@ function vtkPaintWidget(publicAPI, model) {
   // --------------------------------------------------------------------------
 
   // Default manipulator
-  publicAPI.setManipulator(model.manipulator || vtkPlanePointManipulator.newInstance({
+  publicAPI.setManipulator(model.manipulator || vtkPlaneManipulator.newInstance({
     useCameraNormal: true
   }));
 }

package/Widgets/Widgets3D/PolyLineWidget.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 widgetBehavior from './PolyLineWidget/behavior.js';
@@ -54,7 +54,7 @@ function vtkPolyLineWidget(publicAPI, model) {
   // --------------------------------------------------------------------------
 
   // Default manipulator
-  publicAPI.setManipulator(model.manipulator || vtkPlanePointManipulator.newInstance({
+  publicAPI.setManipulator(model.manipulator || vtkPlaneManipulator.newInstance({
     useCameraFocalPoint: true,
     useCameraNormal: true
   }));

package/Widgets/Widgets3D/RectangleWidget.js

@@ -1,5 +1,5 @@
 import { m as macro } from '../../macros2.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 vtkRectangleContextRepresentation from '../Representations/RectangleContextRepresentation.js';
@@ -39,7 +39,7 @@ function vtkRectangleWidget(publicAPI, model) {
   // initialization
   // --------------------------------------------------------------------------
 
-  model.manipulator = vtkPlanePointManipulator.newInstance({
+  model.manipulator = vtkPlaneManipulator.newInstance({
     useCameraNormal: true
   });
 }

package/Widgets/Widgets3D/ResliceCursorWidget.js

@@ -4,7 +4,7 @@ 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';
@@ -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/SphereWidget.js

@@ -1,6 +1,6 @@
 import { e 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "34.11.3",
+  "version": "34.12.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",