@kitware/vtk.js 35.0.0 → 35.2.0

package/Common/DataModel/Sphere.d.ts

@@ -90,6 +90,34 @@ export function newInstance(initialValues?: ISphereInitialValues): vtkSphere;
  */
 declare function evaluate(radius: number, center: Vector3, x: Vector3): number;
 
+/**
+ * Approximate bounding sphere for a point set represented as a flat xyz array.
+ * Returns `[cx, cy, cz, r]`.
+ *
+ * @param {Array<number>|TypedArray} pts flat xyz point coordinates
+ * @param {number} [numPts] number of points to process
+ * @param {number[]} [hints] two point ids expected to be far apart
+ */
+declare function computeBoundingSphere(
+  pts: Array<number> | ArrayLike<number>,
+  numPts?: number,
+  hints?: number[]
+): [number, number, number, number];
+
+/**
+ * Approximate bounding sphere for an array of spheres `[x, y, z, r]`.
+ * Returns `[cx, cy, cz, r]`.
+ *
+ * @param {Array<Vector4>} spheres list of spheres
+ * @param {number} [numSpheres] number of spheres to process
+ * @param {number[]} [hints] two sphere ids expected to be far apart
+ */
+declare function computeBoundingSphereFromSpheres(
+  spheres: Array<[number, number, number, number]>,
+  numSpheres?: number,
+  hints?: number[]
+): [number, number, number, number];
+
 /**
  * vtkSphere provides methods for creating a 1D cubic spline object from given
  * parameters, and allows for the calculation of the spline value and derivative
@@ -99,5 +127,7 @@ export declare const vtkSphere: {
   newInstance: typeof newInstance;
   extend: typeof extend;
   evaluate: typeof evaluate;
+  computeBoundingSphere: typeof computeBoundingSphere;
+  computeBoundingSphereFromSpheres: typeof computeBoundingSphereFromSpheres;
 };
 export default vtkSphere;

package/Common/DataModel/Sphere.js

@@ -1,5 +1,6 @@
 import { m as macro } from '../../macros2.js';
 import vtkImplicitFunction from './ImplicitFunction.js';
+import { f as distance2BetweenPoints } from '../Core/Math/index.js';
 
 // ----------------------------------------------------------------------------
 // Global methods
@@ -13,13 +14,200 @@ function evaluate(radius, center, xyz) {
   const r = [(xyz[0] - center[0]) / radius[0], (xyz[1] - center[1]) / radius[1], (xyz[2] - center[2]) / radius[2]];
   return r[0] * r[0] + r[1] * r[1] + r[2] * r[2] - 1;
 }
+function setPointFromArray(dst, pts, pointId) {
+  const offset = 3 * pointId;
+  dst[0] = pts[offset];
+  dst[1] = pts[offset + 1];
+  dst[2] = pts[offset + 2];
+}
+function copyPoint(dst, src) {
+  dst[0] = src[0];
+  dst[1] = src[1];
+  dst[2] = src[2];
+}
+function copySphere(dst, src) {
+  dst[0] = src[0];
+  dst[1] = src[1];
+  dst[2] = src[2];
+  dst[3] = src[3];
+}
+
+// Inspired by Graphics Gems Vol. I ("An Efficient Bounding Sphere" by Jack Ritter).
+function computeBoundingSphere(pts, numPts, hints) {
+  const actualNumPts = numPts ?? Math.floor(pts.length / 3);
+  const sphere = [0, 0, 0, 0];
+  if (actualNumPts < 1) {
+    return sphere;
+  }
+  const d1 = [0, 0, 0];
+  const d2 = [0, 0, 0];
+  if (hints && hints.length >= 2) {
+    setPointFromArray(d1, pts, hints[0]);
+    setPointFromArray(d2, pts, hints[1]);
+  } else {
+    const xMin = [Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE];
+    const yMin = [Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE];
+    const zMin = [Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE];
+    const xMax = [-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE];
+    const yMax = [-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE];
+    const zMax = [-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE];
+    const p = [0, 0, 0];
+    for (let i = 0; i < actualNumPts; i++) {
+      setPointFromArray(p, pts, i);
+      if (p[0] < xMin[0]) copyPoint(xMin, p);
+      if (p[0] > xMax[0]) copyPoint(xMax, p);
+      if (p[1] < yMin[1]) copyPoint(yMin, p);
+      if (p[1] > yMax[1]) copyPoint(yMax, p);
+      if (p[2] < zMin[2]) copyPoint(zMin, p);
+      if (p[2] > zMax[2]) copyPoint(zMax, p);
+    }
+    const xSpan = distance2BetweenPoints(xMax, xMin);
+    const ySpan = distance2BetweenPoints(yMax, yMin);
+    const zSpan = distance2BetweenPoints(zMax, zMin);
+    if (xSpan > ySpan) {
+      if (xSpan > zSpan) {
+        copyPoint(d1, xMin);
+        copyPoint(d2, xMax);
+      } else {
+        copyPoint(d1, zMin);
+        copyPoint(d2, zMax);
+      }
+    } else if (ySpan > zSpan) {
+      copyPoint(d1, yMin);
+      copyPoint(d2, yMax);
+    } else {
+      copyPoint(d1, zMin);
+      copyPoint(d2, zMax);
+    }
+  }
+  sphere[0] = (d1[0] + d2[0]) / 2;
+  sphere[1] = (d1[1] + d2[1]) / 2;
+  sphere[2] = (d1[2] + d2[2]) / 2;
+  let r2 = distance2BetweenPoints(d1, d2) / 4;
+  sphere[3] = Math.sqrt(r2);
+  const p = [0, 0, 0];
+  for (let i = 0; i < actualNumPts; i++) {
+    setPointFromArray(p, pts, i);
+    const dist2 = distance2BetweenPoints(p, sphere);
+    if (dist2 > r2) {
+      const dist = Math.sqrt(dist2);
+      sphere[3] = (sphere[3] + dist) / 2;
+      r2 = sphere[3] * sphere[3];
+      const delta = dist - sphere[3];
+      sphere[0] = (sphere[3] * sphere[0] + delta * p[0]) / dist;
+      sphere[1] = (sphere[3] * sphere[1] + delta * p[1]) / dist;
+      sphere[2] = (sphere[3] * sphere[2] + delta * p[2]) / dist;
+    }
+  }
+  return sphere;
+}
+function computeBoundingSphereFromSpheres(spheres, numSpheres, hints) {
+  const actualNumSpheres = numSpheres ?? spheres.length;
+  const sphere = [0, 0, 0, 0];
+  if (actualNumSpheres < 1) {
+    return sphere;
+  }
+  if (actualNumSpheres === 1) {
+    copySphere(sphere, spheres[0]);
+    return sphere;
+  }
+  const s1 = [0, 0, 0, 0];
+  const s2 = [0, 0, 0, 0];
+  if (hints && hints.length >= 2) {
+    copySphere(s1, spheres[hints[0]]);
+    copySphere(s2, spheres[hints[1]]);
+  } else {
+    const xMin = [Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE, 0];
+    const yMin = [Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE, 0];
+    const zMin = [Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE, 0];
+    const xMax = [-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE, 0];
+    const yMax = [-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE, 0];
+    const zMax = [-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE, 0];
+    for (let i = 0; i < actualNumSpheres; i++) {
+      const s = spheres[i];
+      if (s[0] - s[3] < xMin[0] - xMin[3]) copySphere(xMin, s);
+      if (s[0] + s[3] > xMax[0] + xMax[3]) copySphere(xMax, s);
+      if (s[1] - s[3] < yMin[1] - yMin[3]) copySphere(yMin, s);
+      if (s[1] + s[3] > yMax[1] + yMax[3]) copySphere(yMax, s);
+      if (s[2] - s[3] < zMin[2] - zMin[3]) copySphere(zMin, s);
+      if (s[2] + s[3] > zMax[2] + zMax[3]) copySphere(zMax, s);
+    }
+    const xSpan = (xMax[0] + xMax[3] - (xMin[0] - xMin[3])) * (xMax[0] + xMax[3] - (xMin[0] - xMin[3])) + (xMax[1] + xMax[3] - (xMin[1] - xMin[3])) * (xMax[1] + xMax[3] - (xMin[1] - xMin[3])) + (xMax[2] + xMax[3] - (xMin[2] - xMin[3])) * (xMax[2] + xMax[3] - (xMin[2] - xMin[3]));
+    const ySpan = (yMax[0] + yMax[3] - (yMin[0] - yMin[3])) * (yMax[0] + yMax[3] - (yMin[0] - yMin[3])) + (yMax[1] + yMax[3] - (yMin[1] - yMin[3])) * (yMax[1] + yMax[3] - (yMin[1] - yMin[3])) + (yMax[2] + yMax[3] - (yMin[2] - yMin[3])) * (yMax[2] + yMax[3] - (yMin[2] - yMin[3]));
+    const zSpan = (zMax[0] + zMax[3] - (zMin[0] - zMin[3])) * (zMax[0] + zMax[3] - (zMin[0] - zMin[3])) + (zMax[1] + zMax[3] - (zMin[1] - zMin[3])) * (zMax[1] + zMax[3] - (zMin[1] - zMin[3])) + (zMax[2] + zMax[3] - (zMin[2] - zMin[3])) * (zMax[2] + zMax[3] - (zMin[2] - zMin[3]));
+    if (xSpan > ySpan) {
+      if (xSpan > zSpan) {
+        copySphere(s1, xMin);
+        copySphere(s2, xMax);
+      } else {
+        copySphere(s1, zMin);
+        copySphere(s2, zMax);
+      }
+    } else if (ySpan > zSpan) {
+      copySphere(s1, yMin);
+      copySphere(s2, yMax);
+    } else {
+      copySphere(s1, zMin);
+      copySphere(s2, zMax);
+    }
+  }
+  let r2 = distance2BetweenPoints(s1, s2) / 4;
+  sphere[3] = r2 > 0 ? Math.sqrt(r2) : s1[3];
+  const t1 = -s1[3] / (2 * sphere[3]);
+  const t2 = 1 + s2[3] / (2 * sphere[3]);
+  const v = [0, 0, 0];
+  for (let i = 0; i < 3; i++) {
+    v[i] = s2[i] - s1[i];
+    const tmp = s1[i] + t1 * v[i];
+    s2[i] = s1[i] + t2 * v[i];
+    s1[i] = tmp;
+    sphere[i] = (s1[i] + s2[i]) / 2;
+  }
+  r2 = distance2BetweenPoints(s1, s2) / 4;
+  if (r2 > 0) {
+    sphere[3] = Math.sqrt(r2);
+  } else {
+    sphere[3] = s1[3];
+    r2 = sphere[3] * sphere[3];
+  }
+  for (let i = 0; i < actualNumSpheres; i++) {
+    const s = spheres[i];
+    const sR2 = s[3] * s[3];
+    let dist2 = distance2BetweenPoints(s, sphere);
+    if (dist2 <= 0) {
+      dist2 = s[3];
+    }
+    const fac = sR2 > dist2 ? 2 * sR2 : 2 * dist2;
+    if (dist2 + fac + sR2 > r2) {
+      const dist = Math.sqrt(dist2);
+      if ((dist + s[3]) * (dist + s[3]) > r2) {
+        for (let j = 0; j < 3; j++) {
+          v[j] = s[j] - sphere[j];
+          s1[j] = sphere[j] - sphere[3] / dist * v[j];
+          s2[j] = sphere[j] + (1 + s[3] / dist) * v[j];
+          sphere[j] = (s1[j] + s2[j]) / 2;
+        }
+        r2 = distance2BetweenPoints(s1, s2) / 4;
+        if (r2 > 0) {
+          sphere[3] = Math.sqrt(r2);
+        } else {
+          sphere[3] = Math.max(s1[3], sphere[3]);
+          r2 = sphere[3] * sphere[3];
+        }
+      }
+    }
+  }
+  return sphere;
+}
 
 // ----------------------------------------------------------------------------
 // Static API
 // ----------------------------------------------------------------------------
 
 const STATIC = {
-  evaluate
+  evaluate,
+  computeBoundingSphere,
+  computeBoundingSphereFromSpheres
 };
 
 // ----------------------------------------------------------------------------

package/IO/Geometry/STLReader.d.ts

@@ -13,7 +13,34 @@ interface ISTLReaderOptions {
 /**
  *
  */
