@kitware/vtk.js 30.6.0 → 30.6.2

package/Common/DataModel/KochanekSpline1D.d.ts

@@ -1,42 +1,60 @@
-import vtkSpline1D, { ISpline1DInitialValues, BoundaryCondition } from './Spline1D';
+import vtkSpline1D, {
+  ISpline1DInitialValues,
+  BoundaryCondition,
+} from './Spline1D';
 
 export interface IKochanekSpline1DInitialValues extends ISpline1DInitialValues {
-	tension?: number;
-	bias?: number;
-	continuity?: number;
+  tension?: number;
+  bias?: number;
+  continuity?: number;
 }
 
 export interface vtkKochanekSpline1D extends vtkSpline1D {
+  /**
+   *
+   * @param {Number} size
+   * @param {Float32Array} work
+   * @param {Number[]} x
+   * @param {Number[]} y
+   */
+  computeCloseCoefficients(
+    size: number,
+    work: Float32Array,
+    x: number[],
+    y: number[]
+  ): void;
 
-	/**
-	 * 
-	 * @param {Number} size 
-	 * @param {Float32Array} work 
-	 * @param {Number[]} x 
-	 * @param {Number[]} y 
-	 */
-	computeCloseCoefficients(size: number, work: Float32Array, x: number[], y: number[]): void;
+  /**
+   *
+   * @param {Number} size
+   * @param {Float32Array} work
+   * @param {Number[]} x
+   * @param {Number[]} 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: number[],
+    y: number[],
+    options: {
+      leftConstraint: BoundaryCondition;
+      leftValue: number;
+      rightConstraint: BoundaryCondition;
+      rightValue: Number;
+    }
+  ): void;
 
-	/**
-	 * 
-	 * @param {Number} size 
-	 * @param {Float32Array} work 
-	 * @param {Number[]} x 
-	 * @param {Number[]} 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: number[], y: number[], 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;
 }
 
 /**
@@ -46,13 +64,19 @@ export interface vtkKochanekSpline1D extends vtkSpline1D {
  * @param model object on which data structure will be bounds (protected)
  * @param {IKochanekSpline1DInitialValues} [initialValues] (default: {})
  */
-export function extend(publicAPI: object, model: object, initialValues?: IKochanekSpline1DInitialValues): void;
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IKochanekSpline1DInitialValues
+): void;
 
 /**
  * Method used to create a new instance of vtkKochanekSpline1D.
  * @param {IKochanekSpline1DInitialValues} [initialValues] for pre-setting some of its content
  */
-export function newInstance(initialValues?: IKochanekSpline1DInitialValues): vtkKochanekSpline1D;
+export function newInstance(
+  initialValues?: IKochanekSpline1DInitialValues
+): vtkKochanekSpline1D;
 
 /**
  * vtkKochanekSpline1D provides methods for creating a Kochanek interpolating
@@ -61,7 +85,7 @@ export function newInstance(initialValues?: IKochanekSpline1DInitialValues): vtk
  */
 
 export declare const vtkKochanekSpline1D: {
-	newInstance: typeof newInstance,
-	extend: typeof extend
+  newInstance: typeof newInstance;
+  extend: typeof extend;
 };
 export default vtkKochanekSpline1D;

package/Common/DataModel/Line.d.ts

