@kitware/vtk.js 30.6.0 → 30.6.2

package/Common/DataModel/IncrementalOctreeNode.d.ts

@@ -5,258 +5,258 @@ import vtkPoints from './../Core/Points';
  *
  */
 export interface IIncrementalOctreeNodeInitialValues {
-	pointIdSet?: number[];
-	minBounds?: Bounds;
-	maxBounds?: Bounds;
-	minDataBounds?: Bounds;
-	maxDataBounds?: Bounds;
-	parent?: vtkIncrementalOctreeNode;
-	children?: vtkIncrementalOctreeNode[];
+  pointIdSet?: number[];
+  minBounds?: Bounds;
+  maxBounds?: Bounds;
+  minDataBounds?: Bounds;
+  maxDataBounds?: Bounds;
+  parent?: vtkIncrementalOctreeNode;
+  children?: vtkIncrementalOctreeNode[];
 }
 
 export interface vtkIncrementalOctreeNode extends vtkObject {
-	/**
-	 * Create a list object for storing point indices.
-	 */
-	createPointIdSet(): void;
+  /**
+   * Create a list object for storing point indices.
+   */
+  createPointIdSet(): void;
 
-	/**
-	 * Set the spatial bounding box of the node. This function sets a default
-	 * data bounding box.
-	 *
-	 * @param {Number} x1
-	 * @param {Number} x2
-	 * @param {Number} y1
-	 * @param {Number} y2
-	 * @param {Number} z1
-	 * @param {Number} z2
-	 */
-	setBounds(
-		x1: number,
-		x2: number,
-		y1: number,
-		y2: number,
-		z1: number,
-		z2: number
-	): void;
+  /**
+   * Set the spatial bounding box of the node. This function sets a default
+   * data bounding box.
+   *
+   * @param {Number} x1
+   * @param {Number} x2
+   * @param {Number} y1
+   * @param {Number} y2
+   * @param {Number} z1
+   * @param {Number} z2
+   */
+  setBounds(
+    x1: number,
+    x2: number,
+    y1: number,
+    y2: number,
+    z1: number,
+    z2: number
+  ): void;
 
-	/**
-	 * Get the spatial bounding box of the node. The values are returned via
-	 * an array in order of: x_min, x_max, y_min, y_max, z_min, z_max.
-	 *
-	 * @param {Bounds} bounds
-	 */
-	getBounds(bounds: Bounds): void;
+  /**
+   * Get the spatial bounding box of the node. The values are returned via
+   * an array in order of: x_min, x_max, y_min, y_max, z_min, z_max.
+   *
+   * @param {Bounds} bounds
+   */
+  getBounds(bounds: Bounds): void;
 
-	/**
-	 * @param {Vector3} point
-	 */
-	getChildIndex(point: Vector3): number;
-	
-	/**
-	 * @param {Vector3} point
-	 */
-	containsPoint(point: Vector3): boolean;
-	
-	/**
-	 * @param {Vector3} point
-	 */
-	containsPointByData(point: Vector3): boolean;
+  /**
+   * @param {Vector3} point
+   */
+  getChildIndex(point: Vector3): number;
 
-	/**
-	 * Given a point inserted to either this node (a leaf node) or a descendant
-	 * leaf (of this node --- when this node is a non-leaf node), update the
-	 * counter and the data bounding box for this node only. The data bounding box
-	 * is considered only if updateData is non-zero. The returned value indicates
-	 * whether (1) or not (0) the data bounding box is actually updated. Note that
-	 * argument nHits must be 1 unless this node is updated with a number (nHits)
-	 * of exactly duplicate points as a whole via a single call to this function.
-	 *
-	 * @param {Vector3} point
-	 * @param {Number} nHits
-	 * @param {Boolean} updateData
-	 */
-	updateCounterAndDataBounds(
-		point: Vector3,
-		nHits: number,
-		updateData: boolean
-	): boolean;
+  /**
+   * @param {Vector3} point
+   */
+  containsPoint(point: Vector3): boolean;
 
-	/**
-	 * Given a point inserted to either this node (a leaf node) or a descendant
-	 * leaf (of this node --- when this node is a non-leaf node), update the
-	 * counter and the data bounding box recursively bottom-up until a specified
-	 * node. The data bounding box is considered only if updateData is non-zero.
-	 * The returned value indicates whether (true) or not (false) the data bounding box
-	 * is actually updated. Note that argument nHits must be 1 unless this node
-	 * is updated with a number (nHits) of exactly duplicate points as a whole
-	 * via a single call to this function.
-	 *
-	 * @param {Vector3} point
-	 * @param {Number} nHits
-	 * @param {Boolean} updateData
-	 * @param {vtkIncrementalOctreeNode} endNode
-	 */
-	updateCounterAndDataBoundsRecursively(
-		point: Vector3,
-		nHits: number,
-		updateData: boolean,
-		endNode: vtkIncrementalOctreeNode
-	): boolean;
+  /**
+   * @param {Vector3} point
+   */
+  containsPointByData(point: Vector3): boolean;
 
-	/**
-	 * Given a point, determine whether (true) or not (false) it is an exact duplicate
-	 * of all the points, if any, maintained in this node. In other words, to
-	 * check if this given point and all existing points, if any, of this node
-	 * are exactly duplicate with one another.
-	 *
-	 * @param {Vector3} point
-	 */
-	containsDuplicatePointsOnly(point: Vector3): boolean;
+  /**
+   * Given a point inserted to either this node (a leaf node) or a descendant
+   * leaf (of this node --- when this node is a non-leaf node), update the
+   * counter and the data bounding box for this node only. The data bounding box
+   * is considered only if updateData is non-zero. The returned value indicates
+   * whether (1) or not (0) the data bounding box is actually updated. Note that
+   * argument nHits must be 1 unless this node is updated with a number (nHits)
+   * of exactly duplicate points as a whole via a single call to this function.
+   *
+   * @param {Vector3} point
+   * @param {Number} nHits
+   * @param {Boolean} updateData
+   */
+  updateCounterAndDataBounds(
+    point: Vector3,
+    nHits: number,
+    updateData: boolean
+  ): boolean;
 
-	/**
-	 * Determine whether or not this node is a leaf.
-	 */
-	isLeaf(): boolean;
+  /**
+   * Given a point inserted to either this node (a leaf node) or a descendant
+   * leaf (of this node --- when this node is a non-leaf node), update the
+   * counter and the data bounding box recursively bottom-up until a specified
+   * node. The data bounding box is considered only if updateData is non-zero.
+   * The returned value indicates whether (true) or not (false) the data bounding box
+   * is actually updated. Note that argument nHits must be 1 unless this node
+   * is updated with a number (nHits) of exactly duplicate points as a whole
+   * via a single call to this function.
+   *
+   * @param {Vector3} point
+   * @param {Number} nHits
+   * @param {Boolean} updateData
+   * @param {vtkIncrementalOctreeNode} endNode
+   */
+  updateCounterAndDataBoundsRecursively(
+    point: Vector3,
+    nHits: number,
+    updateData: boolean,
+    endNode: vtkIncrementalOctreeNode
+  ): boolean;
 
-	/**
-	 * Get the child at the given index i.
-	 * i must be an int between 0 and 7.
-	 *
-	 * @param {Number} i
-	 */
-	getChild(i: number): vtkIncrementalOctreeNode;
+  /**
+   * Given a point, determine whether (true) or not (false) it is an exact duplicate
+   * of all the points, if any, maintained in this node. In other words, to
+   * check if this given point and all existing points, if any, of this node
+   * are exactly duplicate with one another.
+   *
+   * @param {Vector3} point
+   */
+  containsDuplicatePointsOnly(point: Vector3): boolean;
 
-	/**
-	 * Given a number (>= threshold) of all exactly duplicate points (accessible
-	 * via points and pntIds, but with exactly the same 3D coordinate) maintained
-	 * in this leaf node and a point (absolutely not a duplicate any more, with
-	 * pntIdx storing the index in points)) to be inserted to this node, separate
-	 * all the duplicate points from this new point by means of usually recursive
-	 * node sub-division such that the former points are inserted to a descendant
-	 * leaf while the new point is inserted to a sibling of this descendant leaf.
-	 * Argument ptMode specifies whether the point is not inserted at all but only
-	 * the point index is provided upon 0, the point is inserted via vtkPoints::
-	 * InsertPoint() upon 1, or this point is instead inserted through vtkPoints::
-	 * InsertNextPoint() upon 2.
-	 *
-	 * @param {vtkPoints} points
-	 * @param {Number[]} pntIds
-	 * @param {Vector3} newPnt
-	 * @param {Number} pntIdx
-	 * @param {Number} maxPts
-	 * @param {Number} ptMode
-	 */
-	separateExactlyDuplicatePointsFromNewInsertion(
-		points: vtkPoints,
-		pntIds: number[],
-		newPnt: Vector3,
-		pntIdx: number,
-		maxPts: number,
-		ptMode: number
-	): void;
+  /**
+   * Determine whether or not this node is a leaf.
+   */
+  isLeaf(): boolean;
 
-	/**
-	 * Divide this LEAF node into eight child nodes as the number of points
-	 * maintained by this leaf node has reached the threshold maxPts while
-	 * another point newPnt is just going to be inserted to it. The available
-	 * point-indices pntIds are distributed to the child nodes based on the
-	 * point coordinates (available through points). Note that this function
-	 * can incur recursive node-division to determine the specific leaf node
-	 * for accepting the new point (with pntIdx storing the index in points)
-	 * because the existing maxPts points may fall within only one of the eight
-	 * child nodes to make a radically imbalanced layout within the node (to
-	 * be divided). Argument ptMode specifies whether the point is not inserted
-	 * at all but instead only the point index is provided upon 0, the point is
-	 * inserted via vtkPoints.InsertPoint() upon 1, or the point is inserted by
-	 * vtkPoints.InsertNextPoint() upon 2. The returned value of this function
-	 * indicates whether pntIds needs to be destroyed (1) or just unregistered
-	 * from this node as it has been attached to another node (0).
-	 * numberOfNodes in the tree is updated with new created nodes
-	 *
-	 * @param {vtkPoints} points
-	 * @param {Number[]} pntIds
-	 * @param {Vector3} newPnt
-	 * @param {Number} pntIdx
-	 * @param {Number} maxPts
-	 * @param {Number} ptMode
-	 * @param {Number} numberOfNodes
-	 */
-	createChildNodes(
-		points: vtkPoints,
-		pntIds: number[],
-		newPnt: Vector3,
-		pntIdx: number,
-		maxPts: number,
-		ptMode: number,
-		numberOfNodes: number
-	): { success: boolean; numberOfNodes: number; pointIdx: number };
+  /**
+   * Get the child at the given index i.
+   * i must be an int between 0 and 7.
+   *
+   * @param {Number} i
+   */
+  getChild(i: number): vtkIncrementalOctreeNode;
 
-	/**
-	 * This function is called after a successful point-insertion check and
-	 * only applies to a leaf node. Prior to a call to this function, the
-	 * octree should have been retrieved top-down to find the specific leaf
-	 * node in which this new point (newPt) will be inserted. The actual index
-	 * of the new point (to be inserted to points) is stored in pntId. Argument
-	 * ptMode specifies whether the point is not inserted at all but instead only
-	 * the point index is provided upon 0, the point is inserted via vtkPoints.
-	 * insertPoint() upon 1, or it is inserted via vtkPoints.insertNextPoint()
-	 * upon 2. For case 0, pntId needs to be specified. For cases 1 and 2, the
-	 * actual point index is returned via pntId. Note that this function always
-	 * returns 1 to indicate the success of point insertion.
-	 * numberOfNodes is the number of nodes present in the tree at this time.
-	 * it is used to assign an ID to each node which can be used to associate
-	 * application specific information with each node. It is updated if new nodes
-	 * are added to the tree.
-	 *
-	 * @param {Number} points
-	 * @param {Number} newPnt
-	 * @param {Number} maxPts
-	 * @param {Number} pntId
-	 * @param {Number} ptMode
-	 * @param {Number} numberOfNodes
-	 */
-	insertPoint(
-		points: number,
-		newPnt: number,
-		maxPts: number,
-		pntId: number,
-		ptMode: number,
-		numberOfNodes: number
-	): { numberOfNodes: number; pointIdx: number };
+  /**
+   * Given a number (>= threshold) of all exactly duplicate points (accessible
+   * via points and pntIds, but with exactly the same 3D coordinate) maintained
+   * in this leaf node and a point (absolutely not a duplicate any more, with
+   * pntIdx storing the index in points)) to be inserted to this node, separate
+   * all the duplicate points from this new point by means of usually recursive
+   * node sub-division such that the former points are inserted to a descendant
+   * leaf while the new point is inserted to a sibling of this descendant leaf.
+   * Argument ptMode specifies whether the point is not inserted at all but only
+   * the point index is provided upon 0, the point is inserted via vtkPoints::
+   * InsertPoint() upon 1, or this point is instead inserted through vtkPoints::
+   * InsertNextPoint() upon 2.
+   *
+   * @param {vtkPoints} points
+   * @param {Number[]} pntIds
+   * @param {Vector3} newPnt
+   * @param {Number} pntIdx
+   * @param {Number} maxPts
+   * @param {Number} ptMode
+   */
+  separateExactlyDuplicatePointsFromNewInsertion(
+    points: vtkPoints,
+    pntIds: number[],
+    newPnt: Vector3,
+    pntIdx: number,
+    maxPts: number,
+    ptMode: number
+  ): void;
 
-	/**
-	 * Compute the minimum squared distance from a point to this node, with all
-	 * six boundaries considered. The data bounding box is checked if checkData
-	 * is non-zero. The closest on-boundary point is returned via closest.
-	 *
-	 * @param {Vector3} point
-	 * @param {Vector3} closest
-	 * @param {Boolean} innerOnly
-	 * @param {vtkIncrementalOctreeNode} rootNode
-	 * @param {Boolean} checkData
-	 * @returns {Number}
-	 */
-	getDistance2ToBoundary(
-		point: Vector3,
-		closest: Vector3,
-		innerOnly: boolean,
-		rootNode: vtkIncrementalOctreeNode,
-		checkData: boolean
-	): number;
+  /**
+   * Divide this LEAF node into eight child nodes as the number of points
+   * maintained by this leaf node has reached the threshold maxPts while
+   * another point newPnt is just going to be inserted to it. The available
+   * point-indices pntIds are distributed to the child nodes based on the
+   * point coordinates (available through points). Note that this function
+   * can incur recursive node-division to determine the specific leaf node
+   * for accepting the new point (with pntIdx storing the index in points)
+   * because the existing maxPts points may fall within only one of the eight
+   * child nodes to make a radically imbalanced layout within the node (to
+   * be divided). Argument ptMode specifies whether the point is not inserted
+   * at all but instead only the point index is provided upon 0, the point is
+   * inserted via vtkPoints.InsertPoint() upon 1, or the point is inserted by
+   * vtkPoints.InsertNextPoint() upon 2. The returned value of this function
+   * indicates whether pntIds needs to be destroyed (1) or just unregistered
+   * from this node as it has been attached to another node (0).
+   * numberOfNodes in the tree is updated with new created nodes
+   *
+   * @param {vtkPoints} points
+   * @param {Number[]} pntIds
+   * @param {Vector3} newPnt
+   * @param {Number} pntIdx
+   * @param {Number} maxPts
+   * @param {Number} ptMode
+   * @param {Number} numberOfNodes
+   */
+  createChildNodes(
+    points: vtkPoints,
+    pntIds: number[],
+    newPnt: Vector3,
+    pntIdx: number,
+    maxPts: number,
+    ptMode: number,
+    numberOfNodes: number
+  ): { success: boolean; numberOfNodes: number; pointIdx: number };
 
-	/**
-	 * Given a point inside this node, get the minimum squared distance to all
-	 * inner boundaries. An inner boundary is a node's face that is shared by
-	 * another non-root node.
-	 *
-	 * @param {Vector3} point
-	 * @param {vtkIncrementalOctreeNode} rootNode
-	 */
-	getDistance2ToInnerBoundary(
-		point: Vector3,
-		rootNode: vtkIncrementalOctreeNode
-	): number;
+  /**
+   * This function is called after a successful point-insertion check and
+   * only applies to a leaf node. Prior to a call to this function, the
+   * octree should have been retrieved top-down to find the specific leaf
+   * node in which this new point (newPt) will be inserted. The actual index
+   * of the new point (to be inserted to points) is stored in pntId. Argument
+   * ptMode specifies whether the point is not inserted at all but instead only
+   * the point index is provided upon 0, the point is inserted via vtkPoints.
+   * insertPoint() upon 1, or it is inserted via vtkPoints.insertNextPoint()
+   * upon 2. For case 0, pntId needs to be specified. For cases 1 and 2, the
+   * actual point index is returned via pntId. Note that this function always
+   * returns 1 to indicate the success of point insertion.
+   * numberOfNodes is the number of nodes present in the tree at this time.
+   * it is used to assign an ID to each node which can be used to associate
+   * application specific information with each node. It is updated if new nodes
+   * are added to the tree.
+   *
+   * @param {Number} points
+   * @param {Number} newPnt
+   * @param {Number} maxPts
+   * @param {Number} pntId
+   * @param {Number} ptMode
+   * @param {Number} numberOfNodes
+   */
+  insertPoint(
+    points: number,
+    newPnt: number,
+    maxPts: number,
+    pntId: number,
+    ptMode: number,
+    numberOfNodes: number
+  ): { numberOfNodes: number; pointIdx: number };
+
+  /**
+   * Compute the minimum squared distance from a point to this node, with all
+   * six boundaries considered. The data bounding box is checked if checkData
+   * is non-zero. The closest on-boundary point is returned via closest.
+   *
+   * @param {Vector3} point
+   * @param {Vector3} closest
+   * @param {Boolean} innerOnly
+   * @param {vtkIncrementalOctreeNode} rootNode
+   * @param {Boolean} checkData
+   * @returns {Number}
+   */
+  getDistance2ToBoundary(
+    point: Vector3,
+    closest: Vector3,
+    innerOnly: boolean,
+    rootNode: vtkIncrementalOctreeNode,
+    checkData: boolean
+  ): number;
+
+  /**
+   * Given a point inside this node, get the minimum squared distance to all
+   * inner boundaries. An inner boundary is a node's face that is shared by
+   * another non-root node.
+   *
+   * @param {Vector3} point
+   * @param {vtkIncrementalOctreeNode} rootNode
+   */
+  getDistance2ToInnerBoundary(
+    point: Vector3,
+    rootNode: vtkIncrementalOctreeNode
+  ): number;
 }
 
 // ----------------------------------------------------------------------------
