@kitware/vtk.js 30.6.0 → 30.6.2

package/Common/DataModel/CardinalSpline1D.d.ts

@@ -1,39 +1,58 @@
 import { Vector3 } from './../../types';
-import vtkSpline1D, { ISpline1DInitialValues, BoundaryCondition } from './Spline1D';
+import vtkSpline1D, {
+  ISpline1DInitialValues,
+  BoundaryCondition,
+} from './Spline1D';
 
-export interface ICardinalSpline1DInitialValues extends ISpline1DInitialValues {}
+export interface ICardinalSpline1DInitialValues
+  extends ISpline1DInitialValues {}
 
 export interface vtkCardinalSpline1D extends vtkSpline1D {
+  /**
+   *
+   * @param {Number} size
+   * @param {Float32Array} work
+   * @param {Vector3} x
+   * @param {Vector3} y
+   */
+  computeCloseCoefficients(
+    size: number,
+    work: Float32Array,
+    x: Vector3,
+    y: Vector3
+  ): void;
 
-	/**
-	 * 
-	 * @param {Number} size 
-	 * @param {Float32Array} work 
-	 * @param {Vector3} x 
-	 * @param {Vector3} y 
-	 */
-	computeCloseCoefficients(size: number, work: Float32Array, x: Vector3, y: Vector3): void;
+  /**
+   *
+   * @param {Number} size
+   * @param {Float32Array} work
+   * @param {Vector3} x
+   * @param {Vector3} y
+   * @param {Object} options
+   * @param {BoundaryCondition} options.leftConstraint
+   * @param {Number} options.leftValue
+   * @param {BoundaryCondition} options.rightConstraint
+   * @param {Number} options.rightValue
+   */
+  computeOpenCoefficients(
+    size: number,
+    work: Float32Array,
+    x: Vector3,
+    y: Vector3,
+    options: {
+      leftConstraint: BoundaryCondition;
+      leftValue: number;
+      rightConstraint: BoundaryCondition;
+      rightValue: Number;
+    }
+  ): void;
 
-	/**
-	 * 
-	 * @param {Number} size 
-	 * @param {Float32Array} work 
-	 * @param {Vector3} x 
-	 * @param {Vector3} y
-	 * @param {Object} options
-	 * @param {BoundaryCondition} options.leftConstraint
-	 * @param {Number} options.leftValue
-	 * @param {BoundaryCondition} options.rightConstraint
-	 * @param {Number} options.rightValue
-	 */
-	computeOpenCoefficients(size: number, work: Float32Array, x: Vector3, y: Vector3, options: { leftConstraint: BoundaryCondition, leftValue: number, rightConstraint: BoundaryCondition, rightValue: Number }): void;
-
-	/**
-	 * 
-	 * @param {Number} intervalIndex 
-	 * @param {Number} t 
-	 */
-	getValue(intervalIndex: number, t: number): number;
+  /**
+   *
+   * @param {Number} intervalIndex
+   * @param {Number} t
+   */
+  getValue(intervalIndex: number, t: number): number;
 }
 
 /**
@@ -43,13 +62,19 @@ export interface vtkCardinalSpline1D extends vtkSpline1D {
  * @param model object on which data structure will be bounds (protected)
  * @param {ICardinalSpline1DInitialValues} [initialValues] (default: {})
  */
-export function extend(publicAPI: object, model: object, initialValues?: ICardinalSpline1DInitialValues): void;
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: ICardinalSpline1DInitialValues
+): void;
 
 /**
  * Method used to create a new instance of vtkCardinalSpline1D.
  * @param {ICardinalSpline1DInitialValues} [initialValues] for pre-setting some of its content
  */
-export function newInstance(initialValues?: ICardinalSpline1DInitialValues): vtkCardinalSpline1D;
+export function newInstance(
+  initialValues?: ICardinalSpline1DInitialValues
+): vtkCardinalSpline1D;
 
 /**
  * vtkCardinalSpline1D provides methods for creating a 1D cubic spline object
@@ -57,7 +82,7 @@ export function newInstance(initialValues?: ICardinalSpline1DInitialValues): vtk
  * derivative at any given point inside the spline intervals.
  */
 export declare const vtkCardinalSpline1D: {
-	newInstance: typeof newInstance,
-	extend: typeof extend
+  newInstance: typeof newInstance;
+  extend: typeof extend;
 };
 export default vtkCardinalSpline1D;

