@kitware/vtk.js 26.8.2 → 26.9.1

package/BREAKING_CHANGES.md

@@ -3,7 +3,12 @@
 - **ResliceCursorWidget**: vtkResliceCursorContextRepresentation is deprecated and removed.
 Instead, a `vtkSphereHandleRepresentation` is used for `rotation` and `center` handles,
 and a `vtkLineHandleRepresenttion` is used for the axes. `rotateLineInView()` now
-takes an axis name (string, e.g. 'XinY') instead of a substate.
+takes an axis name (string, e.g. 'XinY') instead of a substate. `enableRotation`, `enableTranslation` and `keepOrthogonality` in widgetState are replaced by widget behavior accessors (e.g. `widgetInView.setEnableRotation(false)`). See RCW example.
+  - `widgetState.setShowCenter()` is replaced by `widgetState.getCenterHandle.setVisible()`
+  - `widgetState.setSphereRadius()` is replaced by `widgetState.getCenterHandle().setScale1()` and `widgetState.getStatesWithLabel('rotation').forEach((handle) => handle.setScale1())`
+  - `widgetState.setLineThickness(t)` is replaced by `widgetState.getStatesWithLabel('line').forEach((handle) => handle.setScale3(t,t,t))`
+  - `setScaleInPixels()` should now be set on the widget instead of the `widgetInView`.
+  - `widgetState.setOpacity()` is replaced by `widgetState.getStatesWithLabel('handles').forEach((handle) => handle.setOpacity())`
 - SVGRepresentation and SVG widget support has been fully removed.
 
 ## From 24.x to 25

package/Common/Core/DataArray.js

