@kitware/vtk.js 24.4.1 → 24.5.0

package/Common/Core/Math/index.js

@@ -2329,4 +2329,4 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   'default': vtkMath
 });
 
-export { binomial as $, degreesFromRadians as A, areEquals as B, clampValue as C, arrayRange as D, getMajorAxisIndex as E, isInf as F, rgb2hsv as G, rgb2lab as H, lab2rgb as I, floor as J, round as K, normalize2D as L, nearestPowerOfTwo as M, createUninitializedBounds as N, multiply3x3_vect3 as O, areBoundsInitialized as P, isPowerOfTwo as Q, angleBetweenVectors as R, signedAngleBetweenVectors as S, Pi as T, ceil as U, min as V, max as W, arrayMin as X, arrayMax as Y, ceilLog2 as Z, factorial as _, areMatricesEqual as a, beginCombination as a0, nextCombination as a1, randomSeed as a2, getSeed as a3, gaussian as a4, multiplyScalar2D as a5, multiplyAccumulate2D as a6, outer as a7, projectVector as a8, dot2D as a9, hex2float as aA, lab2xyz as aB, xyz2lab as aC, xyz2rgb as aD, rgb2xyz as aE, clampAndNormalizeValue as aF, getScalarTypeFittingRange as aG, getAdjustedScalarRange as aH, extentIsWithinOtherExtent as aI, boundsIsWithinOtherBounds as aJ, pointIsWithinBounds as aK, solve3PointCircle as aL, inf as aM, negInf as aN, isFinite as aO, isNaN as aP, floatToHex2 as aQ, floatRGB2HexCode as aR, float2CssRGBA as aS, projectVector2D as aa, gaussianAmplitude as ab, gaussianWeight as ac, outer2D as ad, norm2D as ae, LUFactor3x3 as af, LUSolve3x3 as ag, linearSolve3x3 as ah, multiply3x3_mat3 as ai, multiplyMatrix as aj, transpose3x3 as ak, invert3x3 as al, identity3x3 as am, quaternionToMatrix3x3 as an, roundNumber as ao, matrix3x3ToQuaternion as ap, multiplyQuaternion as aq, orthogonalize3x3 as ar, diagonalize3x3 as as, singularValueDecomposition3x3 as at, luFactorLinearSystem as au, luSolveLinearSystem as av, invertMatrix as aw, estimateMatrixCondition as ax, solveHomogeneousLeastSquares as ay, solveLeastSquares as az, roundVector as b, computeBoundsFromPoints as c, dot as d, clampVector as e, distance2BetweenPoints as f, subtract as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, multiplyAccumulate as m, norm as n, determinant2x2 as o, jacobiN as p, perpendiculars as q, radiansFromDegrees as r, solveLinearSystem as s, jacobi as t, uninitializeBounds as u, vtkMath$1 as v, vtkMath as w, multiplyScalar as x, random as y, determinant3x3 as z };
+export { binomial as $, degreesFromRadians as A, areEquals as B, clampValue as C, arrayRange as D, getMajorAxisIndex as E, isInf as F, rgb2hsv as G, rgb2lab as H, lab2rgb as I, floor as J, round as K, normalize2D as L, nearestPowerOfTwo as M, createUninitializedBounds as N, multiply3x3_vect3 as O, areBoundsInitialized as P, isPowerOfTwo as Q, angleBetweenVectors as R, signedAngleBetweenVectors as S, Pi as T, ceil as U, min as V, max as W, arrayMin as X, arrayMax as Y, ceilLog2 as Z, factorial as _, areMatricesEqual as a, beginCombination as a0, nextCombination as a1, randomSeed as a2, getSeed as a3, gaussian as a4, multiplyScalar2D as a5, multiplyAccumulate2D as a6, outer as a7, projectVector as a8, dot2D as a9, hex2float as aA, lab2xyz as aB, xyz2lab as aC, xyz2rgb as aD, rgb2xyz as aE, clampAndNormalizeValue as aF, getScalarTypeFittingRange as aG, getAdjustedScalarRange as aH, extentIsWithinOtherExtent as aI, boundsIsWithinOtherBounds as aJ, pointIsWithinBounds as aK, solve3PointCircle as aL, inf as aM, negInf as aN, isFinite as aO, isNaN as aP, floatToHex2 as aQ, floatRGB2HexCode as aR, float2CssRGBA as aS, projectVector2D as aa, gaussianAmplitude as ab, gaussianWeight as ac, outer2D as ad, norm2D as ae, LUFactor3x3 as af, LUSolve3x3 as ag, linearSolve3x3 as ah, multiply3x3_mat3 as ai, multiplyMatrix as aj, transpose3x3 as ak, invert3x3 as al, identity3x3 as am, quaternionToMatrix3x3 as an, roundNumber as ao, matrix3x3ToQuaternion as ap, multiplyQuaternion as aq, orthogonalize3x3 as ar, diagonalize3x3 as as, singularValueDecomposition3x3 as at, luFactorLinearSystem as au, luSolveLinearSystem as av, invertMatrix as aw, estimateMatrixCondition as ax, solveHomogeneousLeastSquares as ay, solveLeastSquares as az, roundVector as b, computeBoundsFromPoints as c, dot as d, clampVector as e, distance2BetweenPoints as f, subtract as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, multiplyAccumulate as m, norm as n, determinant2x2 as o, jacobiN as p, perpendiculars as q, radiansFromDegrees as r, solveLinearSystem as s, vtkMath as t, uninitializeBounds as u, vtkMath$1 as v, jacobi as w, multiplyScalar as x, random as y, determinant3x3 as z };

