@kitware/vtk.js 29.6.0 → 29.7.1

package/Filters/General/ContourLoopExtraction.d.ts

@@ -0,0 +1,79 @@
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+import vtkPolyData from './../../Common/DataModel/PolyData';
+/**
+ * Initial configuration values for vtkContourLoopExtraction instances.
+ */
+export interface IContourLoopExtractionInitialValues {}
+
+type vtkContourLoopExtractionBase = vtkObject & vtkAlgorithm;
+
+export interface vtkContourLoopExtraction extends vtkContourLoopExtractionBase {
+  /**
+   * Runs the contour extraction algorithm with the given input and output data.
+   * @param inData - The input data for the contour extraction.
+   * @param outData - The output data where the extracted contours will be stored.
+   */
+  requestData(inData: vtkPolyData[], outData: vtkPolyData[]): void;
+
+  /**
+   * Extracts contour loops from the given polydata input and populates the given output.
+   * @param input - The input polydata
+   * @param output - The output polydata
+   */
+  extractContours(input: vtkPolyData, output: vtkPolyData): void;
+
+  /**
+   * Traverses a loop starting from a given line and point, in a specified direction.
+   * @param pd - The polydata which to traverse.
+   * @param dir - The direction of traversal.
+   * @param startLineId - The ID of the starting line.
+   * @param startPtId - The ID of the starting point.
+   * @param loopPoints - The array to store the traversed points of the loop.
+   * @returns The last point ID after traversal.
+   */
+  traverseLoop(
+    pd: vtkPolyData,
+    dir: number,
+    startLineId: number,
+    startPtId: number,
+    loopPoints: Array<{ t: number; ptId: number }>
+  ): number;
+}
+
+// ----------------------------------------------------------------------------
+// Static API
+// ----------------------------------------------------------------------------
+
+/**
+ * Method use to decorate a given object (publicAPI+model) with vtkContourLoopExtraction characteristics.
+ *
+ * @param publicAPI - Object on which methods will be bound (public).
+ * @param model - Object on which data structure will be bound (protected).
+ * @param initialValues - (Optional) Initial values to assign to the model.
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IContourLoopExtractionInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkContourLoopExtraction.
+ *
+ * @param initialValues - (Optional) Initial values for the instance.
+ */
+export function newInstance(
+  initialValues?: IContourLoopExtractionInitialValues
+): vtkContourLoopExtraction;
+
+// ----------------------------------------------------------------------------
+
+/**
+ * vtkContourLoopExtraction specific static methods.
+ */
+export declare const vtkContourLoopExtraction: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+
+export default vtkContourLoopExtraction;

package/Filters/General/ContourLoopExtraction.js

