@kitware/vtk.js 34.9.1 → 34.11.0

package/Common/DataModel/Planes.d.ts

@@ -0,0 +1,120 @@
+import { Bounds, Vector3 } from './../../types';
+import vtkDataArray from './../Core/DataArray';
+import vtkImplicitFunction, {
+  IImplicitFunctionInitialValues,
+} from './ImplicitFunction';
+import vtkPlane from './Plane';
+import vtkPoints from './../Core/Points';
+
+/**
+ *
+ */
+export interface IPlanesInitialValues extends IImplicitFunctionInitialValues {
+  points?: vtkPoints;
+  normals?: vtkDataArray;
+  bounds?: Bounds;
+  planes?: number[];
+}
+
+export interface vtkPlanes extends vtkImplicitFunction {
+  /**
+   * Evaluate the function at a point x
+   * @param x The point at which to evaluate the function
+   * @returns The function value at the point x
+   */
+  evaluateFunction(x: Vector3): number;
+
+  /**
+   * Evaluate the gradient at a point x
+   * @param x The point at which to evaluate the gradient
+   * @returns The gradient at the point x
+   */
+  evaluateGradient(x: Vector3): Vector3;
+
+  /**
+   * Get the bounds of the planes.
+   * @returns {Bounds} The bounds of the planes.
+   */
+  getBounds(): Bounds;
+
+  /**
+   * Get the number of planes in the set of planes.
+   */
+  getNumberOfPlanes(): number;
+
+  /**
+   * Get the normals of the plane.
+   * @returns {vtkDataArray} The normals of the plane.
+   */
+  getNormals(): vtkDataArray;
+
+  /**
+   * Get the points of the plane.
+   * @returns {vtkPoints} The points of the plane.
+   */
+  getPoints(): vtkPoints;
+
+  /**
+   * Get the i-th plane
+   * @param {Number} i The index of the plane to get.
+   * @param {vtkPlane} [plane] The vtkPlane instance to fill (optional).
+   * @returns {vtkPlane} The plane instance at the specified index.
+   * If no plane is provided, a new vtkPlane instance will be created.
+   */
+  getPlane(i: number, plane?: vtkPlane): vtkPlane;
+
+  /**
+   * Set the bounds of the planes.
+   * @param {Bounds} bounds The bounds to set.
+   * @returns {Boolean} true if bounds were set, false if they were already set
+   * @see getBounds
+   */
+  setBounds(bounds: Bounds): boolean;
+
+  /**
+   * Set the Frustum planes.
+   * @param {Vector3[]} planes The coordinates of the frustum planes.
+   */
+  setFrustumPlanes(planes: Vector3[]): boolean;
+
+  /**
+   * Set the normals of the plane.
+   * @param {vtkDataArray} normals The normals to set.
+   */
+  setNormals(normals: vtkDataArray): boolean;
+
+  /**
+   * Set the points of the plane.
+   * @param points The points to set.
+   */
+  setPoints(points: vtkPoints): boolean;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkPlane characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IPlanesInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IPlanesInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkPlane.
+ * @param {IPlanesInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(initialValues?: IPlanesInitialValues): vtkPlanes;
+
+/**
+ * vtkPlanes computes the implicit function and function gradient for a set of
+ * planes. The planes must define a convex space.
+ */
+export declare const vtkPlanes: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkPlanes;

package/Common/DataModel/Planes.js

@@ -0,0 +1,281 @@
+import { m as macro, T as TYPED_ARRAYS } from '../../macros2.js';
+import vtkDataArray from '../Core/DataArray.js';
+import vtkImplicitFunction from './ImplicitFunction.js';
+import { f as vtkMath } from '../Core/Math/index.js';
+import vtkPlane from './Plane.js';
+import vtkPoints from '../Core/Points.js';
+import { VtkDataTypes } from '../Core/DataArray/Constants.js';
+
+const {
+  vtkErrorMacro,
+  vtkWarningMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
+// vtkPlanes methods
+// ----------------------------------------------------------------------------
+
+function vtkPlanes(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkPlanes');
+
+  // Initialize internal variables
+  model.planes = model.planes || macro.newTypedArray(TYPED_ARRAYS.Float64Array, 24);
+  model.bounds = model.bounds || macro.newTypedArray(TYPED_ARRAYS.Float64Array, 6);
+  model.plane = vtkPlane.newInstance();
+
+  // Public API methods
+  publicAPI.setNormals = normals => {
+    if (normals && normals.getNumberOfComponents() !== 3) {
+      vtkWarningMacro('This array does not have 3 components. Ignoring normals.');
+    }
+    model.normals = normals;
+    publicAPI.modified();
+    return true;
+  };
+
+  /**
+   * Evaluate the function at a point x
+   * @param {*} x The point at which to evaluate the function
+   * @returns The function value at the point x
+   */
+  publicAPI.evaluateFunction = x => {
+    if (!model.points || !model.normals) {
+      vtkErrorMacro('Please define points and/or normals!');
+      return Number.MAX_VALUE;
+    }
+    const numPlanes = model.points.getNumberOfPoints();
+    if (numPlanes !== model.normals.getNumberOfTuples()) {
+      vtkErrorMacro('Number of normals/points inconsistent!');
+      return Number.MAX_VALUE;
+    }
+    let maxVal = -Number.MAX_VALUE;
+    const normal = [];
+    const point = [];
+    for (let i = 0; i < numPlanes; i++) {
+      model.normals.getTuple(i, normal);
+      model.points.getPoint(i, point);
+      const val = vtkPlane.evaluate(normal, point, x);
+      if (val > maxVal) {
+        maxVal = val;
+      }
+    }
+    return maxVal;
+  };
+
+  /**
+   * Evaluate the gradient at a point x
+   * @param {*} x The point at which to evaluate the gradient
+   * @returns The gradient at the point x
+   */
+  publicAPI.evaluateGradient = x => {
+    const retVal = [0, 0, 0];
+    if (!model.points || !model.normals) {
+      vtkErrorMacro('Define points and/or normals first!');
+      return retVal;
+    }
+    const numPlanes = model.points.getNumberOfPoints();
+    if (numPlanes !== model.normals.getNumberOfTuples()) {
+      vtkErrorMacro('The number of normals/points is inconsistent!');
+      return retVal;
+    }
+    let maxVal = -Number.MAX_VALUE;
+    const nTemp = [];
+    const pTemp = [];
+    for (let i = 0; i < numPlanes; i++) {
+      model.normals.getTuple(i, nTemp);
+      model.points.getPoint(i, pTemp);
+      const val = vtkPlane.evaluate(nTemp, pTemp, x);
+      if (val > maxVal) {
+        maxVal = val;
+        retVal[0] = nTemp[0];
+        retVal[1] = nTemp[1];
+        retVal[2] = nTemp[2];
+      }
+    }
+    return retVal;
+  };
+
+  /**
+   * Set the frustum planes
+   * @param {Number[]} planes The planes to set
+   * @returns {Boolean} true if planes were set, false if they were already set
+   */
+  publicAPI.setFrustumPlanes = planes => {
+    if (vtkMath.areEquals(model.planes, planes)) {
+      return false;
+    }
+    model.planes = [...planes];
+    const pts = vtkPoints.newInstance({
+      dataType: VtkDataTypes.DOUBLE
+    });
+    const normals = vtkDataArray.newInstance({
+      numberOfComponents: 3,
+      size: 6 * 3,
+      // 6 planes, each with a normal
+      dataType: VtkDataTypes.DOUBLE
+    });
+    pts.setNumberOfPoints(6);
+    publicAPI.setPoints(pts);
+    publicAPI.setNormals(normals);
+    const n = [];
+    const x = [];
+    for (let i = 0; i < 6; i++) {
+      const planeOffset = 4 * i;
+      n[0] = -planes[planeOffset];
+      n[1] = -planes[planeOffset + 1];
+      n[2] = -planes[planeOffset + 2];
+      x[0] = 0.0;
+      x[1] = 0.0;
+      x[2] = 0.0;
+      if (n[0] !== 0.0) {
+        x[0] = planes[planeOffset + 3] / n[0];
+      } else if (n[1] !== 0.0) {
+        x[1] = planes[planeOffset + 3] / n[1];
+      } else {
+        x[2] = planes[planeOffset + 3] / n[2];
+      }
+      pts.setPoint(i, ...x);
+      normals.setTuple(i, n);
+    }
+    publicAPI.modified();
+    return true;
+  };
+
+  /**
+   * Set the bounds of the planes
+   * @param {*} bounds The bounds to set
+   * @returns {Boolean} true if bounds were set, false if they were already set
+   */
+  publicAPI.setBounds = bounds => {
+    if (vtkMath.areEquals(model.bounds, bounds)) {
+      return false;
+    }
+    model.bounds = [...bounds];
+    const pts = vtkPoints.newInstance();
+    const normals = vtkDataArray.newInstance({
+      numberOfComponents: 3,
+      size: 6 * 3,
+      // 6 planes, each with a normal
+      dataType: VtkDataTypes.DOUBLE
+    });
+    pts.setNumberOfPoints(6);
+    publicAPI.setPoints(pts);
+    publicAPI.setNormals(normals);
+    const n = [];
+    const x = [];
+
+    // The x planes
+    n[0] = -1.0;
+    n[1] = 0.0;
+    n[2] = 0.0;
+    x[0] = bounds[0];
+    x[1] = 0.0;
+    x[2] = 0.0;
+    pts.setPoint(0, ...x);
+    normals.setTuple(0, n);
+    n[0] = 1.0;
+    x[0] = bounds[1];
+    pts.setPoint(1, ...x);
+    normals.setTuple(1, n);
+
+    // The y planes
+    n[0] = 0.0;
+    n[1] = -1.0;
+    n[2] = 0.0;
+    x[0] = 0.0;
+    x[1] = bounds[2];
+    x[2] = 0.0;
+    pts.setPoint(2, ...x);
+    normals.setTuple(2, n);
+    n[1] = 1.0;
+    x[1] = bounds[3];
+    pts.setPoint(3, ...x);
+    normals.setTuple(3, n);
+
+    // The z planes
+    n[0] = 0.0;
+    n[1] = 0.0;
+    n[2] = -1.0;
+    x[0] = 0.0;
+    x[1] = 0.0;
+    x[2] = bounds[4];
+    pts.setPoint(4, ...x);
+    normals.setTuple(4, n);
+    n[2] = 1.0;
+    x[2] = bounds[5];
+    pts.setPoint(5, ...x);
+    normals.setTuple(5, n);
+    publicAPI.modified();
+    return true;
+  };
+
+  /**
+   * Get the number of planes
+   * @returns {Number} the number of planes
+   */
+  publicAPI.getNumberOfPlanes = () => {
+    if (model.points && model.normals) {
+      const npts = model.points.getNumberOfPoints();
+      const nnormals = model.normals.getNumberOfTuples();
+      return Math.min(npts, nnormals);
+    }
+    return 0;
+  };
+
+  /**
+   * Get the i-th plane
+   * @param {*} i
+   * @param {vtkPlane} plane the vtkPlane instance to fill
+   * @returns {vtkPlane} the plane instance
+   */
+  publicAPI.getPlane = function (i) {
+    let plane = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : model.plane;
+    if (i >= 0 && i < publicAPI.getNumberOfPlanes()) {
+      const normal = model.normals.getTuple(i);
+      const point = model.points.getPoint(i);
+      plane.setNormal(normal);
+      plane.setOrigin(point);
+    }
+    return plane;
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  points: null,
+  normals: null,
+  planes: null,
+  bounds: null
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Build VTK API
+  vtkImplicitFunction.extend(publicAPI, model, initialValues);
+  macro.setGet(publicAPI, model, ['points', 'normals']);
+  macro.get(publicAPI, model, ['bounds', 'planes']);
+
+  // Object methods
+  vtkPlanes(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkPlanes');
+
+// ----------------------------------------------------------------------------
+
+var vtkPlanes$1 = {
+  newInstance,
+  extend
+};
+
+export { vtkPlanes$1 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;