package/Common/Core/Math.js

@@ -1,4 +1,4 @@
 import '@babel/runtime/helpers/slicedToArray';
 import 'seedrandom';
 import '../../macros.js';
-export { af as LUFactor3x3, ag as LUSolve3x3, T as Pi, k as add, R as angleBetweenVectors, P as areBoundsInitialized, B as areEquals, a as areMatricesEqual, Y as arrayMax, X as arrayMin, D as arrayRange, a0 as beginCombination, $ as binomial, aJ as boundsIsWithinOtherBounds, U as ceil, Z as ceilLog2, aF as clampAndNormalizeValue, C as clampValue, e as clampVector, c as computeBoundsFromPoints, N as createUninitializedBounds, j as cross, w as default, A as degreesFromRadians, o as determinant2x2, z as determinant3x3, as as diagonalize3x3, f as distance2BetweenPoints, d as dot, a9 as dot2D, ax as estimateMatrixCondition, aI as extentIsWithinOtherExtent, _ as factorial, aS as float2CssRGBA, aR as floatRGB2HexCode, aQ as floatToHex2, J as floor, a4 as gaussian, ab as gaussianAmplitude, ac as gaussianWeight, aH as getAdjustedScalarRange, E as getMajorAxisIndex, aG as getScalarTypeFittingRange, a3 as getSeed, aA as hex2float, h as hsv2rgb, am as identity3x3, aM as inf, al as invert3x3, aw as invertMatrix, aO as isFinite, F as isInf, aP as isNaN, i as isNan, Q as isPowerOfTwo, t as jacobi, p as jacobiN, I as lab2rgb, aB as lab2xyz, ah as linearSolve3x3, au as luFactorLinearSystem, av as luSolveLinearSystem, ap as matrix3x3ToQuaternion, W as max, V as min, ai as multiply3x3_mat3, O as multiply3x3_vect3, m as multiplyAccumulate, a6 as multiplyAccumulate2D, aj as multiplyMatrix, aq as multiplyQuaternion, x as multiplyScalar, a5 as multiplyScalar2D, M as nearestPowerOfTwo, aN as negInf, a1 as nextCombination, n as norm, ae as norm2D, l as normalize, L as normalize2D, ar as orthogonalize3x3, a7 as outer, ad as outer2D, q as perpendiculars, aK as pointIsWithinBounds, a8 as projectVector, aa as projectVector2D, an as quaternionToMatrix3x3, r as radiansFromDegrees, y as random, a2 as randomSeed, G as rgb2hsv, H as rgb2lab, aE as rgb2xyz, K as round, ao as roundNumber, b as roundVector, S as signedAngleBetweenVectors, at as singularValueDecomposition3x3, aL as solve3PointCircle, ay as solveHomogeneousLeastSquares, az as solveLeastSquares, s as solveLinearSystem, g as subtract, ak as transpose3x3, u as uninitializeBounds, aC as xyz2lab, aD as xyz2rgb } from './Math/index.js';
+export { af as LUFactor3x3, ag as LUSolve3x3, T as Pi, k as add, R as angleBetweenVectors, P as areBoundsInitialized, B as areEquals, a as areMatricesEqual, Y as arrayMax, X as arrayMin, D as arrayRange, a0 as beginCombination, $ as binomial, aJ as boundsIsWithinOtherBounds, U as ceil, Z as ceilLog2, aF as clampAndNormalizeValue, C as clampValue, e as clampVector, c as computeBoundsFromPoints, N as createUninitializedBounds, j as cross, t as default, A as degreesFromRadians, o as determinant2x2, z as determinant3x3, as as diagonalize3x3, f as distance2BetweenPoints, d as dot, a9 as dot2D, ax as estimateMatrixCondition, aI as extentIsWithinOtherExtent, _ as factorial, aS as float2CssRGBA, aR as floatRGB2HexCode, aQ as floatToHex2, J as floor, a4 as gaussian, ab as gaussianAmplitude, ac as gaussianWeight, aH as getAdjustedScalarRange, E as getMajorAxisIndex, aG as getScalarTypeFittingRange, a3 as getSeed, aA as hex2float, h as hsv2rgb, am as identity3x3, aM as inf, al as invert3x3, aw as invertMatrix, aO as isFinite, F as isInf, aP as isNaN, i as isNan, Q as isPowerOfTwo, w as jacobi, p as jacobiN, I as lab2rgb, aB as lab2xyz, ah as linearSolve3x3, au as luFactorLinearSystem, av as luSolveLinearSystem, ap as matrix3x3ToQuaternion, W as max, V as min, ai as multiply3x3_mat3, O as multiply3x3_vect3, m as multiplyAccumulate, a6 as multiplyAccumulate2D, aj as multiplyMatrix, aq as multiplyQuaternion, x as multiplyScalar, a5 as multiplyScalar2D, M as nearestPowerOfTwo, aN as negInf, a1 as nextCombination, n as norm, ae as norm2D, l as normalize, L as normalize2D, ar as orthogonalize3x3, a7 as outer, ad as outer2D, q as perpendiculars, aK as pointIsWithinBounds, a8 as projectVector, aa as projectVector2D, an as quaternionToMatrix3x3, r as radiansFromDegrees, y as random, a2 as randomSeed, G as rgb2hsv, H as rgb2lab, aE as rgb2xyz, K as round, ao as roundNumber, b as roundVector, S as signedAngleBetweenVectors, at as singularValueDecomposition3x3, aL as solve3PointCircle, ay as solveHomogeneousLeastSquares, az as solveLeastSquares, s as solveLinearSystem, g as subtract, ak as transpose3x3, u as uninitializeBounds, aC as xyz2lab, aD as xyz2rgb } from './Math/index.js';