@@ -0,0 +1,137 @@
+import { m as macro } from '../../macros2.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.js';
+
+const Dir = {
+  Forward: 1,
+  Backward: -1
+};
+const visited = new Set();
+function vtkContourLoopExtraction(publicAPI, model) {
+  publicAPI.requestData = (inData, outData) => {
+    const [input] = inData;
+    if (!outData[0]) {
+      outData[0] = vtkPolyData.newInstance();
+    }
+    const [output] = outData;
+    publicAPI.extractContours(input, output);
+    output.modified();
+  };
+  publicAPI.traverseLoop = (pd, dir, startLineId, startPtId, loopPoints) => {
+    let lineId = startLineId;
+    let lastPtId = startPtId;
+    let terminated = false;
+    let numInserted = 0;
+    while (!terminated) {
+      const {
+        cellPointIds
+      } = pd.getCellPoints(lineId);
+      if (!cellPointIds) {
+        // eslint-disable-next-line no-continue
+        continue;
+      }
+      lastPtId = cellPointIds[0] !== lastPtId ? cellPointIds[0] : cellPointIds[1];
+      numInserted++;
+
+      // parametric point value
+      const t = dir * numInserted;
+      loopPoints.push({
+        t,
+        ptId: lastPtId
+      });
+      const lineCell = pd.getPointCells(lastPtId);
+      if (lineCell.length !== 2 || lastPtId === startPtId) {
+        // looped
+        return lastPtId;
+      }
+      if (lineCell.length === 2) {
+        // continue along loop
+        lineId = lineCell[0] !== lineId ? lineCell[0] : lineCell[1];
+        visited.add(lineId);
+      } else {
+        // empty or invalid cell
+        terminated = true;
+      }
+    }
+    return lastPtId;
+  };
+  publicAPI.extractContours = (input, output) => {
+    const loops = [];
+    visited.clear();
+    const inLines = input.getLines();
+    output.getPoints().setData(Float32Array.from(input.getPoints().getData()));
+
+    // TODO skip if cached input mtime hasn't changed.
+    // iterate over input lines
+    for (let li = 0; li < inLines.getNumberOfCells(); li++) {
+      if (visited.has(li)) {
+        // eslint-disable-next-line no-continue
+        continue;
+      }
+      const {
+        cellPointIds
+      } = input.getCellPoints(li);
+      if (!cellPointIds) {
+        // eslint-disable-next-line no-continue
+        continue;
+      }
+      visited.add(li);
+      const startPtId = cellPointIds[0];
+      const loopPoints = [];
+      loopPoints.push({
+        t: 0,
+        ptId: startPtId
+      });
+      const endPtId = publicAPI.traverseLoop(input, Dir.Forward, li, startPtId, loopPoints);
+      if (startPtId !== endPtId) {
+        // didn't find a loop. Go other direction to see where we end up
+        publicAPI.traverseLoop(input, Dir.Backward, li, startPtId, loopPoints);
+        loopPoints.sort((a, b) => a.t < b.t ? -1 : 1);
+        // make closed contour
+        if (loopPoints.length && loopPoints[0].ptId !== loopPoints[loopPoints.length - 1]?.ptId) {
+          loopPoints.push({
+            ...loopPoints[loopPoints.length - 1]
+          });
+        }
+      }
+      if (loopPoints.length) {
+        loops.push(loopPoints);
+      }
+    }
+
+    // clear output lines
+    const outLines = output.getLines();
+    outLines.resize(0);
+    loops.forEach(loop => {
+      outLines.insertNextCell(loop.map(pt => pt.ptId));
+    });
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+  macro.obj(publicAPI, model);
+  macro.algo(publicAPI, model, 1, 1);
+  vtkContourLoopExtraction(publicAPI);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkContourLoopExtraction');
+
+// ----------------------------------------------------------------------------
+
+var index = {
+  newInstance,
+  extend
+};
+
+export { index as default, extend, newInstance };

package/Interaction/Manipulators/MouseRangeManipulator.d.ts

@@ -1,11 +1,14 @@
 import vtkCompositeMouseManipulator, {
   ICompositeMouseManipulatorInitialValues,
 } from './CompositeMouseManipulator';
+import { vtkObject } from './../../interfaces';
 
 export interface IMouseRangeManipulatorInitialValues
   extends ICompositeMouseManipulatorInitialValues {}
 
-export interface vtkMouseRangeManipulator extends vtkCompositeMouseManipulator {
+export interface vtkMouseRangeManipulator
+  extends vtkCompositeMouseManipulator,
+    vtkObject {
   setHorizontalListener(
     min: number,
     max: number,

package/Interaction/Widgets/OrientationMarkerWidget/Constants.js

@@ -8,4 +8,4 @@ var Constants = {
   Corners
 };
 
-export { Constants as default };
+export { Corners, Constants as default };

package/Interaction/Widgets/OrientationMarkerWidget.d.ts

@@ -1,6 +1,5 @@
 import { vtkObject } from './../../interfaces';
-import vtkAnnotatedCubeActor from './../../Rendering/Core/AnnotatedCubeActor';
-import vtkAxesActor from './../../Rendering/Core/AxesActor';
+import vtkActor from './../../Rendering/Core/Actor';
 import vtkRenderer from './../../Rendering/Core/Renderer';
 import vtkRenderWindowInteractor from './../../Rendering/Core/RenderWindowInteractor';
 import { Nullable } from './../../types';
@@ -11,7 +10,7 @@ import { Corners } from './OrientationMarkerWidget/Constants';
  * 
  */
 export interface IOrientationMarkerWidgetInitialValues {
-	actor?: vtkAnnotatedCubeActor | vtkAxesActor,
+	actor?: vtkActor,
 	interactor?: vtkRenderWindowInteractor,
 	parentRenderer?: vtkRenderer,
 	viewportCorner?: Corners,
@@ -39,7 +38,7 @@ export interface vtkOrientationMarkerWidget extends vtkObject {
 	/**
 	 * 
 	 */
-	getActor(): vtkAnnotatedCubeActor | vtkAxesActor;
+	getActor(): vtkActor;
 
 	/**
 	 * Gets the parent renderer, if any.
@@ -85,9 +84,9 @@ export interface vtkOrientationMarkerWidget extends vtkObject {
 	
 	/**
 	 * Get the actor associated with the widget.
-	 * @param {vtkAnnotatedCubeActor | vtkAxesActor} actor The actor instance.
+	 * @param {vtkActor} actor The actor instance.
 	 */
-	setActor(actor: vtkAnnotatedCubeActor | vtkAxesActor): void;
+	setActor(actor: vtkActor): void;
 
 	/**
 	 * Sets the parent renderer

package/Rendering/Core/RenderWindowInteractor.d.ts

@@ -396,6 +396,11 @@ export interface vtkRenderWindowInteractor extends vtkObject {
 	 */
 	invokeEndInteractionEvent(callData: IRenderWindowInteractorEvent): void;
 
+	/**
+	 *
+	 */
+	invokeRenderEvent(): void;
+
 	/**
 	 *
 	 * @param cb The callback to be called
@@ -659,6 +664,13 @@ export interface vtkRenderWindowInteractor extends vtkObject {
 	 */
 	onEndInteractionEvent(cb: InteractorEventCallback, priority?: number): Readonly<vtkSubscription>;
 
+	/**
+	 *
+	 * @param {Function} cb The callback to be called.
+	 * @param {Number} [priority] The priority of the event.
+	 */
+	onRenderEvent(cb: () => void, priority?: number): Readonly<vtkSubscription>;
+
 	/**
 	 *
 	 * @param args

package/Rendering/Core/VolumeProperty.d.ts

@@ -1,5 +1,6 @@
 import vtkPiecewiseFunction from './../../Common/DataModel/PiecewiseFunction';
 import { vtkObject } from './../../interfaces';
+import { Nullable } from './../../types';
 import vtkColorTransferFunction from './ColorTransferFunction';
 import { InterpolationType, OpacityMode } from './VolumeProperty/Constants';
 
@@ -279,14 +280,14 @@ export interface vtkVolumeProperty extends vtkObject {
 	 * @param {Number} index 
 	 * @param {vtkColorTransferFunction} func 
 	 */
-	setRGBTransferFunction(index: number, func: vtkColorTransferFunction): boolean;
+	setRGBTransferFunction(index: number, func?: Nullable<vtkColorTransferFunction>): boolean;
 
 	/**
 	 * Set the scalar opacity of a volume to a transfer function
 	 * @param {Number} index 
 	 * @param {vtkPiecewiseFunction} func 
 	 */
-	setScalarOpacity(index: number, func: vtkPiecewiseFunction): boolean;
+	setScalarOpacity(index: number, func?: Nullable<vtkPiecewiseFunction>): boolean;
 
 	/**
 	 * Set the scalar component weights.

package/Rendering/OpenGL/RenderWindow.d.ts

@@ -80,7 +80,7 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
 	 *
 	 * @param {HTMLElement} el The container element.
 	 */
-	setContainer(el: HTMLElement): void;
+	setContainer(el: Nullable<HTMLElement>): void;
 
 	/**
 	 * Get the container element.

package/Widgets/Core/AbstractWidget.js

@@ -102,7 +102,9 @@ function extend(publicAPI, model) {
   vtkProp.extend(publicAPI, model, initialValues);
   vtkInteractorObserver.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['contextVisibility', 'handleVisibility', '_widgetManager']);
-  macro.get(publicAPI, model, ['representations', 'widgetState', 'activeState']);
+  macro.get(publicAPI, model, ['representations', 'widgetState', 'activeState' // stores the last activated sub state(handle)
+  ]);
+
   macro.moveToProtected(publicAPI, model, ['widgetManager']);
   macro.event(publicAPI, model, 'ActivateHandle');
   vtkAbstractWidget(publicAPI, model);

package/Widgets/Widgets3D/ResliceCursorWidget/behavior.js

@@ -164,7 +164,9 @@ function widgetBehavior(publicAPI, model) {
     const step = calldata.spinY;
     isScrolling = true;
     publicAPI.translateCenterOnPlaneDirection(step);
-    publicAPI.invokeInternalInteractionEvent();
+    publicAPI.invokeInternalInteractionEvent(
+    // Force interaction mode because mouse cursor could be above rotation handle
+    InteractionMethodsName.TranslateCenter);
     isScrolling = false;
     return macro.EVENT_ABORT;
   };
@@ -183,14 +185,15 @@ function widgetBehavior(publicAPI, model) {
   };
   publicAPI.handleEvent = callData => {
     if (model.activeState.getActive()) {
-      publicAPI[publicAPI.getActiveInteraction()](callData);
-      publicAPI.invokeInternalInteractionEvent();
+      const methodName = publicAPI.getActiveInteraction();
+      publicAPI[methodName](callData);
+      publicAPI.invokeInternalInteractionEvent(methodName);
       return macro.EVENT_ABORT;
     }
     return macro.VOID;
   };
-  publicAPI.invokeInternalInteractionEvent = () => {
-    const methodName = publicAPI.getActiveInteraction();
+  publicAPI.invokeInternalInteractionEvent = function () {
+    let methodName = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : publicAPI.getActiveInteraction();
     const computeFocalPointOffset = methodName !== InteractionMethodsName.RotateLine;
     const canUpdateFocalPoint = methodName === InteractionMethodsName.RotateLine;
     publicAPI.invokeInteractionEvent({

package/index.d.ts

@@ -55,6 +55,7 @@
 /// <reference path="./Common/Transform/Transform.d.ts" />
 /// <reference path="./Filters/General/AppendPolyData.d.ts" />
 /// <reference path="./Filters/General/ClipClosedSurface.d.ts" />
+/// <reference path="./Filters/General/ContourLoopExtraction.d.ts" />
 /// <reference path="./Filters/General/ContourTriangulator.d.ts" />
 /// <reference path="./Filters/General/ImageCropFilter.d.ts" />
 /// <reference path="./Filters/General/ImageDataOutlineFilter.d.ts" />

package/package.json

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