@@ -3,80 +3,85 @@ import { Vector3, Vector2, Nullable } from './../../types';
 import vtkCell from './Cell';
 
 export enum IntersectionState {
-	NO_INTERSECTION,
-	YES_INTERSECTION,
-	ON_LINE,
+  NO_INTERSECTION,
+  YES_INTERSECTION,
+  ON_LINE,
 }
 
 export interface ILineInitialValues {
-	orientations: Nullable<quat[]>;
+  orientations: Nullable<quat[]>;
 }
 
 export interface IIntersectWithLine {
-	intersect: number;
-	t: number;
-	subId: number;
-	evaluation?: number;
-	betweenPoints?: boolean;
+  intersect: number;
+  t: number;
+  subId: number;
+  evaluation?: number;
+  betweenPoints?: boolean;
 }
 
 interface IDistanceToLine {
-	t: number;
-	distance: number;
+  t: number;
+  distance: number;
 }
 
 export interface vtkLine extends vtkCell {
-
-	/**
-	 * Get the topological dimensional of the cell (0, 1, 2 or 3).
-	 */
-	getCellDimension(): number;
-
-	/**
-	 * Get the list of orientations (a list of quat) for each point of the line.
-	 * Can be null if the line is not oriented
-	 */
-	getOrientations(): Nullable<quat[]>;
-
-	/**
-	 * @see getOrientations
-	 * @param orientations The list of orientation per point of the centerline
-	 */
-	setOrientations(orientations: Nullable<quat[]>): boolean;
-
-	/**
-	 * Compute the intersection point of the intersection between line and line
-	 * defined by p1 and p2. tol Tolerance use for the position evaluation x is
-	 * the point which intersect triangle (computed in function) pcoords
-	 * parametric coordinates (computed in function) A javascript object is
-	 * returned :
-	 * 
-	 * ```js
-	 * {
-	 *   evaluation: define if the line has been intersected or not
-	 *   subId: always set to 0
-	 *   t: tolerance of the intersection
-	 * }
-	 * ```
-	 * @param {Vector3} p1 The first point coordinate.
-	 * @param {Vector3} p2 The second point coordinate.
-	 * @param {Number} tol The tolerance to use.
-	 * @param {Vector3} x The point which intersect triangle.
-	 * @param {Vector3} pcoords The parametric coordinates.
-	 */
-	intersectWithLine(p1: Vector3, p2: Vector3, tol: number, x: Vector3, pcoords: Vector3): IIntersectWithLine;
-
-	/**
-	 * Determine the global coordinates `x' and parametric coordinates `pcoords' in the cell.
-	 */
-	evaluateLocation(pcoords: Vector3, x: Vector3, weights: Vector2): void
-
-	/**
-	 * Determine the global orientation `q' and parametric coordinates `pcoords' in the cell.
-	 * Use slerp to interpolate orientation
-	 * Returns wether the orientation has been set in `q'
-	 */
-	evaluateOrientation(pcoords: Vector3, q: quat, weights: Vector2): boolean
+  /**
+   * Get the topological dimensional of the cell (0, 1, 2 or 3).
+   */
+  getCellDimension(): number;
+
+  /**
+   * Get the list of orientations (a list of quat) for each point of the line.
+   * Can be null if the line is not oriented
+   */
+  getOrientations(): Nullable<quat[]>;
+
+  /**
+   * @see getOrientations
+   * @param orientations The list of orientation per point of the centerline
+   */
+  setOrientations(orientations: Nullable<quat[]>): boolean;
+
+  /**
+   * Compute the intersection point of the intersection between line and line
+   * defined by p1 and p2. tol Tolerance use for the position evaluation x is
+   * the point which intersect triangle (computed in function) pcoords
+   * parametric coordinates (computed in function) A javascript object is
+   * returned :
+   *
+   * ```js
+   * {
+   *   evaluation: define if the line has been intersected or not
+   *   subId: always set to 0
+   *   t: tolerance of the intersection
+   * }
+   * ```
+   * @param {Vector3} p1 The first point coordinate.
+   * @param {Vector3} p2 The second point coordinate.
+   * @param {Number} tol The tolerance to use.
+   * @param {Vector3} x The point which intersect triangle.
+   * @param {Vector3} pcoords The parametric coordinates.
+   */
+  intersectWithLine(
+    p1: Vector3,
+    p2: Vector3,
+    tol: number,
+    x: Vector3,
+    pcoords: Vector3
+  ): IIntersectWithLine;
+
+  /**
+   * Determine the global coordinates `x' and parametric coordinates `pcoords' in the cell.
+   */
+  evaluateLocation(pcoords: Vector3, x: Vector3, weights: Vector2): void;
+
+  /**
+   * Determine the global orientation `q' and parametric coordinates `pcoords' in the cell.
+   * Use slerp to interpolate orientation
+   * Returns wether the orientation has been set in `q'
+   */
+  evaluateOrientation(pcoords: Vector3, q: quat, weights: Vector2): boolean;
 }
 
 /**
@@ -86,7 +91,11 @@ export interface vtkLine extends vtkCell {
  * @param model object on which data structure will be bounds (protected)
  * @param {ILineInitialValues} [initialValues] (default: {})
  */
