vtk.js 29.6.0 → 29.7.0

package/ComputeHistogram.worker-lite.worker.js.LICENSE.txt

@@ -1,6 +1,6 @@
 /*!
  * @project        vtk.js
- * @build          Thu, Feb 8, 2024 8:13 PM ET
+ * @build          Thu, Feb 8, 2024 10:05 PM ET
  * @copyright      Copyright (c) 2024 Kitware, Inc.
  *
  */

package/ComputeHistogram.worker.worker.js.LICENSE.txt

@@ -1,6 +1,6 @@
 /*!
  * @project        vtk.js
- * @build          Thu, Feb 8, 2024 8:13 PM ET
+ * @build          Thu, Feb 8, 2024 10:05 PM ET
  * @copyright      Copyright (c) 2024 Kitware, Inc.
  *
  */

package/PaintFilter.worker-lite.worker.js.LICENSE.txt

@@ -1,6 +1,6 @@
 /*!
  * @project        vtk.js
- * @build          Thu, Feb 8, 2024 8:13 PM ET
+ * @build          Thu, Feb 8, 2024 10:05 PM ET
  * @copyright      Copyright (c) 2024 Kitware, Inc.
  *
  */

package/PaintFilter.worker.worker.js.LICENSE.txt

@@ -1,6 +1,6 @@
 /*!
  * @project        vtk.js
- * @build          Thu, Feb 8, 2024 8:13 PM ET
+ * @build          Thu, Feb 8, 2024 10:05 PM ET
  * @copyright      Copyright (c) 2024 Kitware, Inc.
  *
  */

package/Sources/Filters/General/ContourLoopExtraction/index.d.ts

@@ -0,0 +1,79 @@
+import { vtkAlgorithm, vtkObject } from 'vtk.js/Sources/interfaces';
+import vtkPolyData from 'vtk.js/Sources/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/Sources/Filters/General/ContourLoopExtraction/index.js

@@ -0,0 +1,153 @@
+import macro from 'vtk.js/Sources/macros';
+import vtkPolyData from 'vtk.js/Sources/Common/DataModel/PolyData';
+
+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 = {};
+
+// ----------------------------------------------------------------------------
+
+export function extend(publicAPI, model, initialValues = {}) {
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  macro.obj(publicAPI, model);
+  macro.algo(publicAPI, model, 1, 1);
+
+  vtkContourLoopExtraction(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+export const newInstance = macro.newInstance(
+  extend,
+  'vtkContourLoopExtraction'
+);
+
+// ----------------------------------------------------------------------------
+
+export default { newInstance, extend };

package/Sources/Interaction/Manipulators/MouseRangeManipulator/index.d.ts

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

package/Sources/Interaction/Widgets/OrientationMarkerWidget/Constants.js

@@ -1,4 +1,4 @@
-const Corners = {
+export const Corners = {
   TOP_LEFT: 'TOP_LEFT',
   TOP_RIGHT: 'TOP_RIGHT',
   BOTTOM_LEFT: 'BOTTOM_LEFT',

package/Sources/Interaction/Widgets/OrientationMarkerWidget/index.d.ts

@@ -1,6 +1,5 @@
 import { vtkObject } from 'vtk.js/Sources/interfaces';
-import vtkAnnotatedCubeActor from 'vtk.js/Sources/Rendering/Core/AnnotatedCubeActor';
-import vtkAxesActor from 'vtk.js/Sources/Rendering/Core/AxesActor';
+import vtkActor from 'vtk.js/Sources/Rendering/Core/Actor';
 import vtkRenderer from 'vtk.js/Sources/Rendering/Core/Renderer';
 import vtkRenderWindowInteractor from 'vtk.js/Sources/Rendering/Core/RenderWindowInteractor';
 import { Nullable } from 'vtk.js/Sources/types';
@@ -11,7 +10,7 @@ import { Corners } from 'vtk.js/Sources/Interaction/Widgets/OrientationMarkerWid
  * 
  */
 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/Sources/Rendering/Core/RenderWindowInteractor/index.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/Sources/Rendering/Core/VolumeProperty/index.d.ts

@@ -1,5 +1,6 @@
 import vtkPiecewiseFunction from 'vtk.js/Sources/Common/DataModel/PiecewiseFunction';
 import { vtkObject } from 'vtk.js/Sources/interfaces';
+import { Nullable } from 'vtk.js/Sources/types';
 import vtkColorTransferFunction from 'vtk.js/Sources/Rendering/Core/ColorTransferFunction';
 import { InterpolationType, OpacityMode } from 'vtk.js/Sources/Rendering/Core/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/Sources/Rendering/OpenGL/RenderWindow/index.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/package.json

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