@kitware/vtk.js 31.0.5 → 31.1.0

package/Widgets/Representations/GlyphRepresentation.js

@@ -119,7 +119,7 @@ function direction(publicAPI, model) {
   return (polyData, states) => {
     model._pipeline.mapper.setOrientationArray('orientation');
     model._pipeline.mapper.setOrientationMode(OrientationModes.MATRIX);
-    const orientation = allocateArray(polyData, 'orientation', states.length, 'Float32Array', 9).getData();
+    const orientation = allocateArray(polyData, 'orientation', states.length, 'Float64Array', 9).getData();
     for (let i = 0; i < states.length; ++i) {
       const state = states[i];
       const right = state.getRight ? state.getRight() : [1, 0, 0];

package/Widgets/Representations/LineHandleRepresentation.js

@@ -4,6 +4,8 @@ import vtkGlyphRepresentation from './GlyphRepresentation.js';
 import vtkPixelSpaceCallbackMapper from '../../Rendering/Core/PixelSpaceCallbackMapper.js';
 import vtkCylinderSource from '../../Filters/Sources/CylinderSource.js';
 import { allocateArray } from './WidgetRepresentation.js';
+import { getPixelWorldHeightAtCoord } from '../Core/WidgetManager.js';
+import { vec3 } from 'gl-matrix';
 
 const INFINITE_RATIO = 100000;
 
@@ -60,6 +62,61 @@ function vtkLineHandleRepresentation(publicAPI, model) {
     model.displayCallback = callback;
     model.displayMapper.setCallback(callback ? callbackProxy : null);
   };
+  const superPublicAPI = {
+    ...publicAPI
+  };
+  publicAPI.requestData = (inData, outData) => {
+    superPublicAPI.requestData(inData, outData);
+    if (!model.holeWidth) {
+      return;
+    }
+    const internalPolyData = outData[0];
+
+    // Duplicate points and point data
+    const points = internalPolyData.getPoints();
+    const dataArrays = internalPolyData.getPointData().getArrays();
+    [points, ...dataArrays].forEach(array => {
+      const oldNumberOfValues = array.getNumberOfValues();
+      array.resize(2 * array.getNumberOfTuples());
+      const arrayData = array.getData();
+      for (let i = 0; i < oldNumberOfValues; ++i) {
+        arrayData[i + oldNumberOfValues] = arrayData[i];
+      }
+    });
+
+    // Change the scale and origin of each line
+    const states = publicAPI.getRepresentationStates(inData[0]);
+    const nStates = states.length;
+    const scaleArray = internalPolyData.getPointData().getArrayByName('scale');
+    const orientationArray = internalPolyData.getPointData().getArrayByName('orientation');
+    const defaultScale = [1, 1, 1];
+    const defaultOrientation = [1, 0, 0, 0, 1, 0, 0, 0, 1];
+    for (let i = 0; i < nStates; ++i) {
+      const j = i + nStates;
+      const scale = scaleArray?.getTuple(i) ?? defaultScale;
+      const orientationMatrix = orientationArray?.getTuple(i) ?? defaultOrientation;
+      const originalPoint = points.getTuple(i);
+
+      // Divide the scale by two in the direction of the cylinder, as we duplicate the line
+      scale[2] *= 0.5;
+      scaleArray?.setTuple(i, scale);
+      scaleArray?.setTuple(j, scale);
+
+      // Add or subtract an offset to each point depending on the hole width
+      let holeWidth = model.holeWidth;
+      if (publicAPI.getScaleInPixels()) {
+        holeWidth *= getPixelWorldHeightAtCoord(originalPoint, model.displayScaleParams);
+      }
+      const offset = vec3.fromValues(0, 0, 0.5 * scale[2] + holeWidth);
+      vec3.transformMat3(offset, offset, orientationMatrix);
+      points.setTuple(i, vec3.add(vec3.create(), originalPoint, offset));
+      points.setTuple(j, vec3.sub(vec3.create(), originalPoint, offset));
+    }
+  };
+  publicAPI.getSelectedState = (prop, compositeID) => {
+    const representationStates = publicAPI.getRepresentationStates();
+    return representationStates[compositeID % representationStates.length];
+  };
 
   /**
    * Overwrite scale3 to optionally make lines infinite
@@ -84,6 +141,7 @@ function defaultValues(initialValues) {
   return {
     infiniteLine: true,
     glyphResolution: 4,
+    holeWidth: 0,
     _pipeline: {
       glyph: vtkCylinderSource.newInstance({
         resolution: initialValues.glyphResolution ?? 4,
@@ -100,7 +158,7 @@ function defaultValues(initialValues) {
 function extend(publicAPI, model) {
   let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   vtkGlyphRepresentation.extend(publicAPI, model, defaultValues(initialValues));
-  macro.setGet(publicAPI, model, ['infiniteLine', 'glyphResolution']);
+  macro.setGet(publicAPI, model, ['infiniteLine', 'glyphResolution', 'holeWidth']);
 
   // Object specific methods
   vtkLineHandleRepresentation(publicAPI, model);

package/Widgets/Widgets3D/ResliceCursorWidget/behavior.d.ts

@@ -14,6 +14,12 @@ export default interface vtkResliceCursorWidgetDefaultInstance
   extends vtkAbstractWidget {
   getActiveInteraction(): Nullable<InteractionMethodsName>;
 
+  getScaleInPixels(): boolean;
+  setScaleInPixels(scaleInPixels: boolean): boolean;
+
+  getHoleWidth(): number;
+  setHoleWidth(holeWidth: number): boolean;
+
   setKeepOrthogonality(keepOrthogonality: boolean): boolean;
   getKeepOrthogonality(): boolean;
 

package/Widgets/Widgets3D/ResliceCursorWidget/helpers.js

@@ -211,10 +211,7 @@ function updateState(widgetState, scaleInPixels, rotationHandlePosition) {
     lineHandle.setOrigin(center);
     lineHandle.getManipulator()?.setHandleOrigin(center);
     lineHandle.getManipulator()?.setHandleNormal(widgetState.getPlanes()[planeNameToViewType[planeName]].normal);
-    const scale = normalize(direction);
-    const scale3 = lineHandle.getScale3();
-    scale3[2] = 2 * scale;
-    lineHandle.setScale3(scale3);
+    normalize(direction);
     const right = widgetState.getPlanes()[planeNameToViewType[inPlaneName]].normal;
     const up = cross(direction, right, []);
     lineHandle.setRight(right);

package/Widgets/Widgets3D/ResliceCursorWidget/state.js

@@ -68,9 +68,7 @@ function generateState() {
     // Line handle
     axisState.addStateFromMixin({
       labels: ['handles', 'line', `lineIn${view}`, `${axis}in${view}`],
-      mixins: ['origin', 'color3', 'scale3',
-      // scale3[2] will be automatically overwritten
-      'orientation', 'visible', 'manipulator'],
+      mixins: ['origin', 'color3', 'scale3', 'orientation', 'visible', 'manipulator'],
       name: `axis${axis}in${view}`,
       initialValues: {
         scale3: [4, 4, 4],

package/Widgets/Widgets3D/ResliceCursorWidget.d.ts

@@ -70,6 +70,22 @@ export interface vtkResliceCursorWidget<
 
   getScaleInPixels(): boolean;
 
+  setHoleWidth(holeWidth: number): boolean;
+
+  getHoleWidth(): number;
+
+  /**
+   * Defines the length of the line
+   * The scaling of each line representation always define the dimensions of the circle / elipse (X and Y axes)
+   * The unit of this scaling is either in world coordinates or in pixels depending in scaleInPixels
+   * When the line is finite, this scaling on the Z axis also defines the length of the line
+   * When the line is infinite, the scaling on the Z axis is automatically huge
+   * @param infiniteLine
+   */
+  setInfiniteLine(infiniteLine: boolean): boolean;
+
+  getInfiniteLine(): boolean;
+
   setRotationHandlePosition(position: number): boolean;
 
   getRotationHandlePosition(): number;

package/Widgets/Widgets3D/ResliceCursorWidget.js

@@ -27,7 +27,11 @@ const {
 
 function vtkResliceCursorWidget(publicAPI, model) {
   model.classHierarchy.push('vtkResliceCursorWidget');
-  model.methodsToLink = ['scaleInPixels'];
+  model.methodsToLink = [
+  // For all representations
+  'scaleInPixels',
+  // For line representations
+  'holeWidth', 'infiniteLine'];
 
   // --------------------------------------------------------------------------
   // Private methods

package/package.json

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