package/Common/DataModel/Cell.d.ts

@@ -1,82 +1,81 @@
-import { vtkObject } from './../../interfaces' ;
+import { vtkObject } from './../../interfaces';
 import { Bounds, Vector3 } from './../../types';
 import vtkPoints from './../Core/Points';
 
 export interface ICellInitialValues {
-	bounds?: Bounds;
-	pointsIds?: number[];
+  bounds?: Bounds;
+  pointsIds?: number[];
 }
 
 export interface vtkCell extends vtkObject {
+  /**
+   * Copy this cell by completely copying internal data structures.
+   * @param {vtkCell} cell The cell you want to use.
+   */
+  deepCopy(cell: vtkCell): void;
 
-	/**
-	 * Copy this cell by completely copying internal data structures.
-	 * @param {vtkCell} cell The cell you want to use.
-	 */
-	deepCopy(cell: vtkCell): void;
+  /**
+   * Initialize the cell with point coordinates and cell point ids, example :
+   *
+   * ```js
+   * const points = vtkPoints.newInstance();
+   * points.setData(Float32Array.from([0, 0, 0, 0, 0, 1, ..., 255, 255, 255]));
+   * const pointIdsList = [13, 10, 235];
+   * // Create cell
+   * const triangle = vtkTriangle.newInstance();
+   * // Initialize cell
+   * triangle.initialize(points, pointIdsList);
+   * ```
+   *
+   * If pointIdsList is null, points are shallow copied and pointIdsList is
+   * generated as such: [0, 1, ..., N-1] where N is the number of points. If
+   * pointIdsList is not null, only pointIdsList point coordinates are copied into
+   * the cell. pointIdsList is shallow copied.
+   * @param {vtkPoints} points
+   * @param {Number[]} [pointIdsList]
+   */
+  initialize(points: vtkPoints, pointIdsList?: number[]): void;
 
-	/**
-	 * Initialize the cell with point coordinates and cell point ids, example :
-	 * 
-	 * ```js
-	 * const points = vtkPoints.newInstance();
-	 * points.setData(Float32Array.from([0, 0, 0, 0, 0, 1, ..., 255, 255, 255]));
-	 * const pointIdsList = [13, 10, 235];
-	 * // Create cell
-	 * const triangle = vtkTriangle.newInstance();
-	 * // Initialize cell
-	 * triangle.initialize(points, pointIdsList);
-	 * ```
-	 * 
-	 * If pointIdsList is null, points are shallow copied and pointIdsList is
-	 * generated as such: [0, 1, ..., N-1] where N is the number of points. If
-	 * pointIdsList is not null, only pointIdsList point coordinates are copied into
-	 * the cell. pointIdsList is shallow copied.
-	 * @param {vtkPoints} points 
-	 * @param {Number[]} [pointIdsList] 
-	 */
-	initialize(points: vtkPoints, pointIdsList?: number[]): void;
+  /**
+   * Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].
+   * @return {Bounds} The bounds for the mapper.
+   */
+  getBounds(): Bounds;
 
-	/**
-	 * Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].
-	 * @return {Bounds} The bounds for the mapper.
-	 */
-	getBounds(): Bounds;
+  /**
+   * Compute Length squared of cell (i.e., bounding box diagonal squared).
+   */
+  getLength2(): number;
 
-	/**
-	 * Compute Length squared of cell (i.e., bounding box diagonal squared).
-	 */
-	getLength2(): number;
+  /**
+   * Get the distance of the parametric coordinate provided to the cell. If
+   * inside the cell, a distance of zero is returned. This is used during
+   * picking to get the correct cell picked. (The tolerance will occasionally
+   * allow cells to be picked who are not really intersected "inside" the
+   * cell.)
+   * @param {Vector3} pcoords The coordinates of the point.
+   *
+   */
+  getParametricDistance(pcoords: Vector3): number;
 
-	/**
-	 * Get the distance of the parametric coordinate provided to the cell. If
-	 * inside the cell, a distance of zero is returned. This is used during
-	 * picking to get the correct cell picked. (The tolerance will occasionally
-	 * allow cells to be picked who are not really intersected "inside" the
-	 * cell.)
-	 * @param {Vector3} pcoords The coordinates of the point.
-	 *
-	 */
-	getParametricDistance(pcoords: Vector3): number;
+  /**
+   *
+   */
+  getPoints(): vtkPoints;
 
-	/**
-	 * 
-	 */
-	getPoints(): vtkPoints;
+  /**
+   *
+   */
+  getPointsIds(): number[];
 
-	/**
-	 * 
-	 */
-	getPointsIds(): number[];
+  /**
+   * Get the number of points in the cell.
+   */
+  getNumberOfPoints(): number;
 
-	/**
-	 * Get the number of points in the cell.
-	 */
-	getNumberOfPoints(): number;
-
-	// getCellDimension(): void;
-	// intersectWithLine(p1: any, p2: any, tol: any, t: any, x: any, pcoords: any, subId: any): void;
-	// evaluatePosition(x: Vector3, closestPoint: Vector3, subId: number, pcoords: Vector3, dist2: number, weights: any): void;
+  // getCellDimension(): void;
+  // intersectWithLine(p1: any, p2: any, tol: any, t: any, x: any, pcoords: any, subId: any): void;
+  // evaluatePosition(x: Vector3, closestPoint: Vector3, subId: number, pcoords: Vector3, dist2: number, weights: any): void;
 }
 
 /**
@@ -86,7 +85,11 @@ export interface vtkCell extends vtkObject {
  * @param model object on which data structure will be bounds (protected)
  * @param {ICellInitialValues} [initialValues] (default: {})
  */