@@ -161,18 +161,12 @@ var STATIC = {
 function vtkDataArray(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkDataArray');
-
-  function dataChange() {
-    model.ranges = null;
-    publicAPI.modified();
-  }
   /**
    * Resize model.values and copy the old values to the new array.
    * @param {Number} requestedNumTuples Final expected number of tuples; must be >= 0
    * @returns {Boolean} True if a resize occured, false otherwise
    */
 
-
   function resize(requestedNumTuples) {
     if (requestedNumTuples < 0) {
       return false;
@@ -198,19 +192,24 @@ function vtkDataArray(publicAPI, model) {
 
     if (model.size > requestedNumTuples * numComps) {
       model.size = requestedNumTuples * numComps;
-      dataChange();
+      publicAPI.dataChange();
     }
 
     return true;
   }
 
+  publicAPI.dataChange = function () {
+    model.ranges = null;
+    publicAPI.modified();
+  };
+
   publicAPI.resize = function (requestedNumTuples) {
     resize(requestedNumTuples);
     var newSize = requestedNumTuples * publicAPI.getNumberOfComponents();
 
     if (model.size !== newSize) {
       model.size = newSize;
-      dataChange();
+      publicAPI.dataChange();
       return true;
     }
 
@@ -243,7 +242,7 @@ function vtkDataArray(publicAPI, model) {
   publicAPI.setComponent = function (tupleIdx, compIdx, value) {
     if (value !== model.values[tupleIdx * model.numberOfComponents + compIdx]) {
       model.values[tupleIdx * model.numberOfComponents + compIdx] = value;
-      dataChange();
+      publicAPI.dataChange();
     }
   };
 
@@ -448,7 +447,7 @@ function vtkDataArray(publicAPI, model) {
       model.numberOfComponents = 1;
     }
 
-    dataChange();
+    publicAPI.dataChange();
   }; // Override serialization support
 
 

package/Common/Core/ScalarsToColors.d.ts

@@ -124,10 +124,18 @@ export interface vtkScalarsToColors extends vtkObject {
 	getVectorSize(): number;
 
 	/**
-	 * 
+	 * @see areScalarsOpaque
 	 */
 	isOpaque(): boolean;
 
+	/**
+	 * Returns false if scalars are Uint8 LA or RGBA with A < 255,
+	 * otherwise rely on getAlpha() in case of direct mapping,
+	 * otherwise return isOpaque()
+	 * @see isOpaque, getAlpha
+	 */
+	areScalarsOpaque(scalars, colorMode, componentIn): boolean;
+
 	/**
 	 * 
 	 * @param newColors 

package/Common/Core/ScalarsToColors.js

@@ -504,6 +504,28 @@ function vtkScalarsToColors(publicAPI, model) {
   publicAPI.getRange = function () {
     return publicAPI.getMappingRange();
   };
+
+  publicAPI.areScalarsOpaque = function (scalars, colorMode, componentIn) {
+    if (!scalars) {
+      return publicAPI.isOpaque();
+    }
+
+    var numberOfComponents = scalars.getNumberOfComponents(); // map scalars through lookup table only if needed
+
+    if (colorMode === ColorMode.DEFAULT && scalars.getDataType() === VtkDataTypes.UNSIGNED_CHAR || colorMode === ColorMode.DIRECT_SCALARS) {
+      // we will be using the scalars directly, so look at the number of
+      // components and the range
+      if (numberOfComponents === 3 || numberOfComponents === 1) {
+        return model.alpha >= 1.0;
+      } // otherwise look at the range of the alpha channel
+
+
+      var range = scalars.getRange(numberOfComponents - 1);
+      return range[0] === 255;
+    }
+
+    return true;
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------

package/Filters/General/ImageMarchingCubes.js

@@ -268,8 +268,9 @@ function vtkImageMarchingCubes(publicAPI, model) {
           publicAPI.produceTriangles(model.contourValue, i, j, k, extent, slice, dims, origin, spacing, s, pBuffer, tBuffer, nBuffer);
         }
       }
-    } // Update output
+    }
 
+    edgeLocator.initialize(); // Update output
 
     var polydata = vtkPolyData.newInstance();
     polydata.getPoints().setData(new Float32Array(pBuffer), 3);

package/Rendering/Core/Mapper.js

@@ -375,12 +375,21 @@ function vtkMapper(publicAPI, model) {
   };
 
   publicAPI.getIsOpaque = function () {
+    var input = publicAPI.getInputData();
+    var gasResult = publicAPI.getAbstractScalars(input, model.scalarMode, model.arrayAccessMode, model.arrayId, model.colorByArrayName);
+    var scalars = gasResult.scalars;
+
+    if (!model.scalarVisibility || scalars == null) {
+      // No scalar colors.
+      return true;
+    }
+
     var lut = publicAPI.getLookupTable();
 
     if (lut) {
       // Ensure that the lookup table is built
       lut.build();
-      return lut.isOpaque();
+      return lut.areScalarsOpaque(scalars, model.colorMode, -1);
     }
 
     return true;

package/Rendering/OpenGL/Actor.js

@@ -37,9 +37,10 @@ function vtkOpenGLActor(publicAPI, model) {
         }
       }
     }
-  };
+  }; // render both opaque and translucent actors
 
-  publicAPI.traverseOpaqueZBufferPass = function (renderPass) {
+
+  publicAPI.traverseZBufferPass = function (renderPass) {
     if (!model.renderable || !model.renderable.getNestedVisibility() || model._openGLRenderer.getSelector() && !model.renderable.getNestedPickable()) {
       return;
     }
@@ -47,6 +48,11 @@ function vtkOpenGLActor(publicAPI, model) {
     publicAPI.apply(renderPass, true);
     model.oglmapper.traverse(renderPass);
     publicAPI.apply(renderPass, false);
+  }; // only render opaque actors
+
+
+  publicAPI.traverseOpaqueZBufferPass = function (renderPass) {
+    return publicAPI.traverseOpaquePass(renderPass);
   }; // we draw textures, then mapper, then post pass textures
 
 
@@ -103,6 +109,10 @@ function vtkOpenGLActor(publicAPI, model) {
     }
   };
 
+  publicAPI.zBufferPass = function (prepass, renderPass) {
+    return publicAPI.opaquePass(prepass, renderPass);
+  };
+
   publicAPI.opaqueZBufferPass = function (prepass, renderPass) {
     return publicAPI.opaquePass(prepass, renderPass);
   };

package/Rendering/OpenGL/Camera.js

@@ -29,6 +29,7 @@ function vtkOpenGLCamera(publicAPI, model) {
   };
 
   publicAPI.translucentPass = publicAPI.opaquePass;
+  publicAPI.zBufferPass = publicAPI.opaquePass;
   publicAPI.opaqueZBufferPass = publicAPI.opaquePass;
   publicAPI.volumePass = publicAPI.opaquePass;
 

package/Rendering/OpenGL/ForwardPass.js

@@ -40,7 +40,7 @@ function vtkForwardPass(publicAPI, model) {
           publicAPI.setCurrentOperation('queryPass');
           renNode.traverse(publicAPI); // do we need to capture a zbuffer?
 
-          if (model.opaqueActorCount > 0 && model.volumeCount > 0 || model.depthRequested) {
+          if ((model.opaqueActorCount > 0 || model.translucentActorCount > 0) && model.volumeCount > 0 || model.depthRequested) {
             var size = viewNode.getFramebufferSize(); // make sure the framebuffer is setup
 
             if (model.framebuffer === null) {
@@ -56,8 +56,11 @@ function vtkForwardPass(publicAPI, model) {
               model.framebuffer.populateFramebuffer();
             }
 
-            model.framebuffer.bind();
-            publicAPI.setCurrentOperation('opaqueZBufferPass');
+            model.framebuffer.bind(); // opaqueZBufferPass only renders opaque actors
+            // zBufferPass renders both translucent and opaque actors
+            // we want to be able to pick translucent actors
+
+            publicAPI.setCurrentOperation('zBufferPass');
             renNode.traverse(publicAPI);
             model.framebuffer.restorePreviousBindingsAndBuffers(); // reset now that we have done it
 

package/Rendering/OpenGL/ImageMapper.js

@@ -68,7 +68,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     }
   };
 
-  publicAPI.opaqueZBufferPass = function (prepass) {
+  publicAPI.zBufferPass = function (prepass) {
     if (prepass) {
       model.haveSeenDepthRequest = true;
       model.renderDepth = true;
@@ -77,6 +77,10 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     }
   };
 
+  publicAPI.opaqueZBufferPass = function (prepass) {
+    return publicAPI.zBufferPass(prepass);
+  };
+
   publicAPI.opaquePass = function (prepass) {
     if (prepass) {
       publicAPI.render();

package/Rendering/OpenGL/ImageSlice.js

@@ -29,8 +29,20 @@ function vtkOpenGLImageSlice(publicAPI, model) {
     }
   };
 
+  publicAPI.traverseZBufferPass = function (renderPass) {
+    if (!model.renderable || !model.renderable.getNestedVisibility() || model._openGLRenderer.getSelector() && !model.renderable.getNestedPickable()) {
+      return;
+    }
+
+    publicAPI.apply(renderPass, true);
+    model.children.forEach(function (child) {
+      child.traverse(renderPass);
+    });
+    publicAPI.apply(renderPass, false);
+  };
+
   publicAPI.traverseOpaqueZBufferPass = function (renderPass) {
-    publicAPI.traverseOpaquePass(renderPass);
+    return publicAPI.traverseOpaquePass(renderPass);
   }; // we draw textures, then mapper, then post pass textures
 
 
@@ -73,6 +85,10 @@ function vtkOpenGLImageSlice(publicAPI, model) {
     }
   };
 
+  publicAPI.zBufferPass = function (prepass, renderPass) {
+    return publicAPI.opaquePass(prepass, renderPass);
+  };
+
   publicAPI.opaqueZBufferPass = function (prepass, renderPass) {
     return publicAPI.opaquePass(prepass, renderPass);
   }; // Renders myself

package/Rendering/OpenGL/OrderIndependentTranslucentPass.js

@@ -151,6 +151,7 @@ function vtkOpenGLOrderIndependentTranslucentPass(publicAPI, model) {
     // have the forward pass use a texture backed zbuffer
 
     if (forwardPass.getOpaqueActorCount() > 0) {
+      // Don't use zBufferPass as it will also render the depth of translucent actors
       forwardPass.setCurrentOperation('opaqueZBufferPass');
       renNode.traverse(forwardPass);
     }

package/Rendering/OpenGL/PolyDataMapper.js

@@ -72,7 +72,7 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
     }
   };
 
-  publicAPI.opaqueZBufferPass = function (prepass) {
+  publicAPI.zBufferPass = function (prepass) {
     if (prepass) {
       model.haveSeenDepthRequest = true;
       model.renderDepth = true;
@@ -81,6 +81,10 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
     }
   };
 
+  publicAPI.opaqueZBufferPass = function (prepass) {
+    return publicAPI.zBufferPass(prepass);
+  };
+
   publicAPI.opaquePass = function (prepass) {
     if (prepass) {
       publicAPI.render();

package/Rendering/OpenGL/RenderWindow.js

@@ -911,7 +911,26 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
     model.canvas.removeEventListener('webglcontextrestored', publicAPI.restoreContext);
   }
 
-  publicAPI.delete = macro.chain(clearEvents, publicAPI.delete, publicAPI.setViewStream, deleteGLContext);
+  publicAPI.delete = macro.chain(clearEvents, publicAPI.delete, publicAPI.setViewStream, deleteGLContext); // Do not trigger modified for performance reasons
+
+  publicAPI.setActiveFramebuffer = function (newActiveFramebuffer) {
+    model.activeFramebuffer = newActiveFramebuffer;
+  };
+
+  var superSetSize = publicAPI.setSize;
+
+  publicAPI.setSize = function (width, height) {
+    var modified = superSetSize(width, height);
+
+    if (modified) {
+      publicAPI.invokeWindowResizeEvent({
+        width: width,
+        height: height
+      });
+    }
+
+    return modified;
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
@@ -979,13 +998,10 @@ function extend(publicAPI, model) {
   macro.event(publicAPI, model, 'imageReady');
   macro.event(publicAPI, model, 'haveVRDisplay'); // Build VTK API
 
-  macro.get(publicAPI, model, ['shaderCache', 'textureUnitManager', 'webgl2', 'vrDisplay', 'useBackgroundImage', 'xrSupported']);
-  macro.setGet(publicAPI, model, ['initialized', 'context', 'canvas', 'renderPasses', 'notifyStartCaptureImage', 'defaultToWebgl2', 'cursor', 'useOffScreen', // might want to make this not call modified as
-  // we change the active framebuffer a lot. Or maybe
-  // only mark modified if the size or depth
-  // of the buffer has changed
-  'activeFramebuffer']);
-  macro.setGetArray(publicAPI, model, ['size'], 2); // Object methods
+  macro.get(publicAPI, model, ['shaderCache', 'textureUnitManager', 'webgl2', 'vrDisplay', 'useBackgroundImage', 'xrSupported', 'activeFramebuffer']);
+  macro.setGet(publicAPI, model, ['initialized', 'context', 'canvas', 'renderPasses', 'notifyStartCaptureImage', 'defaultToWebgl2', 'cursor', 'useOffScreen']);
+  macro.setGetArray(publicAPI, model, ['size'], 2);
+  macro.event(publicAPI, model, 'windowResizeEvent'); // Object methods
 
   vtkOpenGLRenderWindow(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Rendering/OpenGL/Renderer.js

@@ -44,7 +44,7 @@ function vtkOpenGLRenderer(publicAPI, model) {
     return count;
   };
 
-  publicAPI.opaqueZBufferPass = function (prepass) {
+  publicAPI.zBufferPass = function (prepass) {
     if (prepass) {
       var clearMask = 0;
       var gl = model.context;
@@ -72,6 +72,10 @@ function vtkOpenGLRenderer(publicAPI, model) {
 
       gl.enable(gl.DEPTH_TEST);
     }
+  };
+
+  publicAPI.opaqueZBufferPass = function (prepass) {
+    return publicAPI.zBufferPass(prepass);
   }; // Renders myself
 
 

package/Rendering/OpenGL/VolumeMapper.js

@@ -52,7 +52,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
   // intermixed volume rendering
 
 
-  publicAPI.opaqueZBufferPass = function (prepass, renderPass) {
+  publicAPI.zBufferPass = function (prepass, renderPass) {
     if (prepass) {
       var zbt = renderPass.getZBufferTexture();
 
@@ -60,6 +60,10 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
         model.zBufferTexture = zbt;
       }
     }
+  };
+
+  publicAPI.opaqueZBufferPass = function (prepass, renderPass) {
+    return publicAPI.zBufferPass(prepass, renderPass);
   }; // Renders myself
 
 

package/Widgets/Core/AbstractWidget.js

@@ -87,11 +87,7 @@ function vtkAbstractWidget(publicAPI, model) {
   };
 
   publicAPI.getViewWidgets = function () {
-    return model._factory.getViewIds().map(function (viewId) {
-      return model._factory.getWidgetForView({
-        viewId: viewId
-      });
-    });
+    return model._factory.getViewWidgets();
   }; // --------------------------------------------------------------------------
   // Initialization calls
   // --------------------------------------------------------------------------

package/Widgets/Core/AbstractWidgetFactory.d.ts

@@ -27,6 +27,11 @@ export interface vtkAbstractWidgetFactory {
    */
   getViewIds(): string[];
 
+  /**
+   * Get a list of all the instances of the widget.
+   */
+  getViewWidgets(): vtkAbstractWidget[];
+
   /**
    * Set the visiblity on each underlying view widget.
    * 

package/Widgets/Core/AbstractWidgetFactory.js

@@ -121,6 +121,10 @@ function vtkAbstractWidgetFactory(publicAPI, model) {
 
   publicAPI.getViewIds = function () {
     return Object.keys(viewToWidget);
+  };
+
+  publicAPI.getViewWidgets = function () {
+    return Object.values(viewToWidget);
   }; // --------------------------------------------------------------------------
   // Widget visibility / enable
   // --------------------------------------------------------------------------

package/Widgets/Core/StateBuilder/color3Mixin.js

@@ -6,13 +6,15 @@ import macro from '../../../macros.js';
  */
 
 var DEFAULT_VALUES = {
-  color3: [255, 255, 255]
+  color3: [255, 255, 255],
+  opacity: 255
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
   macro.setGetArray(publicAPI, model, ['color3'], 3, 255);
+  macro.setGet(publicAPI, model, ['opacity']);
 } // ----------------------------------------------------------------------------
 
 var color3 = {

package/Widgets/Core/StateBuilder/originMixin.js

@@ -1,7 +1,16 @@
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../../macros.js';
+import { f as vtkMath } from '../../../Common/Core/Math/index.js';
+import { getPixelWorldHeightAtCoord } from '../WidgetManager.js';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 function vtkOriginMixin(publicAPI, model) {
+  var superClass = _objectSpread({}, publicAPI);
+
   publicAPI.translate = function (dx, dy, dz) {
     var _publicAPI$getOriginB = publicAPI.getOriginByReference(),
         _publicAPI$getOriginB2 = _slicedToArray(_publicAPI$getOriginB, 3),
@@ -11,18 +20,40 @@ function vtkOriginMixin(publicAPI, model) {
 
     publicAPI.setOrigin(x + dx, y + dy, z + dz);
   };
+
+  publicAPI.getOrigin = function (displayScaleParams) {
+    var origin = superClass.getOrigin();
+
+    if (!model.offset) {
+      return origin;
+    }
+
+    if (!displayScaleParams) {
+      return vtkMath.add(origin, model.offset, origin);
+    }
+
+    var pixelWorldHeight = getPixelWorldHeightAtCoord(origin, displayScaleParams);
+    var rendererPixelDims = displayScaleParams.rendererPixelDims;
+    var totalSize = Math.min(rendererPixelDims[0], rendererPixelDims[1]);
+    return vtkMath.multiplyAccumulate(origin, model.offset, totalSize * pixelWorldHeight, origin);
+  };
 } // ----------------------------------------------------------------------------
 
+/**
+ * offset: optional offset that can be scaled to pixel screen space.
+ */
+
 
 var DEFAULT_VALUES = {
-  origin: null
+  origin: null,
+  offset: null
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
-  macro.setGetArray(publicAPI, model, ['origin'], 3);
-  vtkOriginMixin(publicAPI);
+  macro.setGetArray(publicAPI, model, ['origin', 'offset'], 3);
+  vtkOriginMixin(publicAPI, model);
 } // ----------------------------------------------------------------------------
 
 var origin = {

package/Widgets/Core/WidgetManager.d.ts

@@ -37,6 +37,14 @@ export interface IRenderingComponents {
  */
 export function extractRenderingComponents(renderer: vtkRenderer): IRenderingComponents;
 
+/**
+ * This method returns the world distance that corresponds to the height of a
+ * single display pixel at a given coordinate. For example, to determine the
+ * (vertical) distance that matches a display distance of 30px for a coordinate
+ * `coord`, you would compute `30 * getPixelWorldHeightAtCoord(coord)`.
+ */
+export function getPixelWorldHeightAtCoord(coord: []): Number;
+
 export interface vtkWidgetManager extends vtkObject {
   /**
    * The the captureOn value. 

package/Widgets/Core/WidgetManager.js

@@ -1,7 +1,8 @@
 import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _regeneratorRuntime from '@babel/runtime/regenerator';
-import { r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
+import { f as vtkMath } from '../../Common/Core/Math/index.js';
 import { FieldAssociations } from '../../Common/DataModel/DataSet/Constants.js';
 import macro from '../../macros.js';
 import WidgetManagerConst from './WidgetManager/Constants.js';
@@ -28,6 +29,26 @@ function extractRenderingComponents(renderer) {
     apiSpecificRenderWindow: apiSpecificRenderWindow,
     camera: camera
   };
+}
+function getPixelWorldHeightAtCoord(worldCoord, displayScaleParams) {
+  var dispHeightFactor = displayScaleParams.dispHeightFactor,
+      cameraPosition = displayScaleParams.cameraPosition,
+      cameraDir = displayScaleParams.cameraDir,
+      isParallel = displayScaleParams.isParallel,
+      rendererPixelDims = displayScaleParams.rendererPixelDims;
+  var scale = 1;
+
+  if (isParallel) {
+    scale = dispHeightFactor;
+  } else {
+    var worldCoordToCamera = _toConsumableArray(worldCoord);
+
+    vtkMath.subtract(worldCoordToCamera, cameraPosition, worldCoordToCamera);
+    scale = vtkMath.dot(worldCoordToCamera, cameraDir) * dispHeightFactor;
+  }
+
+  var rHeight = rendererPixelDims[1];
+  return scale / rHeight;
 } // ----------------------------------------------------------------------------
 // vtkWidgetManager methods
 // ----------------------------------------------------------------------------
@@ -98,7 +119,7 @@ function vtkWidgetManager(publicAPI, model) {
 
       var isParallel = _camera.getParallelProjection();
 
-      var dispHeightFactor = isParallel ? 2 * _camera.getParallelScale() : 2 * Math.tan(radiansFromDegrees(_camera.getViewAngle()) / 2);
+      var dispHeightFactor = isParallel ? 2 * _camera.getParallelScale() : 2 * Math.tan(vtkMath.radiansFromDegrees(_camera.getViewAngle()) / 2);
       model.widgets.forEach(function (w) {
         w.getNestedProps().forEach(function (r) {
           if (r.getScaleInPixels()) {
@@ -327,7 +348,7 @@ function vtkWidgetManager(publicAPI, model) {
 
     model._selector.setFieldAssociation(FieldAssociations.FIELD_ASSOCIATION_POINTS);
 
-    subscriptions.push(model._apiSpecificRenderWindow.onModified(updateDisplayScaleParams));
+    subscriptions.push(model._apiSpecificRenderWindow.onWindowResizeEvent(updateDisplayScaleParams));
     subscriptions.push(model._camera.onModified(updateDisplayScaleParams));
     updateDisplayScaleParams();
     subscriptions.push(model._interactor.onStartAnimation(function () {
@@ -622,7 +643,8 @@ var newInstance = macro.newInstance(extend, 'vtkWidgetManager'); // ------------
 var vtkWidgetManager$1 = {
   newInstance: newInstance,
   extend: extend,
-  Constants: WidgetManagerConst
+  Constants: WidgetManagerConst,
+  getPixelWorldHeightAtCoord: getPixelWorldHeightAtCoord
 };
 
-export { vtkWidgetManager$1 as default, extend, extractRenderingComponents, newInstance };
+export { vtkWidgetManager$1 as default, extend, extractRenderingComponents, getPixelWorldHeightAtCoord, newInstance };

package/Widgets/Representations/CroppingOutlineRepresentation.js

@@ -28,7 +28,7 @@ function vtkCroppingOutlineRepresentation(publicAPI, model) {
     mtime: 0
   });
   allocateArray(model.internalPolyData, 'lines', OUTLINE_ARRAY.length).getData().set(OUTLINE_ARRAY);
-  var applyOrigin = origin(); // --------------------------------------------------------------------------
+  var applyOrigin = origin(publicAPI, model); // --------------------------------------------------------------------------
   // Generic rendering pipeline
   // --------------------------------------------------------------------------
 

package/Widgets/Representations/GlyphRepresentation.js

@@ -7,7 +7,8 @@ import vtkContextRepresentation from './ContextRepresentation.js';
 import vtkSphereSource from '../../Filters/Sources/SphereSource.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import { ScalarMode } from '../../Rendering/Core/Mapper/Constants.js';
-import vtkWidgetRepresentation, { allocateArray, getPixelWorldHeightAtCoord } from './WidgetRepresentation.js';
+import { getPixelWorldHeightAtCoord } from '../Core/WidgetManager.js';
+import vtkWidgetRepresentation, { allocateArray } from './WidgetRepresentation.js';
 import { Behavior } from './WidgetRepresentation/Constants.js';
 import { OrientationModes } from '../../Rendering/Core/Glyph3DMapper/Constants.js';
 
@@ -23,7 +24,7 @@ function origin(publicAPI, model) {
     var j = 0;
 
     for (var i = 0; i < states.length; ++i) {
-      var coord = states[i].getOrigin();
+      var coord = states[i].getOrigin(model.scaleInPixels && model.displayScaleParams);
       points[j++] = coord[0];
       points[j++] = coord[1];
       points[j++] = coord[2];
@@ -39,8 +40,9 @@ function color3(publicAPI, model) {
   return function (polyData, states) {
     model._pipeline.mapper.setColorByArrayName('color');
 
-    var colors = allocateArray(polyData, 'color', states.length, 'Uint8Array', // RGB
-    3).getData();
+    var colorArray = allocateArray(polyData, 'color', states.length, 'Uint8Array', // RGBA
+    4);
+    var colors = colorArray.getData();
     var j = 0;
 
     for (var i = 0; i < states.length; ++i) {
@@ -53,7 +55,10 @@ function color3(publicAPI, model) {
       colors[j++] = c3[0];
       colors[j++] = c3[1];
       colors[j++] = c3[2];
+      colors[j++] = states[i].getOpacity();
     }
+
+    colorArray.dataChange();
   };
 }
 function color(publicAPI, model) {
@@ -278,7 +283,7 @@ function defaultValues(publicAPI, model, initialValues) {
       })
     }, initialValues._pipeline),
     applyMixin: _objectSpread({
-      origin: (_initialValues$applyM = (_initialValues$applyM2 = initialValues.applyMixin) === null || _initialValues$applyM2 === void 0 ? void 0 : _initialValues$applyM2.origin) !== null && _initialValues$applyM !== void 0 ? _initialValues$applyM : origin(),
+      origin: (_initialValues$applyM = (_initialValues$applyM2 = initialValues.applyMixin) === null || _initialValues$applyM2 === void 0 ? void 0 : _initialValues$applyM2.origin) !== null && _initialValues$applyM !== void 0 ? _initialValues$applyM : origin(publicAPI, model),
       noPosition: (_initialValues$applyM3 = (_initialValues$applyM4 = initialValues.applyMixin) === null || _initialValues$applyM4 === void 0 ? void 0 : _initialValues$applyM4.noPosition) !== null && _initialValues$applyM3 !== void 0 ? _initialValues$applyM3 : noPosition(),
       color3: (_initialValues$applyM5 = (_initialValues$applyM6 = initialValues.applyMixin) === null || _initialValues$applyM6 === void 0 ? void 0 : _initialValues$applyM6.color3) !== null && _initialValues$applyM5 !== void 0 ? _initialValues$applyM5 : color3(publicAPI, model),
       color: (_initialValues$applyM7 = (_initialValues$applyM8 = initialValues.applyMixin) === null || _initialValues$applyM8 === void 0 ? void 0 : _initialValues$applyM8.color) !== null && _initialValues$applyM7 !== void 0 ? _initialValues$applyM7 : color(publicAPI, model),

package/Widgets/Representations/ImplicitPlaneRepresentation.js

@@ -11,7 +11,8 @@ import vtkPlane from '../../Common/DataModel/Plane.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkSphereSource from '../../Filters/Sources/SphereSource.js';
 import vtkStateBuilder from '../Core/StateBuilder.js';
-import vtkWidgetRepresentation, { getPixelWorldHeightAtCoord } from './WidgetRepresentation.js';
+import { getPixelWorldHeightAtCoord } from '../Core/WidgetManager.js';
+import vtkWidgetRepresentation from './WidgetRepresentation.js';
 import WidgetManagerConst from '../Core/WidgetManager/Constants.js';
 import PropertyConst from '../../Rendering/Core/Property/Constants.js';
 

package/Widgets/Representations/PolyLineRepresentation.js

@@ -5,7 +5,8 @@ import vtkMapper from '../../Rendering/Core/Mapper.js';
 import { B as areEquals } from '../../Common/Core/Math/index.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkTubeFilter from '../../Filters/General/TubeFilter.js';
-import vtkWidgetRepresentation, { allocateArray, getPixelWorldHeightAtCoord } from './WidgetRepresentation.js';
+import { getPixelWorldHeightAtCoord } from '../Core/WidgetManager.js';
+import vtkWidgetRepresentation, { allocateArray } from './WidgetRepresentation.js';
 import { RenderingTypes } from '../Core/WidgetManager/Constants.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 

package/Widgets/Representations/WidgetRepresentation.js

@@ -1,8 +1,6 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 import vtkProp from '../../Rendering/Core/Prop.js';
-import { f as vtkMath } from '../../Common/Core/Math/index.js';
 import vtkCellArray from '../../Common/Core/CellArray.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkPoints from '../../Common/Core/Points.js';
@@ -96,26 +94,6 @@ function connectPipeline(pipeline) {
   }
 
   pipeline.actor.setMapper(pipeline.mapper);
-}
-function getPixelWorldHeightAtCoord(worldCoord, displayScaleParams) {
-  var dispHeightFactor = displayScaleParams.dispHeightFactor,
-      cameraPosition = displayScaleParams.cameraPosition,
-      cameraDir = displayScaleParams.cameraDir,
-      isParallel = displayScaleParams.isParallel,
-      rendererPixelDims = displayScaleParams.rendererPixelDims;
-  var scale = 1;
-
-  if (isParallel) {
-    scale = dispHeightFactor;
-  } else {
-    var worldCoordToCamera = _toConsumableArray(worldCoord);
-
-    vtkMath.subtract(worldCoordToCamera, cameraPosition, worldCoordToCamera);
-    scale = vtkMath.dot(worldCoordToCamera, cameraDir) * dispHeightFactor;
-  }
-
-  var rHeight = rendererPixelDims[1];
-  return scale / rHeight;
 } // Internal convenient function to create a data array:
 
 function allocateArray(polyData, name, numberOfTuples, dataType, numberOfComponents) {
@@ -362,7 +340,7 @@ function extend(publicAPI, model) {
   // Object methods
   vtkProp.extend(publicAPI, model, defaultValues(initialValues));
   macro.algo(publicAPI, model, 1, 1);
-  macro.get(publicAPI, model, ['labels']);
+  macro.get(publicAPI, model, ['labels', 'displayScaleParams', 'coincidentTopologyParameters']);
   macro.set(publicAPI, model, [{
     type: 'object',
     name: 'displayScaleParams'
@@ -379,8 +357,7 @@ var vtkWidgetRepresentation$1 = {
   extend: extend,
   mergeStyles: mergeStyles,
   applyStyles: applyStyles,
-  connectPipeline: connectPipeline,
-  getPixelWorldHeightAtCoord: getPixelWorldHeightAtCoord
+  connectPipeline: connectPipeline
 };
 
-export { allocateArray, applyStyles, connectPipeline, vtkWidgetRepresentation$1 as default, extend, getPixelWorldHeightAtCoord, mergeStyles };
+export { allocateArray, applyStyles, connectPipeline, vtkWidgetRepresentation$1 as default, extend, mergeStyles };

package/Widgets/Widgets3D/ResliceCursorWidget/behavior.js

@@ -10,7 +10,19 @@ import { InteractionMethodsName, lineNames, ScrollingMethods, planeNameToViewTyp
 function widgetBehavior(publicAPI, model) {
   model._isDragging = false;
   var isScrolling = false;
-  var previousPosition; // FIXME: label information should be accessible from activeState instead of parent state.
+  var previousPosition;
+  macro.setGet(publicAPI, model, ['keepOrthogonality']);
+
+  publicAPI.setEnableTranslation = function (enable) {
+    model.representations[0].setPickable(enable); // line handle
+
+    model.representations[2].setPickable(enable); // center handle
+  };
+
+  publicAPI.setEnableRotation = function (enable) {
+    model.representations[1].setPickable(enable); // rotation handle
+  }; // FIXME: label information should be accessible from activeState instead of parent state.
+
 
   publicAPI.getActiveInteraction = function () {
     if (model.widgetState.getStatesWithLabel('rotation').includes(model.activeState)) {
@@ -245,7 +257,7 @@ function widgetBehavior(publicAPI, model) {
     var newCenter = [oldCenter[0] + movingFactor * dirProj[0], oldCenter[1] + movingFactor * dirProj[1], oldCenter[2] + movingFactor * dirProj[2]];
     newCenter = publicAPI.getBoundedCenter(newCenter);
     model.widgetState.setCenter(newCenter);
-    updateState(model.widgetState, model._factory.getDisplayScaleParams(), model._factory.getRotationHandlePosition());
+    updateState(model.widgetState, model._factory.getScaleInPixels(), model._factory.getRotationHandlePosition());
   };
 
   publicAPI[InteractionMethodsName.TranslateAxis] = function (calldata) {
@@ -274,7 +286,7 @@ function widgetBehavior(publicAPI, model) {
     var newOrigin = multiplyAccumulate(center, axisTranslation, translationDistance, [0, 0, 0]);
     newOrigin = publicAPI.getBoundedCenter(newOrigin);
     model.widgetState.setCenter(newOrigin);
-    updateState(model.widgetState, model._factory.getDisplayScaleParams(), model._factory.getRotationHandlePosition());
+    updateState(model.widgetState, model._factory.getScaleInPixels(), model._factory.getRotationHandlePosition());
   };
 
   publicAPI.getBoundedCenter = function (newCenter) {
@@ -295,7 +307,7 @@ function widgetBehavior(publicAPI, model) {
     var newCenter = add(model.widgetState.getCenter(), translation, []);
     newCenter = publicAPI.getBoundedCenter(newCenter);
     model.widgetState.setCenter(newCenter);
-    updateState(model.widgetState, model._factory.getDisplayScaleParams(), model._factory.getRotationHandlePosition());
+    updateState(model.widgetState, model._factory.getScaleInPixels(), model._factory.getRotationHandlePosition());
   };
 
   publicAPI[InteractionMethodsName.RotateLine] = function (calldata) {
@@ -306,7 +318,7 @@ function widgetBehavior(publicAPI, model) {
     var previousLineDirection = activeLineHandle.getDirection();
     normalize(previousLineDirection);
 
-    if (publicAPI.getActiveRotationPointName() === 'point0') {
+    if (publicAPI.getActiveRotationPointName() === 'point1') {
       multiplyScalar(previousLineDirection, -1);
     }
 
@@ -329,13 +341,13 @@ function widgetBehavior(publicAPI, model) {
     var planeNormal = model.widgetState.getPlanes()[inViewType].normal;
     publicAPI.rotatePlane(viewType, radianAngle, planeNormal);
 
-    if (model.widgetState.getKeepOrthogonality()) {
+    if (publicAPI.getKeepOrthogonality()) {
       var otherLineName = getOtherLineName(lineName);
       var otherPlaneName = getLinePlaneName(otherLineName);
       publicAPI.rotatePlane(planeNameToViewType[otherPlaneName], radianAngle, planeNormal);
     }
 
-    updateState(model.widgetState, model._factory.getDisplayScaleParams(), model._factory.getRotationHandlePosition());
+    updateState(model.widgetState, model._factory.getScaleInPixels(), model._factory.getRotationHandlePosition());
   };
   /**
    * Rotate a specified plane around an other specified plane.

package/Widgets/Widgets3D/ResliceCursorWidget/helpers.js

@@ -6,7 +6,6 @@ import vtkPlane from '../../../Common/DataModel/Plane.js';
 import { s as subtract, l as normalize, j as cross, w as multiplyScalar, m as multiplyAccumulate, S as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../../Common/Core/MatrixBuilder.js';
 import { ViewTypes } from '../../Core/WidgetManager/Constants.js';
-import { getPixelWorldHeightAtCoord } from '../../Representations/WidgetRepresentation.js';
 import { planeNames, lineNames, planeNameToViewType } from './Constants.js';
 
 var EPSILON = 10e-7;
@@ -157,25 +156,15 @@ function getOtherLineName(lineName) {
     return planeName !== linePlaneName && planeName !== lineInPlaneName;
   });
   return "".concat(otherLineName, "in").concat(lineInPlaneName);
-} // Update the extremities and the rotation point coordinate of the line
+} // Compute the offset of the rotation handle origin
 
-function computeRotationHandleOrigin(center, axis, rotationHandlePosition, volumeDiagonalLength, displayScaleParams) {
+function computeRotationHandleOriginOffset(axis, rotationHandlePosition, volumeDiagonalLength, scaleInPixels) {
   // FIXME: p1 and p2 could be placed on the exact boundaries of the volume.
-  var distanceToCenter = volumeDiagonalLength; // displayScaleParams is not null when representation.getScaleInPixels() is true
-
-  if (displayScaleParams) {
-    var pixelWorldHeight = getPixelWorldHeightAtCoord(center, displayScaleParams);
-    var rendererPixelDims = displayScaleParams.rendererPixelDims;
-    var totalSize = Math.min(rendererPixelDims[0], rendererPixelDims[1]) / 2;
-    distanceToCenter = pixelWorldHeight * totalSize;
-  }
-
-  distanceToCenter *= rotationHandlePosition;
-  return multiplyAccumulate(center, axis, distanceToCenter, []);
+  return multiplyScalar(_toConsumableArray(axis), rotationHandlePosition * (scaleInPixels ? 1 : volumeDiagonalLength) / 2);
 } // Update the reslice cursor state according to the three planes normals and the origin
 
 
-function updateState(widgetState, displayScaleParams, rotationHandlePosition) {
+function updateState(widgetState, scaleInPixels, rotationHandlePosition) {
   // Compute line axis
   var xNormal = widgetState.getPlanes()[ViewTypes.YZ_PLANE].normal;
   var yNormal = widgetState.getPlanes()[ViewTypes.XZ_PLANE].normal;
@@ -196,13 +185,13 @@ function updateState(widgetState, displayScaleParams, rotationHandlePosition) {
   lineNames.forEach(function (lineName) {
     var planeName = getLinePlaneName(lineName);
     var inPlaneName = getLineInPlaneName(lineName);
-    var rotationPoint0 = computeRotationHandleOrigin(center, axes["".concat(planeName).concat(inPlaneName)], rotationHandlePosition, pdLength, displayScaleParams[planeNameToViewType[inPlaneName]]);
-    widgetState["getRotationHandle".concat(lineName, "0")]().setOrigin(rotationPoint0);
-    var rotationPoint1 = computeRotationHandleOrigin(center, multiplyScalar(axes["".concat(planeName).concat(inPlaneName)], -1), rotationHandlePosition, pdLength, displayScaleParams[planeNameToViewType[inPlaneName]]);
-    widgetState["getRotationHandle".concat(lineName, "1")]().setOrigin(rotationPoint1);
+    var direction = axes["".concat(planeName).concat(inPlaneName)];
+    widgetState["getRotationHandle".concat(lineName, "0")]().setOrigin(center);
+    widgetState["getRotationHandle".concat(lineName, "0")]().setOffset(computeRotationHandleOriginOffset(direction, rotationHandlePosition, pdLength, scaleInPixels));
+    widgetState["getRotationHandle".concat(lineName, "1")]().setOrigin(center);
+    widgetState["getRotationHandle".concat(lineName, "1")]().setOffset(computeRotationHandleOriginOffset(direction, -rotationHandlePosition, pdLength, scaleInPixels));
     var lineHandle = widgetState["getAxis".concat(lineName)]();
     lineHandle.setOrigin(center);
-    var direction = subtract(rotationPoint0, center, []);
     var scale = normalize(direction);
     var scale3 = lineHandle.getScale3();
     scale3[2] = 2 * scale;

package/Widgets/Widgets3D/ResliceCursorWidget/state.js

@@ -17,24 +17,12 @@ function generateState() {
   var state = vtkStateBuilder.createBuilder().addField({
     name: 'center',
     initialValue: [0, 0, 0]
-  }).addField({
-    name: 'opacity',
-    initialValue: 1
   }).addField({
     name: 'image',
     initialValue: null
   }).addField({
     name: 'activeViewType',
     initialValue: null
-  }).addField({
-    name: 'lineThickness',
-    initialValue: 2
-  }).addField({
-    name: 'sphereRadius',
-    initialValue: 5
-  }).addField({
-    name: 'showCenter',
-    initialValue: true
   }).addField({
     name: 'planes',
     initialValue: (_initialValue = {}, _defineProperty(_initialValue, ViewTypes.YZ_PLANE, {
@@ -47,15 +35,6 @@ function generateState() {
       normal: [0, 0, -1],
       viewUp: [0, -1, 0]
     }), _initialValue)
-  }).addField({
-    name: 'enableRotation',
-    initialValue: true
-  }).addField({
-    name: 'enableTranslation',
-    initialValue: true
-  }).addField({
-    name: 'keepOrthogonality',
-    initialValue: false
   }).addField({
     name: 'scrollingMethod',
     initialValue: ScrollingMethods.MIDDLE_MOUSE_BUTTON
@@ -66,7 +45,7 @@ function generateState() {
     name: 'viewUpFromViewType',
     initialValue: {}
   }).addStateFromMixin({
-    labels: ['handles', 'center'],
+    labels: ['handles', 'sphere', 'center'],
     mixins: ['origin', 'color3', 'scale1', 'visible', 'manipulator'],
     name: 'centerHandle',
     initialValues: {
@@ -92,7 +71,7 @@ function generateState() {
 
       for (var rotationHandle = 0; rotationHandle < 2; ++rotationHandle) {
         axisState.addStateFromMixin({
-          labels: ['handles', 'rotation', "rotationIn".concat(view), "".concat(axis, "in").concat(view), "point".concat(rotationHandle)],
+          labels: ['handles', 'sphere', 'rotation', "rotationIn".concat(view), "".concat(axis, "in").concat(view), "point".concat(rotationHandle)],
           mixins: ['origin', 'color3', 'scale1', 'visible', 'manipulator'],
           name: "rotationHandle".concat(axis, "in").concat(view).concat(rotationHandle),
           initialValues: {

package/Widgets/Widgets3D/ResliceCursorWidget.js

@@ -10,6 +10,7 @@ import { e as distance2BetweenPoints, m as multiplyAccumulate, s as subtract, l
 import widgetBehavior from './ResliceCursorWidget/behavior.js';
 import generateState from './ResliceCursorWidget/state.js';
 import { updateState, transformPlane, boundPlane } from './ResliceCursorWidget/helpers.js';
+import { viewTypeToPlaneName } from './ResliceCursorWidget/Constants.js';
 import { ViewTypes } from '../Core/WidgetManager/Constants.js';
 import { mat4 } from 'gl-matrix';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
@@ -138,21 +139,32 @@ function vtkResliceCursorWidget(publicAPI, model) {
     renderer.resetCameraClippingRange(bounds);
   }
   /**
-   * Convenient function to return the ResliceCursorRepresentation for a given viewType
+   * Convenient function to return the widget for a given viewType
    * @param {string} viewType
-   * @returns
+   * @returns the widget instanced in the given viewType.
    */
 
 
-  function findRepresentationsForViewType(viewType) {
-    var widgetForViewType = publicAPI.getViewIds().map(function (viewId) {
+  function findWidgetForViewType(viewType) {
+    return publicAPI.getViewIds().map(function (viewId) {
       return publicAPI.getWidgetForView({
         viewId: viewId
       });
     }).find(function (widget) {
       return widget.getViewType() === viewType;
     });
-    return widgetForViewType.getRepresentations();
+  }
+  /**
+   * Convenient function to return the ResliceCursorRepresentation for a given viewType
+   * @param {string} viewType
+   * @returns an array of 3 representations (for line handles, rotation handles, center handle)
+   * or an empty array if the widget has not yet been added to the view type.
+   */
+
+
+  function findRepresentationsForViewType(viewType) {
+    var widgetForViewType = findWidgetForViewType(viewType);
+    return widgetForViewType ? widgetForViewType.getRepresentations() : [];
   } // --------------------------------------------------------------------------
   // initialization
   // --------------------------------------------------------------------------
@@ -161,47 +173,28 @@ function vtkResliceCursorWidget(publicAPI, model) {
   publicAPI.getRepresentationsForViewType = function (viewType) {
     switch (viewType) {
       case ViewTypes.XY_PLANE:
-        return [{
-          builder: vtkLineHandleRepresentation,
-          labels: ['lineInZ'],
-          initialValues: {
-            useActiveColor: false
-          }
-        }, {
-          builder: vtkSphereHandleRepresentation,
-          labels: ['rotationInZ', 'center'],
-          initialValues: {
-            useActiveColor: false
-          }
-        }];
-
       case ViewTypes.XZ_PLANE:
+      case ViewTypes.YZ_PLANE:
         return [{
           builder: vtkLineHandleRepresentation,
-          labels: ['lineInY'],
+          labels: ["lineIn".concat(viewTypeToPlaneName[viewType])],
           initialValues: {
-            useActiveColor: false
+            useActiveColor: false,
+            scaleInPixels: model.scaleInPixels
           }
         }, {
           builder: vtkSphereHandleRepresentation,
-          labels: ['rotationInY', 'center'],
+          labels: ["rotationIn".concat(viewTypeToPlaneName[viewType])],
           initialValues: {
-            useActiveColor: false
-          }
-        }];
-
-      case ViewTypes.YZ_PLANE:
-        return [{
-          builder: vtkLineHandleRepresentation,
-          labels: ['lineInX'],
-          initialValues: {
-            useActiveColor: false
+            useActiveColor: false,
+            scaleInPixels: model.scaleInPixels
           }
         }, {
           builder: vtkSphereHandleRepresentation,
-          labels: ['rotationInX', 'center'],
+          labels: ['center'],
           initialValues: {
-            useActiveColor: false
+            useActiveColor: false,
+            scaleInPixels: model.scaleInPixels
           }
         }];
 
@@ -218,12 +211,12 @@ function vtkResliceCursorWidget(publicAPI, model) {
     model.widgetState.setImage(image);
     var center = image.getCenter();
     model.widgetState.setCenter(center);
-    updateState(model.widgetState, publicAPI.getDisplayScaleParams(), model.rotationHandlePosition);
+    updateState(model.widgetState, model.scaleInPixels, model.rotationHandlePosition);
   };
 
   publicAPI.setCenter = function (center) {
     model.widgetState.setCenter(center);
-    updateState(model.widgetState, publicAPI.getDisplayScaleParams(), model.rotationHandlePosition);
+    updateState(model.widgetState, model.scaleInPixels, model.rotationHandlePosition);
     publicAPI.modified();
   }; // --------------------------------------------------------------------------
   // Methods
@@ -423,10 +416,17 @@ function vtkResliceCursorWidget(publicAPI, model) {
     return [ViewTypes.YZ_PLANE, ViewTypes.XZ_PLANE, ViewTypes.XY_PLANE].reduce(function (res, viewType) {
       var _findRepresentationsF, _findRepresentationsF2;
 
-      res[viewType] = (_findRepresentationsF = (_findRepresentationsF2 = findRepresentationsForViewType(viewType)[0]).getDisplayScaleParams) === null || _findRepresentationsF === void 0 ? void 0 : _findRepresentationsF.call(_findRepresentationsF2);
+      res[viewType] = (_findRepresentationsF = findRepresentationsForViewType(viewType)[0]) === null || _findRepresentationsF === void 0 ? void 0 : (_findRepresentationsF2 = _findRepresentationsF.getDisplayScaleParams) === null || _findRepresentationsF2 === void 0 ? void 0 : _findRepresentationsF2.call(_findRepresentationsF);
       return res;
     }, {});
   };
+
+  publicAPI.setScaleInPixels = macro.chain(publicAPI.setScaleInPixels, function (scale) {
+    publicAPI.getViewWidgets().forEach(function (w) {
+      return w.setScaleInPixels(scale);
+    });
+    updateState(model.widgetState, model.scaleInPixels, model.rotationHandlePosition);
+  });
 } // ----------------------------------------------------------------------------
 
 
@@ -434,7 +434,8 @@ var defaultValues = function defaultValues(initialValues) {
   return _objectSpread({
     behavior: widgetBehavior,
     widgetState: generateState(),
-    rotationHandlePosition: 0.25
+    rotationHandlePosition: 0.5,
+    scaleInPixels: true
   }, initialValues);
 }; // ----------------------------------------------------------------------------
 
@@ -443,7 +444,7 @@ function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, defaultValues(initialValues));
   vtkAbstractWidgetFactory.extend(publicAPI, model, initialValues);
-  macro.setGet(publicAPI, model, ['rotationHandlePosition']);
+  macro.setGet(publicAPI, model, ['scaleInPixels', 'rotationHandlePosition']);
   vtkResliceCursorWidget(publicAPI, model);
 } // ----------------------------------------------------------------------------
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "26.8.2",
+  "version": "26.9.1",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",
@@ -129,6 +129,8 @@
     "xml2js": "0.4.23"
   },
   "peerDependencies": {
+    "@babel/preset-env": "^7.17.10",
+    "autoprefixer": "^10.4.7",
     "wslink": "^1.1.0"
   },
   "scripts": {