-export interface ISTLReaderInitialValues {}
+export interface ISTLReaderInitialValues {
+  /**
+   * Data access helper used for loading remote resources.
+   */
+  dataAccessHelper?:
+    | HtmlDataAccessHelper
+    | HttpDataAccessHelper
+    | JSZipDataAccessHelper
+    | LiteHttpDataAccessHelper;
+
+  /**
+   * Point locator used for vertex merging.
+   */
+  locator?: any;
+
+  /**
+   * Enable/disable point merging.
+   * Default is true.
+   */
+  merging?: boolean;
+
+  /**
+   * Merge tolerance power.
+   * If >= 0, points within 10^-tolerance are merged.
+   * Default is -1 (disabled).
+   */
+  removeDuplicateVertices?: number;
+}
 
 type vtkSTLReaderBase = vtkObject &
   Omit<
@@ -41,6 +68,16 @@ export interface vtkSTLReader extends vtkSTLReaderBase {
     | JSZipDataAccessHelper
     | LiteHttpDataAccessHelper;
 
+  /**
+   * Get the point locator used for vertex merging.
+   */
+  getLocator(): any;
+
+  /**
+   * Get whether point merging is enabled.
+   */
+  getMerging(): boolean;
+
   /**
    * Get the url of the object to load.
    */
@@ -74,6 +111,7 @@ export interface vtkSTLReader extends vtkSTLReaderBase {
    * @param {String} content The content to parse.
    */
   parseAsText(content: string): void;
+
   /**
    *
    * @param inData
@@ -93,6 +131,16 @@ export interface vtkSTLReader extends vtkSTLReaderBase {
       | LiteHttpDataAccessHelper
   ): boolean;
 
+  /**
+   * Set a point locator used for vertex merging.
+   */
+  setLocator(locator: any): boolean;
+
+  /**
+   * Enable/disable point merging.
+   */
+  setMerging(merging: boolean): boolean;
+
   /**
    * Set the url of the object to load.
    * @param {String} url the url of the object to load.

package/IO/Geometry/STLReader.js

@@ -1,8 +1,10 @@
+import { m as macro } from '../../macros2.js';
 import BinaryHelper from '../Core/BinaryHelper.js';
 import DataAccessHelper from '../Core/DataAccessHelper.js';
-import { m as macro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
+import vtkPoints from '../../Common/Core/Points.js';
+import vtkMergePoints from '../../Common/DataModel/MergePoints.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import '../Core/DataAccessHelper/LiteHttpDataAccessHelper.js';
 
@@ -11,7 +13,8 @@ import '../Core/DataAccessHelper/LiteHttpDataAccessHelper.js';
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/JSZipDataAccessHelper'; // zip
 
 const {
-  vtkErrorMacro
+  vtkErrorMacro,
+  vtkWarningMacro
 } = macro;
 function parseHeader(headerString) {
   const headerSubStr = headerString.split(' ');
@@ -101,54 +104,83 @@ function vtkSTLReader(publicAPI, model) {
       progressCallback
     });
   }
-  function removeDuplicateVertices(tolerance) {
+  function removeDuplicateVertices(tolerancePower) {
     const polydata = model.output[0];
     const points = polydata.getPoints().getData();
     const faces = polydata.getPolys().getData();
     if (!points || !faces) {
-      console.warn('No valid polydata.');
+      vtkWarningMacro('No valid polydata.');
       return;
     }
-    const vMap = new Map();
-    const vIndexMap = new Map();
-    let vInc = 0;
-    let pointsChanged = false;
-    for (let i = 0; i < points.length; i += 3) {
-      const k1 = (points[i] * 10 ** tolerance).toFixed(0);
-      const k2 = (points[i + 1] * 10 ** tolerance).toFixed(0);
-      const k3 = (points[i + 2] * 10 ** tolerance).toFixed(0);
-      const key = `${k1},${k2},${k3}`;
-      if (vMap.get(key) !== undefined) {
-        vIndexMap.set(i / 3, vMap.get(key));
-        pointsChanged = true;
-      } else {
-        vIndexMap.set(i / 3, vInc);
-        vMap.set(key, vInc);
-        vInc++;
+    const inCellNormals = polydata.getCellData().getNormals();
+    const inCellScalars = polydata.getCellData().getScalars();
+    const mergedPoints = vtkPoints.newInstance({
+      dataType: points.constructor
+    });
+    mergedPoints.allocate(points.length / 6, 3);
+    let locator = model.locator;
+    if (!locator) {
+      locator = vtkMergePoints.newInstance();
+    }
+    if (tolerancePower >= 0) {
+      locator.setTolerance(10 ** -tolerancePower);
+    }
+    locator.initPointInsertion(mergedPoints, polydata.getBounds(), Math.floor(points.length / 3 / 2));
+    const mergedCells = [];
+    const keptCellIds = [];
+    for (let i = 0, cellId = 0; i < faces.length; i += 4, cellId++) {
+      if (faces[i] === 3) {
+        const nodeIds = [0, 0, 0];
+        for (let j = 0; j < 3; j++) {
+          const pid = faces[i + 1 + j];
+          const x = [points[pid * 3], points[pid * 3 + 1], points[pid * 3 + 2]];
+          nodeIds[j] = locator.insertUniquePoint(x).id;
+        }
+        if (nodeIds[0] !== nodeIds[1] && nodeIds[0] !== nodeIds[2] && nodeIds[1] !== nodeIds[2]) {
+          mergedCells.push(3, nodeIds[0], nodeIds[1], nodeIds[2]);
+          keptCellIds.push(cellId);
+        }
       }
     }
-    if (pointsChanged) {
-      const outVerts = new Float32Array(vMap.size * 3);
-      const keys = Array.from(vMap.keys());
-      for (let i = 0; i < keys.length; i++) {
-        const k = keys[i];
-        const j = vMap.get(k) * 3;
-        const coords = k.split(',').map(e => +e * 10 ** -tolerance);
-        outVerts[j] = coords[0];
-        outVerts[j + 1] = coords[1];
-        outVerts[j + 2] = coords[2];
+    const outCellArray = new faces.constructor(mergedCells);
+    polydata.getPoints().setData(mergedPoints.getData(), 3);
+    polydata.getPolys().setData(outCellArray);
+    if (inCellNormals && inCellNormals.getData()) {
+      const inData = inCellNormals.getData();
+      const numComp = inCellNormals.getNumberOfComponents();
+      const outData = new inData.constructor(keptCellIds.length * numComp);
+      for (let i = 0; i < keptCellIds.length; i++) {
+        const srcOffset = keptCellIds[i] * numComp;
+        const dstOffset = i * numComp;
+        for (let c = 0; c < numComp; c++) {
+          outData[dstOffset + c] = inData[srcOffset + c];
+        }
       }
-      const outFaces = new Int32Array(faces.length);
-      for (let i = 0; i < faces.length; i += 4) {
-        outFaces[i] = 3;
-        outFaces[i + 1] = vIndexMap.get(faces[i + 1]);
-        outFaces[i + 2] = vIndexMap.get(faces[i + 2]);
-        outFaces[i + 3] = vIndexMap.get(faces[i + 3]);
+      polydata.getCellData().setNormals(vtkDataArray.newInstance({
+        name: inCellNormals.getName() || 'Normals',
+        values: outData,
+        numberOfComponents: numComp
+      }));
+    }
+    if (inCellScalars && inCellScalars.getData()) {
+      const inData = inCellScalars.getData();
+      const numComp = inCellScalars.getNumberOfComponents();
+      const outData = new inData.constructor(keptCellIds.length * numComp);
+      for (let i = 0; i < keptCellIds.length; i++) {
+        const srcOffset = keptCellIds[i] * numComp;
+        const dstOffset = i * numComp;
+        for (let c = 0; c < numComp; c++) {
+          outData[dstOffset + c] = inData[srcOffset + c];
+        }
       }
-      polydata.getPoints().setData(outVerts);
-      polydata.getPolys().setData(outFaces);
-      polydata.modified();
+      polydata.getCellData().setScalars(vtkDataArray.newInstance({
+        name: inCellScalars.getName() || 'Attribute',
+        values: outData,
+        numberOfComponents: numComp
+      }));
     }
+    locator.initialize();
+    polydata.modified();
   }
 
   // Set DataSet url
@@ -296,7 +328,7 @@ function vtkSTLReader(publicAPI, model) {
 
     // Add new output
     model.output[0] = polydata;
-    if (model.removeDuplicateVertices >= 0) {
+    if (model.merging && model.removeDuplicateVertices >= 0) {
       removeDuplicateVertices(model.removeDuplicateVertices);
     }
   };
@@ -329,7 +361,7 @@ function vtkSTLReader(publicAPI, model) {
 
     // Add new output
     model.output[0] = polydata;
-    if (model.removeDuplicateVertices >= 0) {
+    if (model.merging && model.removeDuplicateVertices >= 0) {
       removeDuplicateVertices(model.removeDuplicateVertices);
     }
   };
@@ -345,7 +377,9 @@ function vtkSTLReader(publicAPI, model) {
 const DEFAULT_VALUES = {
   // baseURL: null,
   // dataAccessHelper: null,
+  // locator: null,
   // url: null,
+  merging: true,
   removeDuplicateVertices: -1
 };
 
@@ -357,7 +391,7 @@ function extend(publicAPI, model, initialValues = {}) {
   // Build VTK API
   macro.obj(publicAPI, model);
   macro.get(publicAPI, model, ['url', 'baseURL']);
-  macro.setGet(publicAPI, model, ['dataAccessHelper', 'removeDuplicateVertices']);
+  macro.setGet(publicAPI, model, ['dataAccessHelper', 'locator', 'merging', 'removeDuplicateVertices']);
   macro.algo(publicAPI, model, 0, 1);
 
   // vtkSTLReader methods

package/package.json

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