-export function extend(publicAPI: object, model: object, initialValues?: ICellInitialValues): void;
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: ICellInitialValues
+): void;
 
 /**
  * Method used to create a new instance of vtkCell.
@@ -98,7 +101,7 @@ export function newInstance(initialValues?: ICellInitialValues): vtkCell;
  * vtkCell is an abstract method to define a cell
  */
 export declare const vtkCell: {
-	newInstance: typeof newInstance,
-	extend: typeof extend,
+  newInstance: typeof newInstance;
+  extend: typeof extend;
 };
 export default vtkCell;

package/Common/DataModel/Collection.d.ts

@@ -5,89 +5,99 @@ import { Nullable } from './../../types';
  *
  */
 export interface ICollectionInitialValues {
-	collection?: vtkObject[];
+  collection?: vtkObject[];
 }
 
-
 export interface vtkCollection extends vtkObject {
-
-	/**
-	 * Add item (vtkObject) to the collection
-	 * @param {vtkObject} item item to be added to the collection
-	 */
-  	addItem(item: vtkObject): void;
-
-	/**
-	 * Add item (vtkObject) to the collection _at_ the given index.
-	 * This differs from VTK-C++ where insertItem inserts at position
-	 * after the provided index value.
-	 * @param {number} idx index where the new item should be inserted.
-	 * @param {vtkObject} item item to be inserted
-	 */
-	insertItem(idx: number, item: vtkObject): void;
-
-	/**
-	 * Replace an existing item (vtkObject) with a new one
-	 * @param {number} idx index of item to be replaced
-	 * @param {vtkObject} item
-	 */
-	replaceItem(idx: number, item: vtkObject): void;
-
-	/**
-	 * Remove an existing item from the collection
-	 * @param {number|vtkObject} inValue index or reference of an item to be removed
-	 */
-	removeItem(inValue: number|vtkObject): void;
-
-	/**
-	 * Remove all items from the collection
-	 */
-	removeAllItems(): void;
-
-	/**
-	 * Check if a provided item is already present in the collection
-	 */
-	isItemPresent(item: vtkObject): boolean;
-
-	/**
-	 * Get the total number of items in the collection
-	 */
-	getNumberOfItems(): number;
-
-	/**
-	 * Check if the collection is empty
-	 */
-	empty(): boolean;
-
-	/**
-	 * get the current item and provided index, returns null if index is out of bounds
-	 */
-	getItem(idx: number): Nullable<vtkObject>;
-
-	/**
-	 * Execute a passed function on every item in the collection
-	 * @param callbackfn callback function to be executed on every item in the collection
-	 */
-	forEach<T>(callbackfn: (value: T, index: number, array: readonly T[]) => void): void;
-
-	/**
-	 * Execute a passed function on every item in the collection, in order to calculate an aggregated return value.
-	 * @param callbackfn callback function to be used for aggregating a single value from each item in the collection
-	 * @param initialValue starting value to calculate aggregation
-	 */
-	reduce<T>(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T, initialValue: T): T;
-
-	/**
-	 * Similar to forEach, but returns an array of resulting values.
-	 * @param callbackfn callback function to execute on each item in the collection, that returns a value.
-	 */
-	map<T>(callbackfn: (value: T, index: number, array: readonly T[]) => void): void;
-
-	/**
-	 * Check each element for modified time and update the collection's
-	 * MTime to the latest timestamp from individual items in the collection.
-	 */
-	updateMTimeWithElements(): void;
+  /**
+   * Add item (vtkObject) to the collection
+   * @param {vtkObject} item item to be added to the collection
+   */
+  addItem(item: vtkObject): void;
+
+  /**
+   * Add item (vtkObject) to the collection _at_ the given index.
+   * This differs from VTK-C++ where insertItem inserts at position
+   * after the provided index value.
+   * @param {number} idx index where the new item should be inserted.
+   * @param {vtkObject} item item to be inserted
+   */
+  insertItem(idx: number, item: vtkObject): void;
+
+  /**
+   * Replace an existing item (vtkObject) with a new one
+   * @param {number} idx index of item to be replaced
+   * @param {vtkObject} item
+   */
+  replaceItem(idx: number, item: vtkObject): void;
+
+  /**
+   * Remove an existing item from the collection
+   * @param {number|vtkObject} inValue index or reference of an item to be removed
+   */
+  removeItem(inValue: number | vtkObject): void;
+
+  /**
+   * Remove all items from the collection
+   */
+  removeAllItems(): void;
+
+  /**
+   * Check if a provided item is already present in the collection
+   */
+  isItemPresent(item: vtkObject): boolean;
+
+  /**
+   * Get the total number of items in the collection
+   */
+  getNumberOfItems(): number;
+
+  /**
+   * Check if the collection is empty
+   */
+  empty(): boolean;
+
+  /**
+   * get the current item and provided index, returns null if index is out of bounds
+   */
+  getItem(idx: number): Nullable<vtkObject>;
+
+  /**
+   * Execute a passed function on every item in the collection
+   * @param callbackfn callback function to be executed on every item in the collection
+   */
+  forEach<T>(
+    callbackfn: (value: T, index: number, array: readonly T[]) => void
+  ): void;
+
+  /**
+   * Execute a passed function on every item in the collection, in order to calculate an aggregated return value.
+   * @param callbackfn callback function to be used for aggregating a single value from each item in the collection
+   * @param initialValue starting value to calculate aggregation
+   */
+  reduce<T>(
+    callbackfn: (
+      previousValue: T,
+      currentValue: T,
+      currentIndex: number,
+      array: readonly T[]
+    ) => T,
+    initialValue: T
+  ): T;
+
+  /**
+   * Similar to forEach, but returns an array of resulting values.
+   * @param callbackfn callback function to execute on each item in the collection, that returns a value.
+   */
+  map<T>(
+    callbackfn: (value: T, index: number, array: readonly T[]) => void
+  ): void;
+
+  /**
+   * Check each element for modified time and update the collection's
+   * MTime to the latest timestamp from individual items in the collection.
+   */
+  updateMTimeWithElements(): void;
 }
 
 /**
@@ -97,13 +107,19 @@ export interface vtkCollection extends vtkObject {
  * @param model object on which data structure will be bounds (protected)
  * @param {ICollectionInitialValues} [initialValues] (default: {})
  */
