@kitware/vtk.js 28.11.1 → 28.12.1

package/Common/Core/DataArray.js

@@ -12,6 +12,7 @@ const {
 // ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
+const EPSILON = 1e-6;
 
 // Original source from https://www.npmjs.com/package/compute-range
 // Modified to accept type arrays
@@ -305,6 +306,24 @@ function vtkDataArray(publicAPI, model) {
     const idx = model.size / model.numberOfComponents;
     return publicAPI.insertTuples(idx, tuples);
   };
+  publicAPI.findTuple = function (tuple) {
+    let precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : EPSILON;
+    for (let i = 0; i < model.size; i += model.numberOfComponents) {
+      if (Math.abs(tuple[0] - model.values[i]) <= precision) {
+        let match = true;
+        for (let j = 1; j < model.numberOfComponents; ++j) {
+          if (Math.abs(tuple[j] - model.values[i + j]) > precision) {
+            match = false;
+            break;
+          }
+        }
+        if (match) {
+          return i / model.numberOfComponents;
+        }
+      }
+    }
+    return -1;
+  };
   publicAPI.getTuple = function (idx) {
     let tupleToFill = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
     const numberOfComponents = model.numberOfComponents || 1;

package/Common/Core/Points.d.ts

@@ -1,96 +1,105 @@
-import vtkDataArray from './DataArray';
-import { Bounds, TypedArray } from './../../types';
-
-/**
- *
- */
-export interface IPointsInitialValues {
-	empty?: boolean;
-	numberOfComponents?: number;
-	bounds?: Bounds;
-}
-
-export interface vtkPoints extends vtkDataArray {
-
-	/**
-	 * Trigger the computation of bounds
-	 */
-	computeBounds(): Bounds;
-
-	/**
-	 * Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].
-	 * @return {Bounds} The bounds for the mapper.
-	 */
-	getBounds(): Bounds;
-
-	/**
-	 * Get the coordinate of a point.
-	 * @param {Number} idx The index of point.
-	 * @param {Number[]|TypedArray} [tupleToFill] (default [])
-	 * @returns {Number[]|TypedArray}
-	 */
-	getPoint(idx: number, tupleToFill?: number[]|TypedArray): number[]|TypedArray;
-
-	/**
-	 * Get the number of points for this object can hold.
-	 */
-	getNumberOfPoints(): number;
-
-	/**
-	 * Set the number of points for this object to hold.
-	 * 
-	 * ```js
-	 * points.getData()[0] = x;
-	 * points.getData()[1] = y;
-	 * points.getData()[2] = z;
-	 * ```
-	 * 
-	 * @param {Number} nbPoints 
-	 * @param {Number} [dimension] 
-	 */
-	setNumberOfPoints(nbPoints: number, dimension?: number): void;
-
-	/**
-	 * Set the (x,y,z) coordinates of a point based on its index.
-	 * @param {Number} idx The index of point.
-	 * @param {Number} x The x coordinate.
-	 * @param {Number} y The y coordinate.
-	 * @param {Number} z The z coordinate.
-	 */
-	setPoint(idx: number, x: number, y: number, z: number): void;
-
-	/**
-	 * Insert the (x,y,z) coordinates of a point at the next available slot.
-	 * @param {Number} x The x coordinate.
-	 * @param {Number} y The y coordinate.
-	 * @param {Number} z The z coordinate.
-	 */
-	insertNextPoint(x: number, y: number, z: number): void;
-}
-
-/**
- * Method used to decorate a given object (publicAPI+model) with vtkPoints characteristics.
- *
- * @param publicAPI object on which methods will be bounds (public)
- * @param model object on which data structure will be bounds (protected)
- * @param {IPointsInitialValues} [initialValues] (default: {})
- */
-export function extend(publicAPI: object, model: object, initialValues?: IPointsInitialValues): void;
-
-/**
- * Method used to create a new instance of vtkPoints
- * @param {IPointsInitialValues} [initialValues] for pre-setting some of its content
- */
-export function newInstance(initialValues?: IPointsInitialValues): vtkPoints;
-
-
-/**
- * vtkPoints represents 3D points. The data model for vtkPoints is an array 
- * of vx-vy-vz triplets accessible by (point or cell) id.
- */
-
-export declare const vtkPoints: {
-	newInstance: typeof newInstance;
-	extend: typeof extend;
-}
-export default vtkPoints;
+import vtkDataArray from './DataArray';
+import { Bounds, TypedArray } from './../../types';
+
+/**
+ *
+ */
+export interface IPointsInitialValues {
+	empty?: boolean;
+	numberOfComponents?: number;
+	bounds?: Bounds;
+}
+
+export interface vtkPoints extends vtkDataArray {
+
+	/**
+	 * Trigger the computation of bounds
+	 */
+	computeBounds(): Bounds;
+
+	/**
+	 * Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].
+	 * @return {Bounds} The bounds for the mapper.
+	 */
+	getBounds(): Bounds;
+
+	/**
+	 * Get the coordinate of a point.
+	 * @param {Number} idx The index of point.
+	 * @param {Number[]|TypedArray} [tupleToFill] (default [])
+	 * @returns {Number[]|TypedArray}
+	 */
+	getPoint(idx: number, tupleToFill?: number[]|TypedArray): number[]|TypedArray;
+
+	/**
+	 * Convenient method to search a point in the array.
+	 * This is a naïve search. Consider using a "locator" instead.
+	 * @param {Array<Number>|TypedArray} pointToSearch
+	 * @param {Number} precision (1e-6 by default)
+	 * @returns {Number} the index of the point if found, -1 otherwise.
+	 */
+	findPoint(pointToSearch: Array<number>|TypedArray, precision?: number): number;
+
+	/**
+	 * Get the number of points for this object can hold.
+	 */
+	getNumberOfPoints(): number;
+
+	/**
+	 * Set the number of points for this object to hold.
+	 * 
+	 * ```js
+	 * points.getData()[0] = x;
+	 * points.getData()[1] = y;
+	 * points.getData()[2] = z;
+	 * ```
+	 * 
+	 * @param {Number} nbPoints 
+	 * @param {Number} [dimension] 
+	 */
+	setNumberOfPoints(nbPoints: number, dimension?: number): void;
+
+	/**
+	 * Set the (x,y,z) coordinates of a point based on its index.
+	 * @param {Number} idx The index of point.
+	 * @param {Number} x The x coordinate.
+	 * @param {Number} y The y coordinate.
+	 * @param {Number} z The z coordinate.
+	 */
+	setPoint(idx: number, x: number, y: number, z: number): void;
+
+	/**
+	 * Insert the (x,y,z) coordinates of a point at the next available slot.
+	 * @param {Number} x The x coordinate.
+	 * @param {Number} y The y coordinate.
+	 * @param {Number} z The z coordinate.
+	 */
+	insertNextPoint(x: number, y: number, z: number): void;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkPoints characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IPointsInitialValues} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues?: IPointsInitialValues): void;
+
+/**
+ * Method used to create a new instance of vtkPoints
+ * @param {IPointsInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(initialValues?: IPointsInitialValues): vtkPoints;
+
+
+/**
+ * vtkPoints represents 3D points. The data model for vtkPoints is an array 
+ * of vx-vy-vz triplets accessible by (point or cell) id.
+ */
+
+export declare const vtkPoints: {
+	newInstance: typeof newInstance;
+	extend: typeof extend;
+}
+export default vtkPoints;

package/Common/Core/Points.js

@@ -33,6 +33,7 @@ function vtkPoints(publicAPI, model) {
     publicAPI.setTuple(idx, xyz);
   };
   publicAPI.getPoint = publicAPI.getTuple;
+  publicAPI.findPoint = publicAPI.findTuple;
   publicAPI.insertNextPoint = (x, y, z) => publicAPI.insertNextTuple([x, y, z]);
   publicAPI.getBounds = () => {
     if (publicAPI.getNumberOfComponents() === 3) {

package/Filters/Core/Cutter.js

@@ -8,20 +8,25 @@ function initPolyIterator(pd) {
   const polys = pd.getPolys().getData();
   const strips = pd.getStrips().getData();
   const it = {
+    cellSize: 0,
+    cell: [],
     done: false,
     polyIdx: 0,
     stripIdx: 0,
     remainingStripLength: 0,
     // returns a single poly cell
     next() {
-      let ret = null;
       if (it.polyIdx < polys.length) {
-        const cellSize = polys[it.polyIdx];
+        it.cellSize = polys[it.polyIdx];
         const start = it.polyIdx + 1;
-        const end = start + cellSize;
+        const end = start + it.cellSize;
         it.polyIdx = end;
-        ret = polys.subarray(start, end);
+        let p = 0;
+        for (let i = start; i < end; ++i) {
+          it.cell[p++] = polys[i];
+        }
       } else if (it.stripIdx < strips.length) {
+        it.cellSize = 3;
         if (it.remainingStripLength === 0) {
           it.remainingStripLength = strips[it.stripIdx] - 2; // sliding window of 3 points
           // stripIdx points to the last point in a triangle 3-tuple
@@ -31,14 +36,18 @@ function initPolyIterator(pd) {
         const end = it.stripIdx + 1;
         it.stripIdx++;
         it.remainingStripLength--;
-        ret = strips.subarray(start, end);
-      } else if (it.done) {
+        let p = 0;
+        for (let i = start; i < end; ++i) {
+          it.cell[p++] = strips[i];
+        }
+      } else if (!it.done) {
+        it.done = true;
+      } else {
         throw new Error('Iterator is done');
       }
-      it.done = it.polyIdx >= polys.length && it.stripIdx >= strips.length;
-      return ret;
     }
   };
+  it.next();
   return it;
 }
 
@@ -82,32 +91,29 @@ function vtkCutter(publicAPI, model) {
     const crossedEdges = [];
     const x1 = new Array(3);
     const x2 = new Array(3);
+    const cellPointsScalars = [];
+
     // Loop over all cells; get scalar values for all cell points
     // and process each cell.
     /* eslint-disable no-continue */
-    const it = initPolyIterator(input);
-    while (!it.done) {
+    for (const it = initPolyIterator(input); !it.done; it.next()) {
       // cell contains the point IDs/indices
-      const cell = it.next();
 
       // Check that cells have at least 3 points
-      if (cell.length <= 2) {
+      if (it.cellSize <= 2) {
         continue;
       }
 
       // Get associated scalar of points that constitute the current cell
-      const cellPointsScalars = [];
-      let pointIndex;
-      for (let i = 0; i < cell.length; i++) {
-        pointIndex = cell[i];
-        cellPointsScalars.push(model.cutScalars[pointIndex]);
+      for (let i = 0; i < it.cellSize;) {
+        cellPointsScalars[i] = model.cutScalars[it.cell[i++]];
       }
 
       // Check if all cell points are on same side (same side == cell not crossed by cut function)
       // TODO: won't work if one point scalar is = 0 ?
       const sideFirstPoint = cellPointsScalars[0] > 0;
       let allPointsSameSide = true;
-      for (let i = 1; i < cellPointsScalars.length; i++) {
+      for (let i = 1; i < it.cell.length; i++) {
         const sideCurrentPoint = cellPointsScalars[i] > 0;
         if (sideCurrentPoint !== sideFirstPoint) {
           allPointsSameSide = false;
@@ -122,8 +128,8 @@ function vtkCutter(publicAPI, model) {
 
       // Find and compute edges which intersect cells
       const intersectedEdgesList = [];
-      for (let i = 0; i < cell.length; i++) {
-        const idNext = i + 1 === cell.length ? 0 : i + 1;
+      for (let i = 0; i < it.cellSize; i++) {
+        const idNext = i + 1 === it.cellSize ? 0 : i + 1;
 
         // Go to next edge if edge is not crossed
         // TODO: in most come cases, (numberOfPointsInCell - 1) or 0 edges of the cell
@@ -152,8 +158,8 @@ function vtkCutter(publicAPI, model) {
         }
 
         // points position
-        const pointID1 = cell[e1];
-        const pointID2 = cell[e2];
+        const pointID1 = it.cell[e1];
+        const pointID2 = it.cell[e2];
         x1[0] = pointsData[pointID1 * 3];
         x1[1] = pointsData[pointID1 * 3 + 1];
         x1[2] = pointsData[pointID1 * 3 + 2];

package/Filters/Core/PolyDataNormals.js

@@ -11,14 +11,17 @@ import vtkTriangle from '../../Common/DataModel/Triangle.js';
 function vtkPolyDataNormals(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkPolyDataNormals');
-  publicAPI.vtkPolyDataNormalsExecute = (pointsData, polysData) => {
+  publicAPI.vtkPolyDataNormalsExecute = (numberOfPolys, polysData, pointsData) => {
     if (!pointsData) {
       return null;
     }
-    const normalsData = new Float32Array(pointsData.length);
+    const pointNormals = new Float32Array(pointsData.length);
+    const cellNormals = new Float32Array(3 * numberOfPolys);
+    let cellNormalComponent = 0;
     let numberOfPoints = 0;
     const polysDataLength = polysData.length;
     const cellPointIds = [0, 0, 0];
+    const cellNormal = [0, 0, 0];
     for (let c = 0; c < polysDataLength; c += numberOfPoints + 1) {
       numberOfPoints = polysData[c];
       if (numberOfPoints < 3) {
@@ -28,26 +31,35 @@ function vtkPolyDataNormals(publicAPI, model) {
       for (let i = 1; i <= 3; ++i) {
         cellPointIds[i - 1] = 3 * polysData[c + i];
       }
-      const cellNormal = [];
       vtkTriangle.computeNormal(pointsData.slice(cellPointIds[0], cellPointIds[0] + 3), pointsData.slice(cellPointIds[1], cellPointIds[1] + 3), pointsData.slice(cellPointIds[2], cellPointIds[2] + 3), cellNormal);
-      for (let i = 1; i <= numberOfPoints; ++i) {
-        let pointId = 3 * polysData[c + i];
-        normalsData[pointId] += cellNormal[0];
-        normalsData[++pointId] += cellNormal[1];
-        normalsData[++pointId] += cellNormal[2];
+      cellNormals[cellNormalComponent++] = cellNormal[0];
+      cellNormals[cellNormalComponent++] = cellNormal[1];
+      cellNormals[cellNormalComponent++] = cellNormal[2];
+      if (model.computePointNormals) {
+        for (let i = 1; i <= numberOfPoints; ++i) {
+          let pointId = 3 * polysData[c + i];
+          pointNormals[pointId] += cellNormal[0];
+          pointNormals[++pointId] += cellNormal[1];
+          pointNormals[++pointId] += cellNormal[2];
+        }
       }
     }
 
-    /* Normalize normals */
-
-    for (let i = 0; i < pointsData.length;) {
-      const pointNormal = normalsData.slice(i, i + 3);
-      vtkMath.normalize(pointNormal);
-      normalsData[i++] = pointNormal[0];
-      normalsData[i++] = pointNormal[1];
-      normalsData[i++] = pointNormal[2];
+    // Normalize point normals.
+    // A point normal is the sum of all the cell normals the point belongs to
+    if (model.computePointNormals) {
+      const pointNormal = [0, 0, 0];
+      for (let i = 0; i < pointsData.length;) {
+        pointNormal[0] = pointNormals[i];
+        pointNormal[1] = pointNormals[i + 1];
+        pointNormal[2] = pointNormals[i + 2];
+        vtkMath.normalize(pointNormal);
+        pointNormals[i++] = pointNormal[0];
+        pointNormals[i++] = pointNormal[1];
+        pointNormals[i++] = pointNormal[2];
+      }
     }
-    return normalsData;
+    return [cellNormals, pointNormals];
   };
   publicAPI.requestData = (inData, outData) => {
     const numberOfInputs = publicAPI.getNumberOfInputPorts();
@@ -58,12 +70,7 @@ function vtkPolyDataNormals(publicAPI, model) {
     if (!input) {
       return;
     }
-    const outputNormalsData = publicAPI.vtkPolyDataNormalsExecute(input.getPoints().getData(), input.getPolys().getData());
     const output = vtkPolyData.newInstance();
-    const outputNormals = vtkDataArray.newInstance({
-      numberOfComponents: 3,
-      values: outputNormalsData
-    });
     output.setPoints(input.getPoints());
     output.setVerts(input.getVerts());
     output.setLines(input.getLines());
@@ -72,7 +79,23 @@ function vtkPolyDataNormals(publicAPI, model) {
     output.getPointData().passData(input.getPointData());
     output.getCellData().passData(input.getCellData());
     output.getFieldData().passData(input.getFieldData());
-    output.getPointData().setNormals(outputNormals);
+    const [cellNormals, pointNormals] = publicAPI.vtkPolyDataNormalsExecute(input.getNumberOfPolys(), input.getPolys().getData(), input.getPoints().getData());
+    if (model.computePointNormals) {
+      const outputPointNormals = vtkDataArray.newInstance({
+        numberOfComponents: 3,
+        name: 'Normals',
+        values: pointNormals
+      });
+      output.getPointData().setNormals(outputPointNormals);
+    }
+    if (model.computeCellNormals) {
+      const outputCellNormals = vtkDataArray.newInstance({
+        numberOfComponents: 3,
+        name: 'Normals',
+        values: cellNormals
+      });
+      output.getCellData().setNormals(outputCellNormals);
+    }
     outData[0] = output;
   };
 }
@@ -82,6 +105,8 @@ function vtkPolyDataNormals(publicAPI, model) {
 // ----------------------------------------------------------------------------
 function defaultValues(initialValues) {
   return {
+    computeCellNormals: false,
+    computePointNormals: true,
     ...initialValues
   };
 }
@@ -98,6 +123,7 @@ function extend(publicAPI, model) {
   /* Also make it an algorithm with one input and one output */
 
   macro.algo(publicAPI, model, 1, 1);
+  macro.setGet(publicAPI, model, ['computeCellNormals', 'computePointNormals']);
 
   /* Object specific methods */
 

package/Rendering/Core/Glyph3DMapper.d.ts

@@ -1,4 +1,4 @@
-import { Bounds } from './../../types';
+import { Bounds, Nullable, vtkPipelineConnection } from './../../types';
 import vtkMapper, { IMapperInitialValues } from './Mapper';
 import { OrientationModes, ScaleModes } from './Glyph3DMapper/Constants';
 
@@ -87,6 +87,12 @@ export interface vtkGlyph3DMapper extends vtkMapper {
 	 */
 	getPrimitiveCount(): IPrimitiveCount;
 
+	/**
+	 * Sets the name of the array to use as orientation.
+	 * @param {String} arrayName Name of the array
+	 */
+	setOrientationArray(arrayName: Nullable<string>): boolean;
+
 	/**
 	 * Orientation mode indicates if the OrientationArray provides the direction 
 	 * vector for the orientation or the rotations around each axes.
@@ -138,6 +144,13 @@ export interface vtkGlyph3DMapper extends vtkMapper {
 	 * Set scale to `SCALE_BY_CONSTANT`
 	 */
 	setScaleModeToScaleByConstant(): boolean;
+
+	/**
+	 * Convenient method to set the source glyph connection
+	 * @param {vtkPipelineConnection} outputPort The output port of the glyph source.
+	 */
+	setSourceConnection(outputPort: vtkPipelineConnection): void;
+
 }
 
 /**

package/Rendering/Core/Glyph3DMapper.js

@@ -112,6 +112,7 @@ function vtkGlyph3DMapper(publicAPI, model) {
       model.normalArray = new Float32Array(9 * numPts);
       const nbuff = model.normalArray.buffer;
       const tuple = [];
+      const orientation = [];
       for (let i = 0; i < numPts; ++i) {
         const z = new Float32Array(mbuff, i * 64, 16);
         trans[0] = pts[i * 3];
@@ -119,7 +120,6 @@ function vtkGlyph3DMapper(publicAPI, model) {
         trans[2] = pts[i * 3 + 2];
         mat4.translate(z, identity, trans);
         if (oArray) {
-          const orientation = [];
           oArray.getTuple(i, orientation);
           switch (model.orientationMode) {
             case OrientationModes.MATRIX:
@@ -244,6 +244,7 @@ function vtkGlyph3DMapper(publicAPI, model) {
     };
     return pcount;
   };
+  publicAPI.setSourceConnection = outputPort => publicAPI.setInputConnection(outputPort, 1);
 }
 
 // ----------------------------------------------------------------------------

package/Rendering/Core/ImageMapper.d.ts

@@ -257,11 +257,27 @@ export interface vtkImageMapper extends vtkAbstractImageMapper {
 	 */
 	getSlicingModeNormal(): number[];
 
+	/**
+	 * Get the slicing mode. 
+	 */
+	getSlicingMode(): SlicingMode;
+
 	/**
 	 * Set the slicing mode. 
-	 * @param {Number} mode The slicing mode.
+	 * @param {SlicingMode} mode The slicing mode.
+	 */
+	setSlicingMode(mode: SlicingMode): boolean;
+
+	/**
+	 * Get the preference to use halfFloat representation of float
+	 */
+	getPreferSizeOverAccuracy(): boolean;
+
+	/**
+	 * Set the preference to use halfFloat representation of float
+	 * @param {Boolean} preferSizeOverAccuracy
 	 */
-	setSlicingMode(mode: number): boolean;
+	setPreferSizeOverAccuracy(preferSizeOverAccuracy: boolean): boolean;
 }
 
 /**

package/Rendering/Core/RenderWindowInteractor.js

@@ -17,7 +17,11 @@ const {
 // Global methods
 // ----------------------------------------------------------------------------
 
-const EMPTY_MOUSE_EVENT = new MouseEvent('');
+const EMPTY_MOUSE_EVENT = {
+  ctrlKey: false,
+  altKey: false,
+  shiftKey: false
+};
 const deviceInputMap = {
   'xr-standard': [Input.Trigger, Input.Grip, Input.TrackPad, Input.Thumbstick, Input.A, Input.B]
 };

package/Widgets/Representations/GlyphRepresentation.js

@@ -257,6 +257,9 @@ function extend(publicAPI, model) {
   } else {
     vtkHandleRepresentation.extend(publicAPI, model, defaultValues(publicAPI, model, initialValues));
   }
+  if ('lighting' in initialValues) {
+    model._pipeline.actor.getProperty().setLighting(initialValues.lighting);
+  }
   macro.setGet(publicAPI, model._pipeline, ['defaultScale']);
   macro.get(publicAPI, model._pipeline, ['glyph', 'mapper', 'actor']);
   // Expose the mixin functions to allow overwriting

package/Widgets/Representations/LineHandleRepresentation.js

@@ -87,6 +87,7 @@ function defaultValues(initialValues) {
     _pipeline: {
       glyph: vtkCylinderSource.newInstance({
         resolution: initialValues.glyphResolution ?? 4,
+        initAngle: initialValues.glyphAngle ?? Math.PI / 4,
         direction: [0, 0, 1]
       })
     },

package/Widgets/Widgets3D/ResliceCursorWidget.js

@@ -178,14 +178,16 @@ function vtkResliceCursorWidget(publicAPI, model) {
           labels: [`rotationIn${viewTypeToPlaneName[viewType]}`],
           initialValues: {
             useActiveColor: false,
-            scaleInPixels: model.scaleInPixels
+            scaleInPixels: model.scaleInPixels,
+            lighting: false
           }
         }, {
           builder: vtkSphereHandleRepresentation,
           labels: ['center'],
           initialValues: {
             useActiveColor: false,
-            scaleInPixels: model.scaleInPixels
+            scaleInPixels: model.scaleInPixels,
+            lighting: false
           }
         }];
       case ViewTypes.DEFAULT:

package/package.json

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