@@ -271,9 +271,9 @@ export interface vtkIncrementalOctreeNode extends vtkObject {
  * @param {object} [initialValues] (default: {})
  */
 export function extend(
-	publicAPI: object,
-	model: object,
-	initialValues?: object
+  publicAPI: object,
+  model: object,
+  initialValues?: object
 ): void;
 
 // ----------------------------------------------------------------------------
@@ -283,15 +283,15 @@ export function extend(
  * @param {IIncrementalOctreeNodeInitialValues} [initialValues] for pre-setting some of its content
  */
 export function newInstance(
-	initialValues?: IIncrementalOctreeNodeInitialValues
+  initialValues?: IIncrementalOctreeNodeInitialValues
 ): vtkIncrementalOctreeNode;
 
 /**
  * vtkIncrementalOctreeNode
  */
 export declare const vtkIncrementalOctreeNode: {
-	newInstance: typeof newInstance;
-	extend: typeof extend;
+  newInstance: typeof newInstance;
+  extend: typeof extend;
 };
 
 export default vtkIncrementalOctreeNode;

package/Common/DataModel/IncrementalOctreePointLocator.d.ts

@@ -7,21 +7,21 @@ import { IAbstractPointLocatorInitialValues } from './AbstractPointLocator';
  *
  */
 export interface IIncrementalOctreePointLocatorInitialValues
-	extends IAbstractPointLocatorInitialValues {
-	fudgeFactor: number;
-	octreeMaxDimSize: number;
-	buildCubicOctree: boolean;
-	maxPointsPerLeaf: number;
-	insertTolerance2: number;
-	locatorPoints: vtkPoints;
-	octreeRootNode: vtkIncrementalOctreeNode;
-	numberOfNodes: number;
+  extends IAbstractPointLocatorInitialValues {
+  fudgeFactor: number;
+  octreeMaxDimSize: number;
+  buildCubicOctree: boolean;
+  maxPointsPerLeaf: number;
+  insertTolerance2: number;
+  locatorPoints: vtkPoints;
+  octreeRootNode: vtkIncrementalOctreeNode;
+  numberOfNodes: number;
 }
 
 type vtkIncrementalOctreePointLocatorBase = vtkObject;
 
 export interface vtkIncrementalOctreePointLocator
-	extends vtkIncrementalOctreePointLocatorBase {}
+  extends vtkIncrementalOctreePointLocatorBase {}
 
 // ----------------------------------------------------------------------------
 // Static API
@@ -35,9 +35,9 @@ export interface vtkIncrementalOctreePointLocator
  * @param {object} [initialValues] (default: {})
  */
 export function extend(
-	publicAPI: object,
-	model: object,
-	initialValues?: IIncrementalOctreePointLocatorInitialValues
+  publicAPI: object,
+  model: object,
+  initialValues?: IIncrementalOctreePointLocatorInitialValues
 ): void;
 
 // ----------------------------------------------------------------------------
@@ -47,15 +47,15 @@ export function extend(
  * @param {IIncrementalOctreePointLocatorInitialValues} [initialValues] for pre-setting some of its content
  */
 export function newInstance(
-	initialValues?: IIncrementalOctreePointLocatorInitialValues
+  initialValues?: IIncrementalOctreePointLocatorInitialValues
 ): vtkIncrementalOctreePointLocator;
 
 /**
  * vtkIncrementalOctreePointLocator
  */
 export declare const vtkIncrementalOctreePointLocator: {
-	newInstance: typeof newInstance;
-	extend: typeof extend;
+  newInstance: typeof newInstance;
+  extend: typeof extend;
 };
 
 export default vtkIncrementalOctreePointLocator;