@kitware/vtk.js 34.10.0 → 34.11.1

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 };

package/Common/DataModel/PointLocator.d.ts

@@ -0,0 +1,217 @@
+import { Bounds, Nullable, Vector3 } from './../../types';
+import vtkPoints from './../Core/Points';
+import vtkAbstractPointLocator, {
+  IAbstractPointLocatorInitialValues,
+} from './AbstractPointLocator';
+import vtkPolyData from './PolyData';
+
+/**
+ *
+ */
+export interface IPointLocatorInitialValues
+  extends IAbstractPointLocatorInitialValues {
+  numberOfPointsPerBucket?: number;
+  bucketSize?: number;
+}
+
+export interface IInsertPointResult {
+  inserted: boolean;
+  id: number;
+}
+
+interface IFindClosestPointResult {
+  id: number;
+  dist2: number;
+}
+
+export interface vtkPointLocator extends vtkAbstractPointLocator {
+  /**
+   * Find the closest inserted point to the given coordinates.
+   *
+   * @param {Vector3} x The query point
+   * @returns {Number} The id of the closest inserted point or -1 if not found
+   */
+  findClosestInsertedPoint(x: Vector3): number;
+
+  /**
+   * Find the closest point to a given point.
+   *
+   * @param {Vector3} x The point coordinates
+   * @returns The id of the closest point or -1 if not found
+   */
+  findClosestPoint(x: Vector3): number;
+
+  /**
+   * Find the closest point within a specified radius.
+   *
+   * @param {Number} radius The search radius
+   * @param {Vector3} x The point coordinates
+   * @param {Number} inputDataLength The length of the input data
+   * @returns {IFindClosestPointResult} The closest point result
+   */
+  findClosestPointWithinRadius(
+    radius: number,
+    x: Vector3,
+    inputDataLength?: number
+  ): IFindClosestPointResult;
+
+  /**
+   * Free the search structure and reset the locator.
+   */
+  freeSearchStructure(): void;
+
+  /**
+   * Generate a polydata representation of the point locator.
+   *
+   * @param {vtkPolyData} polydata The polydata to generate representation for
+   * @returns
+   */
+  generateRepresentation(polydata: vtkPolyData): boolean;
+
+  /**
+   * Get the number of points per bucket.
+   *
+   * @returns {Number} The number of points per bucket.
+   */
+  getNumberOfPointsPerBucket(): number;
+
+  /**
+   * Get the points in the specified bucket.
+   * @param {Vector3} x The point coordinates
+   * @returns {Number[]} The points in the bucket
+   */
+  getPointsInBucket(x: Vector3): number[];
+
+  /**
+   * Get the points stored in the point locator.
+   *
+   * @returns {Nullable<vtkPoints>} The vtkPoints object containing the points.
+   */
+  getPoints(): Nullable<vtkPoints>;
+
+  /**
+   * Initialize point insertion.
+   *
+   * @param {vtkPoints} points The points to insert
+   * @param {Bounds} bounds The bounds for the points
+   * @param {Number} estNumPts Estimated number of points for insertion
+   */
+  initPointInsertion(
+    points: vtkPoints,
+    bounds: Bounds,
+    estNumPts?: number
+  ): boolean;
+
+  /**
+   * Insert a point into the point locator.
+   * If the point is already present, it returns the existing ID.
+   * Otherwise, it inserts the point and returns a new ID.
+   *
+   * @param {Number} ptId The index of the point to insert.
+   * @param {Vector3} x The point to insert.
+   * @returns {IInsertPointResult} An object indicating if the point was inserted and its ID.
+   */
+  insertPoint(ptId: number, x: Vector3): IInsertPointResult;
+
+  /**
+   * Insert a point into the point locator.
+   * 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.
+   * @returns {IInsertPointResult} An object indicating if the point was inserted and its ID.
+   */
+  insertNextPoint(x: Vector3): IInsertPointResult;
+
+  /**
+   * Insert a point into the point locator.
+   * 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.
+   * @returns {IInsertPointResult} An object indicating if the point was inserted and its ID.
+   */
+  insertUniquePoint(x: Vector3): IInsertPointResult;
+
+  /**
+   * Check if a point is already inserted in the point locator.
+   *
+   * @param {Vector3} x The point to check.
+   * @returns {Number} The ID of the point if it exists, otherwise -1.
+   */
+  isInsertedPoint(x: Vector3): number;
+
+  /**
+   * Set the divisions of the point locator.
+   * @param {Vector3} divisions The number of divisions in each dimension.
+   * @returns {Boolean} True if the divisions were set successfully, false otherwise.
+   */
+  setDivisions(divisions: Vector3): boolean;
+
+  /**
+   * Set the divisions of the point locator.
+   * @param {Number} x The number of divisions in the x dimension.
+   * @param {Number} y The number of divisions in the y dimension.
+   * @param {Number} z The number of divisions in the z dimension.
+   * @returns {Boolean} True if the divisions were set successfully, false otherwise.
+   */
+  setDivisions(x: number, y: number, z: number): boolean;
+
+  /**
+   * Set the number of points per bucket.
+   *
+   * @param {Number} numberOfPointsPerBucket The number of points per bucket.
+   */
+  setNumberOfPointsPerBucket(numberOfPointsPerBucket: number): boolean;
+
+  /**
+   * Set the points for this point locator.
+   * This is typically used to initialize the locator with a set of points.
+   *
+   * @param {vtkPoints} points The vtkPoints object containing the points.
+   */
+  setPoints(points: vtkPoints): boolean;
+}
+
+/**
+ * Method use to decorate a given object (publicAPI+model) with vtkPointLocator characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {object} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IPointLocatorInitialValues
+): void;
+
+// ----------------------------------------------------------------------------
+
+/**
+ * Method use to create a new instance of vtkPointLocator
+ * @param {IPointLocatorInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: IPointLocatorInitialValues
+): vtkPointLocator;
+
+/**
+ * vtkPointLocator is a spatial search object to quickly locate points in 3D.
+ *
+ * vtkPointLocator works by dividing a specified region of space into a regular
+ * array of "rectangular" buckets, and then keeping a list of points that lie in
+ * each bucket. Typical operation involves giving a position in 3D and finding
+ * the closest point.
+ *
+ * vtkPointLocator has two distinct methods of interaction. In the first method,
+ * you supply it with a dataset, and it operates on the points in the dataset.
+ * In the second method, you supply it with an array of points, and the object
+ * operates on the array.
+ */
+export declare const vtkPointLocator: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+
+export default vtkPointLocator;