-export function extend(publicAPI: object, model: object, initialValues?: ILineInitialValues): void;
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: ILineInitialValues
+): void;
 
 /**
  * Method used to create a new instance of vtkLine.
@@ -98,7 +107,7 @@ export function newInstance(initialValues?: ILineInitialValues): vtkLine;
  * Compute the distance from x to the line composed by p1 and p2. If an object
  * is set as a fourth argument, then the closest point on the line from x will
  * be set into it.
- * 
+ *
  * ```js
  * {
  *   t: tolerance of the distance
@@ -106,12 +115,17 @@ export function newInstance(initialValues?: ILineInitialValues): vtkLine;
  * }
  * ```
  * @static
- * @param {Vector3} x 
- * @param {Vector3} p1 
- * @param {Vector3} p2 
- * @param {Vector3} [closestPoint] 
+ * @param {Vector3} x
+ * @param {Vector3} p1
+ * @param {Vector3} p2
+ * @param {Vector3} [closestPoint]
  */
-export function distanceToLine(x: Vector3, p1: Vector3, p2: Vector3, closestPoint?: Vector3): IDistanceToLine;
+export function distanceToLine(
+  x: Vector3,
+  p1: Vector3,
+  p2: Vector3,
+  closestPoint?: Vector3
+): IDistanceToLine;
 
 /**
  * Performs intersection of two finite 3D lines. An intersection is found if the
@@ -121,7 +135,7 @@ export function distanceToLine(x: Vector3, p1: Vector3, p2: Vector3, closestPoin
  * parametric coordinates of the lines at the position of closest approach.
  * Careful, u and v are filled inside the function. Outside the function, they
  * have to be access with : u[0] and v[0] return IntersectionState enum :
- * 
+ *
  * ```js
  * enum IntersectionState {
  *    NO_INTERSECTION,
@@ -130,25 +144,32 @@ export function distanceToLine(x: Vector3, p1: Vector3, p2: Vector3, closestPoin
  * }
  * ```
  * @static
- * @param  {Vector3} a1 
- * @param {Vector3} a2 
- * @param {Vector3} b1 
- * @param {Vector3} b2 
- * @param {Vector3} u 
- * @param {Vector3} v 
+ * @param  {Vector3} a1
+ * @param {Vector3} a2
+ * @param {Vector3} b1
+ * @param {Vector3} b2
+ * @param {Vector3} u
+ * @param {Vector3} v
  */
-export function intersection(a1: Vector3, a2: Vector3, b1: Vector3, b2: Vector3, u: Vector3, v: Vector3): IntersectionState;
+export function intersection(
+  a1: Vector3,
+  a2: Vector3,
+  b1: Vector3,
+  b2: Vector3,
+  u: Vector3,
+  v: Vector3
+): IntersectionState;
 
-/** 
+/**
  * vtkLine is a cell which representant a line.
  * It contains static method to make some computations directly link to line.
- * 
+ *
  * @see vtkCell
  */
 export declare const vtkLine: {
-	newInstance: typeof newInstance,
-	extend: typeof extend;
-	distanceToLine: typeof distanceToLine;
-	intersection: typeof intersection;
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+  distanceToLine: typeof distanceToLine;
+  intersection: typeof intersection;
 };
 export default vtkLine;

package/Common/DataModel/Locator.d.ts

@@ -4,12 +4,12 @@ import { vtkObject } from './../../interfaces';
  *
  */
 export interface ILocatorInitialValues {
-	dataSet?: number[];
-	maxLevel?: number;
-	level?: number;
-	automatic?: boolean;
-	tolerance?: number;
-	useExistingSearchStructure?: boolean;
+  dataSet?: number[];
+  maxLevel?: number;
+  level?: number;
+  automatic?: boolean;
+  tolerance?: number;
+  useExistingSearchStructure?: boolean;
 }
 
 export interface vtkLocator extends vtkObject {}
@@ -26,9 +26,9 @@ export interface vtkLocator extends vtkObject {}
  * @param {ILocatorInitialValues} [initialValues] (default: {})
  */
 export function extend(
-	publicAPI: object,
-	model: object,
-	initialValues?: ILocatorInitialValues
+  publicAPI: object,
+  model: object,
+  initialValues?: ILocatorInitialValues
 ): void;
 
 // ----------------------------------------------------------------------------
@@ -37,7 +37,7 @@ export function extend(
  * vtkLocator
  */
 export declare const vtkLocator: {
-	extend: typeof extend;
+  extend: typeof extend;
 };
 
 export default vtkLocator;