-export function extend(publicAPI: object, model: object, initialValues? : ICollectionInitialValues): void;
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: ICollectionInitialValues
+): void;
 
 /**
  * Method used to create a new instance of vtkCollection.
  * @param {ICollectionInitialValues} [initialValues] for pre-setting some of its content
  */
-export function newInstance(initialValues? : ICollectionInitialValues): vtkCollection;
+export function newInstance(
+  initialValues?: ICollectionInitialValues
+): vtkCollection;
 
 /**
  * vtkCollection is a container of multiple vtkObject items.
@@ -112,7 +128,7 @@ export function newInstance(initialValues? : ICollectionInitialValues): vtkColle
  * to other filters and mappers as a single unit.
  */
 export declare const vtkCollection: {
-	newInstance: typeof newInstance;
-	extend: typeof extend;
+  newInstance: typeof newInstance;
+  extend: typeof extend;
 };
 export default vtkCollection;

package/Common/DataModel/Cone.d.ts

@@ -1,37 +1,36 @@
-import { vtkObject } from './../../interfaces' ;
+import { vtkObject } from './../../interfaces';
 import { Vector3 } from './../../types';
 
 /**
- * 
+ *
  */
 export interface IConeInitialValues {
-	angle?: number;
+  angle?: number;
 }
 
 export interface vtkCone extends vtkObject {
+  /**
+   * Given the point x evaluate the cone equation.
+   * @param {Vector3} x The point coordinate.
+   */
+  evaluateFunction(x: Vector3): number[];
 
-	/**
-	 * Given the point x evaluate the cone equation.
-	 * @param {Vector3} x The point coordinate.
-	 */
-	evaluateFunction(x: Vector3): number[];
-
-	/**
-	 * Given the point x evaluate the equation for the cone gradient.
-	 * @param {Vector3} x The point coordinate.
-	 */
-	evaluateGradient(x: Vector3): number[];
+  /**
+   * Given the point x evaluate the equation for the cone gradient.
+   * @param {Vector3} x The point coordinate.
+   */
+  evaluateGradient(x: Vector3): number[];
 
-	/**
-	 * Get the angle of the cone.
-	 */
-	getAngle(): number;
+  /**
+   * Get the angle of the cone.
+   */
+  getAngle(): number;
 
-	/**
-	 * Set the value representing the angle of the cone.
-	 * @param {Number} angle The angle of the cone. 
-	 */
-	setAngle(angle: number): boolean;
+  /**
+   * Set the value representing the angle of the cone.
+   * @param {Number} angle The angle of the cone.
+   */
+  setAngle(angle: number): boolean;
 }
 
 /**
@@ -41,7 +40,11 @@ export interface vtkCone extends vtkObject {
  * @param model object on which data structure will be bounds (protected)
  * @param {IConeInitialValues} [initialValues] (default: {})
  */
-export function extend(publicAPI: object, model: object, initialValues?: IConeInitialValues): void;
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IConeInitialValues
+): void;
 
 /**
  * Method used to create a new instance of vtkCone.
@@ -49,7 +52,7 @@ export function extend(publicAPI: object, model: object, initialValues?: IConeIn
  */
 export function newInstance(initialValues?: IConeInitialValues): vtkCone;
 
-/** 
+/**
  * vtkCone computes the implicit function and/or gradient for a cone. vtkCone is
  * a concrete implementation of vtkImplicitFunction. TODO: Currently the cone's
  * axis of rotation is along the x-axis with the apex at the origin. To
@@ -58,7 +61,7 @@ export function newInstance(initialValues?: IConeInitialValues): vtkCone;
  * implicit function level, and should be added.
  */
 export declare const vtkCone: {
-	newInstance: typeof newInstance, 
-	extend: typeof extend;
+  newInstance: typeof newInstance;
+  extend: typeof extend;
 };
 export default vtkCone;