package/Filters/Core/PolyDataNormals.js

@@ -0,0 +1,124 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import macro from '../../macros.js';
+import vtkDataArray from '../../Common/Core/DataArray.js';
+import { t as vtkMath } from '../../Common/Core/Math/index.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import vtkTriangle from '../../Common/DataModel/Triangle.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; }
+// vtkPolyDataNormals methods
+// ----------------------------------------------------------------------------
+
+function vtkPolyDataNormals(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkPolyDataNormals');
+
+  publicAPI.vtkPolyDataNormalsExecute = function (pointsData, polysData) {
+    if (!pointsData) {
+      return null;
+    }
+
+    var normalsData = new Float32Array(pointsData.length);
+    var numberOfPoints = 0;
+    var polysDataLength = polysData.length;
+    var cellPointIds = [0, 0, 0];
+
+    for (var c = 0; c < polysDataLength; c += numberOfPoints + 1) {
+      numberOfPoints = polysData[c];
+
+      if (numberOfPoints < 3) {
+        continue; // eslint-disable-line
+      }
+
+      for (var i = 1; i <= 3; ++i) {
+        cellPointIds[i - 1] = 3 * polysData[c + i];
+      }
+
+      var 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 (var _i = 1; _i <= numberOfPoints; ++_i) {
+        var pointId = 3 * polysData[c + _i];
+        normalsData[pointId] += cellNormal[0];
+        normalsData[++pointId] += cellNormal[1];
+        normalsData[++pointId] += cellNormal[2];
+      }
+    }
+    /* Normalize normals */
+
+
+    for (var _i2 = 0; _i2 < pointsData.length;) {
+      var pointNormal = normalsData.slice(_i2, _i2 + 3);
+      vtkMath.normalize(pointNormal);
+      normalsData[_i2++] = pointNormal[0];
+      normalsData[_i2++] = pointNormal[1];
+      normalsData[_i2++] = pointNormal[2];
+    }
+
+    return normalsData;
+  };
+
+  publicAPI.requestData = function (inData, outData) {
+    var numberOfInputs = publicAPI.getNumberOfInputPorts();
+
+    if (!numberOfInputs) {
+      return;
+    }
+
+    var input = inData[0];
+
+    if (!input) {
+      return;
+    }
+
+    var outputNormalsData = publicAPI.vtkPolyDataNormalsExecute(input.getPoints().getData(), input.getPolys().getData());
+    var output = vtkPolyData.newInstance();
+    var outputNormals = vtkDataArray.newInstance({
+      numberOfComponents: 3,
+      values: outputNormalsData
+    });
+    output.setPointData(input.getPointData());
+    output.setCellData(input.getCellData());
+    output.setFieldData(input.getFieldData());
+    output.setPoints(input.getPoints());
+    output.setVerts(input.getVerts());
+    output.setLines(input.getLines());
+    output.setPolys(input.getPolys());
+    output.setStrips(input.getStrips());
+    output.getPointData().setNormals(outputNormals);
+    outData[0] = output;
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+function defaultValues(initialValues) {
+  return _objectSpread({}, initialValues);
+} // ----------------------------------------------------------------------------
+
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, defaultValues(initialValues));
+  /* Make this a VTK object */
+
+  macro.obj(publicAPI, model);
+  /* Also make it an algorithm with one input and one output */
+
+  macro.algo(publicAPI, model, 1, 1);
+  /* Object specific methods */
+
+  vtkPolyDataNormals(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkPolyDataNormals'); // ----------------------------------------------------------------------------
+
+var vtkPolyDataNormals$1 = {
+  newInstance: newInstance,
+  extend: extend
+};
+
+export { vtkPolyDataNormals$1 as default, extend, newInstance };

package/Filters/Core.js

@@ -1,7 +1,9 @@
 import vtkCutter from './Core/Cutter.js';
+import vtkPolyDataNormals from './Core/PolyDataNormals.js';
 
 var Core = {
-  vtkCutter: vtkCutter
+  vtkCutter: vtkCutter,
+  vtkPolyDataNormals: vtkPolyDataNormals
 };
 
 export { Core as default };

package/Filters/General/OBBTree.js

@@ -2,7 +2,7 @@ import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 import vtkCellArray from '../../Common/Core/CellArray.js';
 import vtkLine from '../../Common/DataModel/Line.js';
-import { d as dot, j as cross, n as norm, t as jacobi, l as normalize, k as add } from '../../Common/Core/Math/index.js';
+import { d as dot, j as cross, n as norm, w as jacobi, l as normalize, k as add } from '../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 import vtkOBBNode from './OBBTree/OBBNode.js';
 import vtkPoints from '../../Common/Core/Points.js';

package/Filters/General/WindowedSincPolyDataFilter.js

@@ -2,7 +2,7 @@ import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { w as vtkMath } from '../../Common/Core/Math/index.js';
+import { t as vtkMath } from '../../Common/Core/Math/index.js';
 import { AttributeTypes } from '../../Common/DataModel/DataSetAttributes/Constants.js';
 import vtkPoints from '../../Common/Core/Points.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';

package/IO/Misc/OBJReader.d.ts

@@ -28,6 +28,24 @@ type vtkOBJReaderBase = vtkObject & Omit<vtkAlgorithm,
 	| 'addInputConnection'
 	| 'addInputData'>;
 
+/**
+ * Convenient method to get the id of all duplicated points.
+ * Relies on a "Duplicates" array that contains the id of:
+ * 	- the first duplicate id for the original point (or self Id if there is no duplicate)
+ *  - the original id for the duplicate points
+ * Duplicated points must be adjacent to each other.
+ * Example:
+ * 	- Points: [pt0, pt1, pt2, pt3, pt1d0, pt1d1, pt1d3, pt3d1, pt3d2]
+ *  - Duplicates: [0, 4, 2, 3, 1, 1, 1, 3, 3]
+ * Expected results:
+ *  - getPointDuplicateIds(p, 1) => [1, 4, 5, 6]
+ *  - getPointDuplicateIds(p, 0) => [0]
+ *  - getPointDuplicateIds(p, 5) => [1, 4, 5, 6]
+ * @param polydata A polydata generated by the OBJReader
+ * @param pointId A point Id (duplicated or not)
+ */
+export function getPointDuplicateIds(polydata: any, pointId: number): Array<number>;
+
 export interface vtkOBJReader extends vtkOBJReaderBase {
 
 	/**
@@ -50,6 +68,11 @@ export interface vtkOBJReader extends vtkOBJReaderBase {
 	 */
 	getSplitMode(): number;
 
+	/**
+	 * True if duplicates are tracked in output polydata.
+	 */
+	getTrackDuplicates(): boolean
+
 	/**
 	 * 
 	 * @param {Boolean} busy 
@@ -93,11 +116,19 @@ export interface vtkOBJReader extends vtkOBJReaderBase {
 	setDataAccessHelper(dataAccessHelper: HtmlDataAccessHelper | HttpDataAccessHelper | JSZipDataAccessHelper | LiteHttpDataAccessHelper): boolean;
 
 	/**
-	 * 
-	 * @param {String} splitMode 
+	 * String in OBJ file used to split in multiple output polydata.
+	 * @param {Null | String} splitMode 
 	 */
 	setSplitMode(splitMode: string): boolean;
 
+	/**
+	 * Set to true to be able to use getPointDuplicateIds() on output polydata.
+	 * Requires splitMode to not be null.
+	 * @param trackDuplicates true or false (false by default)
+	 * @see getPointDuplicateIds(), setSplitMode()
+	 */
+	setTrackDuplicates(trackDuplicates: boolean): boolean;
+
 	/**
 	 * Set the url of the object to load.
 	 * @param {String} url the url of the object to load.

package/IO/Misc/OBJReader.js

@@ -1,3 +1,4 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import macro from '../../macros.js';
 import DataAccessHelper from '../Core/DataAccessHelper.js';
@@ -5,6 +6,9 @@ import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import '../Core/DataAccessHelper/LiteHttpDataAccessHelper.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; }
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/HttpDataAccessHelper'; // HTTP + gz
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/HtmlDataAccessHelper'; // html + base64 + zip
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/JSZipDataAccessHelper'; // zip
@@ -12,9 +16,9 @@ import '../Core/DataAccessHelper/LiteHttpDataAccessHelper.js';
 
 var data = {}; // ----------------------------------------------------------------------------
 
-function pushVector(src, srcOffset, dst, vectorSize) {
+function copyVector(src, srcOffset, dst, dstOffset, vectorSize) {
   for (var i = 0; i < vectorSize; i++) {
-    dst.push(src[srcOffset + i]);
+    dst[dstOffset + i] = src[srcOffset + i];
   }
 } // ----------------------------------------------------------------------------
 
@@ -93,6 +97,60 @@ function end(model) {
     model.numberOfOutputs = data.size;
 
     for (var idx = 0; idx < data.size; idx++) {
+      var polyIn = data.f[idx];
+      var nbElems = polyIn.length;
+      var nbPoints = data.v.length / 3;
+      var keyPointId = {};
+      var pointDuplicatesReferences = void 0;
+
+      if (model.trackDuplicates) {
+        // In trackDuplicates mode, we want the following point layout:
+        // [pt0, pt1, pt2, ... ptN, pt0d1, pt0d2, pt1d1]
+        var pointKeys = [];
+        var duplicatesCount = 0;
+
+        for (var _offset = 0; _offset < nbElems;) {
+          var cellSize = polyIn[_offset++];
+
+          for (var pIdx = 0; pIdx < cellSize; pIdx++) {
+            var _polyIn$_offset = _slicedToArray(polyIn[_offset++], 3),
+                vIdx = _polyIn$_offset[0],
+                tcIdx = _polyIn$_offset[1],
+                nIdx = _polyIn$_offset[2];
+
+            var key = "".concat(vIdx, "/").concat(tcIdx, "/").concat(nIdx);
+
+            if (keyPointId[key] === undefined) {
+              if (pointKeys[vIdx] === undefined) {
+                pointKeys[vIdx] = [key];
+              } else {
+                pointKeys[vIdx].push(key);
+                ++duplicatesCount;
+              } // will be overwritten for duplicates
+
+
+              keyPointId[key] = vIdx;
+            }
+          }
+        }
+
+        pointDuplicatesReferences = new Uint16Array(nbPoints + duplicatesCount);
+        var duplicates = 0;
+
+        for (var pointId = 0; pointId < pointKeys.length; ++pointId) {
+          var usageCount = pointKeys[pointId] ? pointKeys[pointId].length : 0; // Set the first duplicate index on the original point
+
+          pointDuplicatesReferences[pointId] = usageCount > 1 ? nbPoints + duplicates : pointId; // Set the original index on each duplicated point
+
+          for (var duplicateId = 1; duplicateId < usageCount; ++duplicateId) {
+            var finalDuplicateId = nbPoints + duplicates++;
+            pointDuplicatesReferences[finalDuplicateId] = pointId; // Associate the duplicate index to the key
+
+            keyPointId[pointKeys[pointId][duplicateId]] = finalDuplicateId;
+          }
+        }
+      }
+
       var ctMapping = {};
       var polydata = vtkPolyData.newInstance({
         name: data.pieces[idx]
@@ -101,42 +159,50 @@ function end(model) {
       var tc = [];
       var normals = [];
       var polys = [];
-      var polyIn = data.f[idx];
-      var nbElems = polyIn.length;
       var offset = 0;
 
       while (offset < nbElems) {
-        var cellSize = polyIn[offset];
-        polys.push(cellSize);
+        var _cellSize = polyIn[offset];
+        polys.push(_cellSize);
 
-        for (var pIdx = 0; pIdx < cellSize; pIdx++) {
-          var _polyIn = _slicedToArray(polyIn[offset + pIdx + 1], 3),
-              vIdx = _polyIn[0],
-              tcIdx = _polyIn[1],
-              nIdx = _polyIn[2];
+        for (var _pIdx = 0; _pIdx < _cellSize; _pIdx++) {
+          var _polyIn = _slicedToArray(polyIn[offset + _pIdx + 1], 3),
+              _vIdx = _polyIn[0],
+              _tcIdx = _polyIn[1],
+              _nIdx = _polyIn[2];
 
-          var key = "".concat(vIdx, "/").concat(tcIdx, "/").concat(nIdx);
+          var _key = "".concat(_vIdx, "/").concat(_tcIdx, "/").concat(_nIdx);
 
-          if (ctMapping[key] === undefined) {
-            ctMapping[key] = pts.length / 3;
-            pushVector(data.v, vIdx * 3, pts, 3);
+          if (ctMapping[_key] === undefined) {
+            var dstOffset = model.trackDuplicates ? keyPointId[_key] : pts.length / 3;
+            ctMapping[_key] = dstOffset;
+            copyVector(data.v, _vIdx * 3, pts, dstOffset * 3, 3);
 
             if (hasTcoords) {
-              pushVector(data.vt, tcIdx * 2, tc, 2);
+              copyVector(data.vt, _tcIdx * 2, tc, dstOffset * 2, 2);
             }
 
             if (hasNormals) {
-              pushVector(data.vn, nIdx * 3, normals, 3);
+              copyVector(data.vn, _nIdx * 3, normals, dstOffset * 3, 3);
             }
           }
 
-          polys.push(ctMapping[key]);
+          polys.push(ctMapping[_key]);
         }
 
-        offset += cellSize + 1;
+        offset += _cellSize + 1;
       }
 
       polydata.getPoints().setData(Float32Array.from(pts), 3);
+
+      if (model.trackDuplicates) {
+        var duplicatesArray = vtkDataArray.newInstance({
+          name: 'Duplicates',
+          values: pointDuplicatesReferences
+        });
+        polydata.getPointData().addArray(duplicatesArray);
+      }
+
       polydata.getPolys().setData(Uint32Array.from(polys));
 
       if (hasTcoords) {
@@ -190,21 +256,21 @@ function end(model) {
     var _polys = [];
     var _polyIn2 = data.f[0];
     var _nbElems = _polyIn2.length;
-    var _offset = 0;
+    var _offset2 = 0;
 
-    while (_offset < _nbElems) {
-      var _cellSize = _polyIn2[_offset];
+    while (_offset2 < _nbElems) {
+      var _cellSize2 = _polyIn2[_offset2];
 
-      _polys.push(_cellSize);
+      _polys.push(_cellSize2);
 
-      for (var _pIdx = 0; _pIdx < _cellSize; _pIdx++) {
-        var _polyIn3 = _slicedToArray(_polyIn2[_offset + _pIdx + 1], 1),
-            _vIdx = _polyIn3[0];
+      for (var _pIdx2 = 0; _pIdx2 < _cellSize2; _pIdx2++) {
+        var _polyIn3 = _slicedToArray(_polyIn2[_offset2 + _pIdx2 + 1], 1),
+            _vIdx2 = _polyIn3[0];
 
-        _polys.push(_vIdx);
+        _polys.push(_vIdx2);
       }
 
-      _offset += _cellSize + 1;
+      _offset2 += _cellSize2 + 1;
     }
 
     _polydata.getPolys().setData(Uint32Array.from(_polys));
@@ -212,10 +278,41 @@ function end(model) {
     model.output[0] = _polydata;
   }
 } // ----------------------------------------------------------------------------
-// vtkOBJReader methods
+// Static API
 // ----------------------------------------------------------------------------
 
 
+function getPointDuplicateIds(polyData, pointId) {
+  var res = [];
+  var duplicates = polyData.getPointData().getArrayByName('Duplicates');
+
+  if (duplicates == null) {
+    return res;
+  }
+
+  var duplicatesData = duplicates.getData();
+  var originalPointId = Math.min(pointId, duplicatesData[pointId]);
+  res.push(originalPointId);
+  var duplicateId = duplicatesData[originalPointId];
+
+  if (duplicateId !== originalPointId) {
+    // point has duplicates
+    while (duplicateId < duplicatesData.length && duplicatesData[duplicateId] === originalPointId) {
+      // Duplicated points must be next to each other and original point must
+      // reference first duplicate
+      res.push(duplicateId++);
+    }
+  }
+
+  return res;
+}
+
+var STATIC = {
+  getPointDuplicateIds: getPointDuplicateIds
+}; // ----------------------------------------------------------------------------
+// vtkOBJReader methods
+// ----------------------------------------------------------------------------
+
 function vtkOBJReader(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkOBJReader'); // Create default dataAccessHelper if not available
@@ -292,7 +389,8 @@ function vtkOBJReader(publicAPI, model) {
 var DEFAULT_VALUES = {
   numberOfOutputs: 1,
   requestCount: 0,
-  splitMode: null // baseURL: null,
+  splitMode: null,
+  trackDuplicates: false // baseURL: null,
   // dataAccessHelper: null,
   // url: null,
 
@@ -304,7 +402,7 @@ function extend(publicAPI, model) {
 
   macro.obj(publicAPI, model);
   macro.get(publicAPI, model, ['url', 'baseURL']);
-  macro.setGet(publicAPI, model, ['dataAccessHelper', 'splitMode']);
+  macro.setGet(publicAPI, model, ['dataAccessHelper', 'splitMode', 'trackDuplicates']);
   macro.algo(publicAPI, model, 0, 1);
   macro.event(publicAPI, model, 'busy'); // Object methods
 
@@ -313,9 +411,9 @@ function extend(publicAPI, model) {
 
 var newInstance = macro.newInstance(extend, 'vtkOBJReader'); // ----------------------------------------------------------------------------
 
-var vtkOBJReader$1 = {
+var vtkOBJReader$1 = _objectSpread({
   newInstance: newInstance,
   extend: extend
-};
+}, STATIC);
 
-export { vtkOBJReader$1 as default, extend, newInstance };
+export { STATIC, vtkOBJReader$1 as default, extend, newInstance };

package/Widgets/Widgets3D/ShapeWidget/behavior.js

@@ -1,7 +1,7 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../../macros.js';
-import { w as vtkMath } from '../../../Common/Core/Math/index.js';
+import { t as vtkMath } from '../../../Common/Core/Math/index.js';
 import vtkBoundingBox from '../../../Common/DataModel/BoundingBox.js';
 import vtkPlane from '../../../Common/DataModel/Plane.js';
 import { ShapeBehavior, BehaviorCategory, TextPosition } from './Constants.js';

package/package.json

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