@kitware/vtk.js 34.10.0 → 34.11.0

package/Common/Core/Points.d.ts

@@ -81,6 +81,14 @@ export interface vtkPoints extends vtkDataArray {
    * @returns {Number} Index of the inserted point.
    */
   insertNextPoint(x: number, y: number, z: number): number;
+
+  /**
+   * Insert the [x,y,z] coordinates of a point at the given index.
+   * @param {Number} ptId The index of point.
+   * @param {Number[]} point The [x, y, z] coordinates of the point.
+   * @returns {Number} The index of the inserted point.
+   */
+  insertPoint(ptId: number, point: number[]): number;
 }
 
 /**

package/Common/Core/Points.js

@@ -35,6 +35,7 @@ function vtkPoints(publicAPI, model) {
   publicAPI.getPoint = publicAPI.getTuple;
   publicAPI.findPoint = publicAPI.findTuple;
   publicAPI.insertNextPoint = (x, y, z) => publicAPI.insertNextTuple([x, y, z]);
+  publicAPI.insertPoint = (ptId, point) => publicAPI.insertTuple(ptId, point);
   publicAPI.getBounds = () => {
     if (publicAPI.getNumberOfComponents() === 3) {
       const xRange = publicAPI.getRange(0);
@@ -49,8 +50,7 @@ function vtkPoints(publicAPI, model) {
       return model.bounds;
     }
     if (publicAPI.getNumberOfComponents() !== 2) {
-      vtkErrorMacro(`getBounds called on an array with components of
-        ${publicAPI.getNumberOfComponents()}`);
+      vtkErrorMacro(`getBounds called on an array with components of ${publicAPI.getNumberOfComponents()}`);
       return INVALID_BOUNDS;
     }
     const xRange = publicAPI.getRange(0);

package/Common/DataModel/AbstractPointLocator.d.ts

@@ -1,6 +1,6 @@
 import { vtkObject } from './../../interfaces';
 import { Bounds } from './../../types';
-import { ILocatorInitialValues } from './Locator';
+import vtkLocator, { ILocatorInitialValues } from './Locator';
 
 /**
  *
@@ -11,7 +11,7 @@ export interface IAbstractPointLocatorInitialValues
   numberOfBuckets: number;
 }
 
-export interface vtkAbstractPointLocator extends vtkObject {
+export interface vtkAbstractPointLocator extends vtkLocator {
   /**
    * Set the bounds of this object.
    * @param {Bounds} input

package/Common/DataModel/BoundingBox.d.ts

@@ -325,6 +325,37 @@ export function cutWithPlane(
   normal: Vector3
 ): boolean;
 
+/**
+ * Clamp the divisions to ensure the total number doesn't exceed targetBins
+ * @param {Number} targetBins - Maximum number of bins allowed
+ * @param {Number[]} divs - Divisions array to adjust [divX, divY, divZ]
+ */
+export function clampDivisions(targetBins: number, divs: number[]): void;
+
+/**
+ * Compute the number of divisions given the current bounding box and a
+ * target number of buckets/bins. Handles degenerate bounding boxes properly.
+ * @param {Bounds} bounds - The bounding box
+ * @param {Number} totalBins - Target number of bins
+ * @param {Number[]} divs - Output array to store divisions [divX, divY, divZ]
+ * @param {Bounds} [adjustedBounds] - Output array to store adjusted bounds if needed
+ * @returns {Number} The actual total number of bins
+ */
+export function computeDivisions(
+  bounds: Bounds,
+  totalBins: number,
+  divs: number[],
+  adjustedBounds?: Bounds
+): number;
+
+/**
+ * Calculate the squared distance from point x to the specified bounds.
+ * @param {Vector3} x  The point coordinates
+ * @param {Bounds} bounds  The bounding box coordinates
+ * @returns {Number} The squared distance to the bounds
+ */
+export function distance2ToBounds(x: Vector3, bounds: Bounds): number;
+
 declare class BoundingBox {
   getBounds(): Bounds;
   /**
@@ -409,10 +440,9 @@ declare class BoundingBox {
 
   /**
    * Inflates a bounding box.
-   * @param {Bounds} bounds
-   * @param {number} delta
+   * @param {number} [delta] The amount to inflate the bounding box by.
    */
-  inflate(bounds: Bounds, delta: number): Bounds;
+  inflate(delta?: number): Bounds;
 
   /**
    * Scales a bounding box.
@@ -611,6 +641,14 @@ declare class BoundingBox {
    * @param {Vector3} normal
    */
   cutWithPlane(bounds: Bounds, origin: Vector3, normal: Vector3): boolean;
+
+  /**
+   * Calculate the squared distance from point x to the specified bounds.
+   * @param {Vector3} x  The point coordinates
+   * @param {Bounds} bounds  The bounding box coordinates
+   * @returns {Number} The squared distance to the bounds
+   */
+  distance2ToBounds(x: Vector3, bounds: Bounds): number;
 }
 
 export interface IBoundingBoxInitialValues {
@@ -653,6 +691,7 @@ declare const vtkBoundingBox: {
   intersects: typeof intersects;
   containsPoint: typeof containsPoint;
   contains: typeof contains;
+  distance2ToBounds: typeof distance2ToBounds;
   INIT_BOUNDS: Bounds;
 };
 

package/Common/DataModel/BoundingBox.js

@@ -96,6 +96,10 @@ function setMaxPoint(bounds, x, y, z) {
   return xMax !== x || yMax !== y || zMax !== z;
 }
 function inflate(bounds, delta) {
+  if (delta == null) {
+    // eslint-disable-next-line no-use-before-define
+    return minInflate(bounds);
+  }
   bounds[0] -= delta;
   bounds[1] += delta;
   bounds[2] -= delta;
@@ -104,6 +108,33 @@ function inflate(bounds, delta) {
   bounds[5] += delta;
   return bounds;
 }
+function minInflate(bounds) {
+  const nonZero = [0, 0, 0];
+  let maxIdx = -1;
+  let max = 0.0;
+  let w = 0.0;
+  for (let i = 0; i < 3; ++i) {
+    w = bounds[i * 2 + 1] - bounds[i * 2];
+    if (w > max) {
+      max = w;
+      maxIdx = i;
+    }
+    nonZero[i] = w > 0.0 ? 1 : 0;
+  }
+  if (maxIdx < 0) {
+    return inflate(bounds, 0.5);
+  }
+
+  // Any zero width sides are bumped out 1% of max side
+  for (let i = 0; i < 3; ++i) {
+    if (!nonZero[i]) {
+      const d = 0.005 * max;
+      bounds[i * 2] -= d;
+      bounds[i * 2 + 1] += d;
+    }
+  }
+  return bounds;
+}
 function scale(bounds, sx, sy, sz) {
   if (!isValid(bounds)) {
     return false;
@@ -513,6 +544,145 @@ function cutWithPlane(bounds, origin, normal) {
   return true;
 }
 
+/**
+ * Clamp the divisions to ensure the total number doesn't exceed targetBins
+ * @param {Number} targetBins - Maximum number of bins allowed
+ * @param {Array} divs - Divisions array to adjust [divX, divY, divZ]
+ */
+function clampDivisions(targetBins, divs) {
+  for (let i = 0; i < 3; ++i) {
+    divs[i] = divs[i] < 1 ? 1 : divs[i];
+  }
+  let numBins = divs[0] * divs[1] * divs[2];
+  while (numBins > targetBins) {
+    for (let i = 0; i < 3; ++i) {
+      divs[i] = divs[i] > 1 ? divs[i] - 1 : 1;
+    }
+    numBins = divs[0] * divs[1] * divs[2];
+  }
+}
+
+/**
+ * Compute the number of divisions given the current bounding box and a
+ * target number of buckets/bins. Handles degenerate bounding boxes properly.
+ * @param {Bounds} bounds - The bounding box
+ * @param {Number} totalBins - Target number of bins
+ * @param {Array} divs - Output array to store divisions [divX, divY, divZ]
+ * @param {Array} [adjustedBounds] - Output array to store adjusted bounds if needed
+ * @returns {Number} The actual total number of bins
+ */
+function computeDivisions(bounds, totalBins, divs) {
+  let adjustedBounds = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+  // This will always produce at least one bin
+  // eslint-disable-next-line no-param-reassign
+  totalBins = totalBins <= 0 ? 1 : totalBins;
+
+  // First determine the maximum length of the side of the bounds. Keep track
+  // of zero width sides of the bounding box.
+  let numNonZero = 0;
+  const nonZero = [0, 0, 0];
+  let maxIdx = -1;
+  let max = 0.0;
+  const lengths = getLengths(bounds);
+
+  // Use a finite tolerance when detecting zero width sides
+  const totLen = lengths[0] + lengths[1] + lengths[2];
+  const zeroDetectionTolerance = totLen * (0.001 / 3.0);
+  for (let i = 0; i < 3; ++i) {
+    if (lengths[i] > max) {
+      maxIdx = i;
+      max = lengths[i];
+    }
+    if (lengths[i] > zeroDetectionTolerance) {
+      nonZero[i] = 1;
+      numNonZero++;
+    } else {
+      nonZero[i] = 0;
+    }
+  }
+
+  // Get min and max points
+  const minPoint = getMinPoint(bounds);
+  const maxPoint = getMaxPoint(bounds);
+
+  // If the bounding box is degenerate, then one bin of arbitrary size
+  if (numNonZero < 1) {
+    divs[0] = 1;
+    divs[1] = 1;
+    divs[2] = 1;
+    adjustedBounds[0] = minPoint[0] - 0.5;
+    adjustedBounds[1] = maxPoint[0] + 0.5;
+    adjustedBounds[2] = minPoint[1] - 0.5;
+    adjustedBounds[3] = maxPoint[1] + 0.5;
+    adjustedBounds[4] = minPoint[2] - 0.5;
+    adjustedBounds[5] = maxPoint[2] + 0.5;
+    return 1;
+  }
+
+  // Compute the divisions roughly in proportion to the bounding box edge lengths
+  let f = totalBins;
+  f /= nonZero[0] ? lengths[0] / totLen : 1.0;
+  f /= nonZero[1] ? lengths[1] / totLen : 1.0;
+  f /= nonZero[2] ? lengths[2] / totLen : 1.0;
+  f **= 1.0 / numNonZero;
+  for (let i = 0; i < 3; ++i) {
+    divs[i] = nonZero[i] ? Math.floor(f * lengths[i] / totLen) : 1;
+    divs[i] = divs[i] < 1 ? 1 : divs[i];
+  }
+
+  // Make sure that we do not exceed the totalBins
+  clampDivisions(totalBins, divs);
+
+  // Now compute the final bounds, making sure it is a non-zero volume
+  const delta = 0.5 * lengths[maxIdx] / divs[maxIdx];
+  for (let i = 0; i < 3; ++i) {
+    if (nonZero[i]) {
+      adjustedBounds[2 * i] = minPoint[i];
+      adjustedBounds[2 * i + 1] = maxPoint[i];
+    } else {
+      adjustedBounds[2 * i] = minPoint[i] - delta;
+      adjustedBounds[2 * i + 1] = maxPoint[i] + delta;
+    }
+  }
+  return divs[0] * divs[1] * divs[2];
+}
+
+/**
+ * Calculate the squared distance from point x to the specified bounds.
+ * @param {Vector3} x  The point coordinates
+ * @param {Bounds} bounds  The bounding box coordinates
+ * @returns {Number} The squared distance to the bounds
+ */
+function distance2ToBounds(x, bounds) {
+  // Are we within the bounds?
+  if (x[0] >= bounds[0] && x[0] <= bounds[1] && x[1] >= bounds[2] && x[1] <= bounds[3] && x[2] >= bounds[4] && x[2] <= bounds[5]) {
+    return 0.0;
+  }
+  const deltas = [0.0, 0.0, 0.0];
+
+  // dx
+  if (x[0] < bounds[0]) {
+    deltas[0] = bounds[0] - x[0];
+  } else if (x[0] > bounds[1]) {
+    deltas[0] = x[0] - bounds[1];
+  }
+
+  // dy
+  if (x[1] < bounds[2]) {
+    deltas[1] = bounds[2] - x[1];
+  } else if (x[1] > bounds[3]) {
+    deltas[1] = x[1] - bounds[3];
+  }
+
+  // dz
+  if (x[2] < bounds[4]) {
+    deltas[2] = bounds[4] - x[2];
+  } else if (x[2] > bounds[5]) {
+    deltas[2] = x[2] - bounds[5];
+  }
+  return dot(deltas, deltas);
+}
+
 // ----------------------------------------------------------------------------
 // Light Weight class
 // ----------------------------------------------------------------------------
@@ -630,6 +800,13 @@ class BoundingBox {
   contains(otherBounds) {
     return intersects(this.bounds, otherBounds);
   }
+  computeDivisions(totalBins, divs) {
+    let adjustedBounds = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+    return computeDivisions(this.bounds, totalBins, divs, adjustedBounds);
+  }
+  distance2ToBounds(x) {
+    return distance2ToBounds(x, this.bounds);
+  }
 }
 function newInstance(initialValues) {
   const bounds = initialValues && initialValues.bounds;
@@ -675,6 +852,9 @@ const STATIC = {
   intersects,
   containsPoint,
   contains,
+  computeDivisions,
+  clampDivisions,
+  distance2ToBounds,
   INIT_BOUNDS
 };
 var vtkBoundingBox = {
@@ -682,4 +862,4 @@ var vtkBoundingBox = {
   ...STATIC
 };
 
-export { STATIC, addBounds, addPoint, addPoints, computeCornerPoints, computeLocalBounds, computeScale3, contains, containsPoint, cutWithPlane, vtkBoundingBox as default, equals, getCenter, getCorners, getDiagonalLength, getLength, getLengths, getMaxLength, getMaxPoint, getMinPoint, getXRange, getYRange, getZRange, inflate, intersect, intersectBox, intersectPlane, intersects, isValid, reset, scale, scaleAboutCenter, setBounds, setMaxPoint, setMinPoint, transformBounds };
+export { STATIC, addBounds, addPoint, addPoints, clampDivisions, computeCornerPoints, computeDivisions, computeLocalBounds, computeScale3, contains, containsPoint, cutWithPlane, vtkBoundingBox as default, distance2ToBounds, equals, getCenter, getCorners, getDiagonalLength, getLength, getLengths, getMaxLength, getMaxPoint, getMinPoint, getXRange, getYRange, getZRange, intersect, intersectBox, intersectPlane, intersects, isValid, reset, scale, scaleAboutCenter, setBounds, setMaxPoint, setMinPoint, transformBounds };

package/Common/DataModel/Locator.d.ts

@@ -1,10 +1,11 @@
 import { vtkObject } from './../../interfaces';
+import vtkDataSet from './DataSet';
 
 /**
  *
  */
 export interface ILocatorInitialValues {
-  dataSet?: number[];
+  dataSet?: vtkDataSet;
   maxLevel?: number;
   level?: number;
   automatic?: boolean;
@@ -12,7 +13,97 @@ export interface ILocatorInitialValues {
   useExistingSearchStructure?: boolean;
 }
 
-export interface vtkLocator extends vtkObject {}
+export interface vtkLocator extends vtkObject {
+  /**
+   * Get whether locator depth/resolution of locator is computed automatically
+   * from average number of entities in bucket.
+   */
+  getAutomatic(): boolean;
+
+  /**
+   * Get the dataset associated with this locator.
+   *
+   * @returns {vtkDataSet} The dataset associated with this locator.
+   */
+  getDataSet(): vtkDataSet;
+
+  /**
+   * Get the current level of the locator.
+   *
+   * @returns {Number} The current level of the locator.
+   */
+  getLevel(): number;
+
+  /**
+   * Get the maximum level of the locator.
+   *
+   * @returns {Number} The maximum level of the locator.
+   */
+  getMaxLevel(): number;
+
+  /**
+   * Get the tolerance used for the locator.
+   *
+   * @returns {Number} The tolerance value.
+   */
+  getTolerance(): number;
+
+  /**
+   * Get whether to use an existing search structure.
+   *
+   * @returns {Boolean} Whether an existing search structure is used.
+   */
+  getUseExistingSearchStructure(): boolean;
+
+  /**
+   * Set whether locator depth/resolution of locator is computed automatically
+   * from average number of entities in bucket.
+   *
+   * @param {Boolean} automatic - The automatic flag.
+   * @returns {Boolean} Whether the operation was successful.
+   */
+  setAutomatic(automatic: boolean): boolean;
+
+  /**
+   * Set the dataset associated with this locator.
+   *
+   * @param {vtkDataSet} dataSet - The dataset to associate with this locator.
+   * @returns {Boolean} Whether the operation was successful.
+   */
+  setDataSet(dataSet: vtkDataSet): boolean;
+
+  /**
+   * Set the current level of the locator.
+   *
+   * @param {Number} level - The level to set.
+   * @returns {Boolean} Whether the operation was successful.
+   */
+  setLevel(level: number): boolean;
+
+  /**
+   * Set the maximum level of the locator.
+   *
+   * @param {Number} maxLevel - The maximum level to set.
+   * @returns {Boolean} Whether the operation was successful.
+   */
+  setMaxLevel(maxLevel: number): boolean;
+
+  /**
+   * Set the tolerance used for the locator.
+   *
+   * @param {Number} tolerance - The tolerance value to set.
+   * @returns {Boolean} Whether the operation was successful.
+   */
+  setTolerance(tolerance: number): boolean;
+
+  /**
+   * Set whether to use an existing search structure.
+   *
+   * @param {Boolean} useExistingSearchStructure - Whether to use an existing search structure.
+   * @returns {Boolean} Whether the operation was successful.
+   */
+  setUseExistingSearchStructure(useExistingSearchStructure: boolean): boolean;
+}
 
 // ----------------------------------------------------------------------------
 // Static API
@@ -31,10 +122,11 @@ export function extend(
   initialValues?: ILocatorInitialValues
 ): void;
 
-// ----------------------------------------------------------------------------
-
 /**
- * vtkLocator
+ * vtkLocator is an abstract base class for spatial search objects, or locators.
+ * The principle behind locators is that they divide 3-space into small regions
+ * (or "buckets") that can be quickly found in response to queries about point
+ * location, line intersection, or object-object intersection.
  */
 export declare const vtkLocator: {
   extend: typeof extend;

package/Common/DataModel/MergePoints.d.ts

@@ -0,0 +1,64 @@
+import { Vector3 } from './../../types';
+import vtkPointLocator, {
+  IInsertPointResult,
+  IPointLocatorInitialValues,
+} from './PointLocator';
+
+/**
+ * Initial values for vtkMergePoints.
+ */
+export interface IMergePointsInitialValues extends IPointLocatorInitialValues {
+  bucketSize?: number;
+}
+
+export interface vtkMergePoints extends vtkPointLocator {
+  /**
+   * Check if a point is already inserted in the merge points structure.
+   *
+   * @param {Vector3} x The point to check.
+   * @returns {Number} The ID of the point if it exists, otherwise -1.
+   */
+  isInsertedPoint(x: Vector3): number;
+
+  /**
+   * Insert a point into the merge points structure.
+   * If the point is already present, it returns the existing ID.
+   * Otherwise, it inserts the point and returns a new ID.
+   *
+   * @param {Vector3} x The point to insert as an array of 3 numbers.
+   * @returns {IInsertPointResult} An object indicating if the point was inserted and its ID.
+   */
+  insertUniquePoint(x: Vector3): IInsertPointResult;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkMergePoints characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IMergePointsInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IMergePointsInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkMergePoints.
+ * @param {IMergePointsInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: IMergePointsInitialValues
+): vtkMergePoints;
+
+/**
+ * vtkMergePoints merge exactly coincident points.
+ *
+ * vtkMergePoints is a locator object to quickly locate points in 3D.
+ */
+export declare const vtkMergePoints: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkMergePoints;

package/Common/DataModel/MergePoints.js

@@ -0,0 +1,130 @@
+import { m as macro } from '../../macros2.js';
+import vtkPointLocator from './PointLocator.js';
+
+const {
+  vtkErrorMacro
+} = macro;
+
+/**
+ * Search for a point in the array using indices from bucketIds
+ * @param {Number[]} bucketIds - The list of point IDs in the bucket.
+ * @param {vtkPoints} points - The vtkPoints object containing the points.
+ * @param {Vector3} x - The point to check.
+ * @returns {Number} - The ID of the point if it exists, otherwise -1.
+ */
+function findPointInBucket(bucketIds, points, x) {
+  const data = points.getData();
+  for (let i = 0; i < bucketIds.length; ++i) {
+    const ptId = bucketIds[i];
+    const idx = ptId * 3;
+    if (x[0] === data[idx] && x[1] === data[idx + 1] && x[2] === data[idx + 2]) {
+      return ptId;
+    }
+  }
+  return -1;
+}
+
+// ----------------------------------------------------------------------------
+// vtkMergePoints methods
+// ----------------------------------------------------------------------------
+
+function vtkMergePoints(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkMergePoints');
+
+  /**
+   * Check if a point is already inserted in the merge points structure.
+   *
+   * @param {Vector3} x The point to check.
+   * @returns {Number} The ID of the point if it exists, otherwise -1.
+   */
+  publicAPI.isInsertedPoint = x => {
+    const idx = publicAPI.getBucketIndex(x);
+    const bucketIds = model.hashTable.get(idx);
+    if (bucketIds) {
+      return findPointInBucket(bucketIds, model.points, x);
+    }
+    return -1;
+  };
+
+  /**
+   * Insert a point into the merge points structure.
+   * If the point is already present, it returns the existing ID.
+   * Otherwise, it inserts the point and returns a new ID.
+   *
+   * @param {Vector3} x The point to insert as an array of 3 numbers.
+   * @returns {IInsertPointResult} An object indicating if the point was inserted and its ID.
+   */
+  publicAPI.insertUniquePoint = x => {
+    if (!x || x.length !== 3) {
+      vtkErrorMacro('Point must be a Vector3.');
+      return {
+        inserted: false,
+        id: -1
+      };
+    }
+    const idx = publicAPI.getBucketIndex(x);
+    let bucketIds = model.hashTable.get(idx);
+    let id = null;
+    if (bucketIds !== undefined) {
+      const ptId = findPointInBucket(bucketIds, model.points, x);
+      if (ptId !== -1) {
+        id = ptId;
+        return {
+          inserted: false,
+          id
+        };
+      }
+    } else {
+      bucketIds = [];
+      model.hashTable.set(idx, bucketIds);
+    }
+
+    // Insert new point
+    bucketIds.push(model.insertionPointId);
+    model.points.insertNextPoint(...x);
+    id = model.insertionPointId++;
+    return {
+      inserted: true,
+      id
+    };
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+function defaultValues(initialValues) {
+  return {
+    // points: null,
+    // hashTable: null,
+    ...initialValues
+  };
+}
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  vtkPointLocator.extend(publicAPI, model, defaultValues(initialValues));
+
+  // Make this a VTK object
+  macro.obj(publicAPI, model);
+
+  // Object specific methods
+  vtkMergePoints(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkMergePoints');
+
+// ----------------------------------------------------------------------------
+
+var index = {
+  newInstance,
+  extend
+};
+
+export { index as default, extend, newInstance };