@kitware/vtk.js 30.6.0 → 30.6.2

package/Common/DataModel/PolyData/Constants.d.ts

@@ -1,6 +1,6 @@
-export declare const POLYDATA_FIELDS : string[];
+export declare const POLYDATA_FIELDS: string[];
 
 declare const _default: {
-	POLYDATA_FIELDS: typeof POLYDATA_FIELDS;
+  POLYDATA_FIELDS: typeof POLYDATA_FIELDS;
 };
 export default _default;

package/Common/DataModel/PolyData.d.ts

@@ -5,144 +5,141 @@ import vtkPointSet, { IPointSetInitialValues } from './PointSet';
 /**
  *
  */
-export interface IPolyDataInitialValues extends IPointSetInitialValues {
-}
-
+export interface IPolyDataInitialValues extends IPointSetInitialValues {}
 
 export interface vtkPolyData extends vtkPointSet {
-
-	/**
-	 * Create data structure that allows random access of cells.
-	 */
-	buildCells(): void;
-
-	/**
-	 * Create upward links from points to cells that use each point. Enables
-	 * topologically complex queries.
-	 * @param {Number} initialSize 
-	 */
-	buildLinks(initialSize?: number): void;
-
-	/**
-	 * If you know the type of cell, you may provide it to improve performances.
-	 * @param {Number} cellId 
-	 * @param cellHint 
-	 */
-	getCell(cellId: number, cellHint: any): void;
-
-	/**
-	 * Get the neighbors at an edge.
-	 * @param {Number} cellId The Id of the cell.
-	 * @param {Vector3} point1 The first point coordinate.
-	 * @param {Vector3} point2 The second point coordinate.
-	 */
-	getCellEdgeNeighbors(cellId: number, point1: Vector3, point2: Vector3): void;
-
-	/**
-	 * Get a list of point ids that define a cell.
-	 * @param {Number} cellId The Id of the cell.
-	 * @return an object made of the cellType and a subarray `cellPointIds` of the cell points.
-	 */
-	getCellPoints(cellId: number): object;
-
-	/**
-	 * Get the type of the cell
-	 * @param {Number} cellId The Id of the cell.
-	 * @return CellType The type of the cell.
-	 */
-	 getCellType(cellId: number): CellType;
-
-	/**
-	 * Get the cell array defining cells.
-	 */
-	getCells(): vtkCellArray;
-
-	/**
-	 * Get the cell array defining lines.
-	 */
-	getLines(): vtkCellArray;
-
-	/**
-	 *
-	 */
-	getLinks(): any;
-
-	/**
-	 * Determine the number of cells composing the polydata.
-	 */
-	getNumberOfCells(): number;
-
-	/**
-	 * Determine the number of lines composing the polydata.
-	 */
-	getNumberOfLines(): number;
-
-	/**
-	 * Determine the number of points composing the polydata.
-	 */
-	getNumberOfPoints(): number;
-
-	/**
-	 * Determine the number of polys composing the polydata.
-	 */
-	getNumberOfPolys(): number;
-
-	/**
-	 * Determine the number of strips composing the polydata.
-	 */
-	getNumberOfStrips(): number;
-
-	/**
-	 * Determine the number of vertices composing the polydata.
-	 */
-	getNumberOfVerts(): number;
-
-	/**
-	 * Topological inquiry to get cells using point.
-	 * @param ptId
-	 */
-	getPointCells(ptId: any): void;
-
-	/**
-	 * Get the cell array defining polys. 
-	 */
-	getPolys(): vtkCellArray;
-
-	/**
-	 * Get the cell array defining strips.
-	 */
-	getStrips(): vtkCellArray;
-
-	/**
-	 * Get the cell array defining vertices.
-	 * If there are no vertices, an empty array will be returned (convenience to
-	 * simplify traversal).
-	 */
-	getVerts(): vtkCellArray;
-
-	/**
-	 * Set the cell array defining lines. 
-	 * @param {vtkCellArray} lines The cell array defining lines.
-	 */
-	setLines(lines: vtkCellArray): boolean;
-
-	/**
-	 * Set the cell array defining polys. 
-	 * @param {vtkCellArray} polys The cell array defining polys.
-	 */
-	setPolys(polys: vtkCellArray): boolean;
-
-	/**
-	 * Set the cell array defining strips. 
-	 * @param {vtkCellArray} strips The cell array defining strips.
-	 */
-	setStrips(strips: vtkCellArray): boolean;
-
-	/**
-	 * Set the cell array defining vertices.
-	 * @param {vtkCellArray} verts The cell array defining vertices.
-	 */
-	setVerts(verts: vtkCellArray): boolean;
+  /**
+   * Create data structure that allows random access of cells.
+   */
+  buildCells(): void;
+
+  /**
+   * Create upward links from points to cells that use each point. Enables
+   * topologically complex queries.
+   * @param {Number} initialSize
+   */
+  buildLinks(initialSize?: number): void;
+
+  /**
+   * If you know the type of cell, you may provide it to improve performances.
+   * @param {Number} cellId
+   * @param cellHint
+   */
+  getCell(cellId: number, cellHint: any): void;
+
+  /**
+   * Get the neighbors at an edge.
+   * @param {Number} cellId The Id of the cell.
+   * @param {Vector3} point1 The first point coordinate.
+   * @param {Vector3} point2 The second point coordinate.
+   */
+  getCellEdgeNeighbors(cellId: number, point1: Vector3, point2: Vector3): void;
+
+  /**
+   * Get a list of point ids that define a cell.
+   * @param {Number} cellId The Id of the cell.
+   * @return an object made of the cellType and a subarray `cellPointIds` of the cell points.
+   */
+  getCellPoints(cellId: number): object;
+
+  /**
+   * Get the type of the cell
+   * @param {Number} cellId The Id of the cell.
+   * @return CellType The type of the cell.
+   */
+  getCellType(cellId: number): CellType;
+
+  /**
+   * Get the cell array defining cells.
+   */
+  getCells(): vtkCellArray;
+
+  /**
+   * Get the cell array defining lines.
+   */
+  getLines(): vtkCellArray;
+
+  /**
+   *
+   */
+  getLinks(): any;
+
+  /**
+   * Determine the number of cells composing the polydata.
+   */
+  getNumberOfCells(): number;
+
+  /**
+   * Determine the number of lines composing the polydata.
+   */
+  getNumberOfLines(): number;
+
+  /**
+   * Determine the number of points composing the polydata.
+   */
+  getNumberOfPoints(): number;
+
+  /**
+   * Determine the number of polys composing the polydata.
+   */
+  getNumberOfPolys(): number;
+
+  /**
+   * Determine the number of strips composing the polydata.
+   */
+  getNumberOfStrips(): number;
+
+  /**
+   * Determine the number of vertices composing the polydata.
+   */
+  getNumberOfVerts(): number;
+
+  /**
+   * Topological inquiry to get cells using point.
+   * @param ptId
+   */
+  getPointCells(ptId: any): void;
+
+  /**
+   * Get the cell array defining polys.
+   */
+  getPolys(): vtkCellArray;
+
+  /**
+   * Get the cell array defining strips.
+   */
+  getStrips(): vtkCellArray;
+
+  /**
+   * Get the cell array defining vertices.
+   * If there are no vertices, an empty array will be returned (convenience to
+   * simplify traversal).
+   */
+  getVerts(): vtkCellArray;
+
+  /**
+   * Set the cell array defining lines.
+   * @param {vtkCellArray} lines The cell array defining lines.
+   */
+  setLines(lines: vtkCellArray): boolean;
+
+  /**
+   * Set the cell array defining polys.
+   * @param {vtkCellArray} polys The cell array defining polys.
+   */
+  setPolys(polys: vtkCellArray): boolean;
+
+  /**
+   * Set the cell array defining strips.
+   * @param {vtkCellArray} strips The cell array defining strips.
+   */
+  setStrips(strips: vtkCellArray): boolean;
+
+  /**
+   * Set the cell array defining vertices.
+   * @param {vtkCellArray} verts The cell array defining vertices.
+   */
+  setVerts(verts: vtkCellArray): boolean;
 }
 
 /**
@@ -152,19 +149,25 @@ export interface vtkPolyData extends vtkPointSet {
  * @param model object on which data structure will be bounds (protected)
  * @param {IPolyDataInitialValues} [initialValues] (default: {})
  */
-export function extend(publicAPI: object, model: object, initialValues?: IPolyDataInitialValues): void;
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IPolyDataInitialValues
+): void;
 
 /**
  * Method used to create a new instance of vtkPolyData.
  * @param {IPolyDataInitialValues} [initialValues] for pre-setting some of its content
  */
-export function newInstance(initialValues?: IPolyDataInitialValues): vtkPolyData;
+export function newInstance(
+  initialValues?: IPolyDataInitialValues
+): vtkPolyData;
 
 /**
  * vtkPolyData is a dataset that represents a geometric structure consisting of vertices, lines, polygons, and/or strips.
  */
 export declare const vtkPolyData: {
-	newInstance: typeof newInstance,
-	extend: typeof extend,
+  newInstance: typeof newInstance;
+  extend: typeof extend;
 };
 export default vtkPolyData;

package/Common/DataModel/PolyLine.d.ts

@@ -3,51 +3,68 @@ import { Nullable, Vector2, Vector3 } from './../../types';
 import vtkCell, { ICellInitialValues } from './Cell';
 import { IIntersectWithLine } from './Line';
 
-export interface IPolyLineInitialValues extends ICellInitialValues { }
+export interface IPolyLineInitialValues extends ICellInitialValues {}
 
 export interface vtkPolyLine extends vtkCell {
+  /**
+   * Get the topological dimensional of the cell (0, 1, 2 or 3).
+   */
+  getCellDimension(): number;
 
-	/**
-	 * Get the topological dimensional of the cell (0, 1, 2 or 3).
-	 */
-	getCellDimension(): number;
-
-	/**
-	 * @param {number} t1
-	 * @param {number} t2
-	 * @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 the line.
-	 * @param {Vector3} pcoords The parametric coordinates.
-	 */
-	intersectWithLine(t1: number, t2: number, p1: Vector3, p2: Vector3, tol: number, x: Vector3, pcoords: Vector3): IIntersectWithLine;
+  /**
+   * @param {number} t1
+   * @param {number} t2
+   * @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 the line.
+   * @param {Vector3} pcoords The parametric coordinates.
+   */
+  intersectWithLine(
+    t1: number,
+    t2: number,
+    p1: Vector3,
+    p2: Vector3,
+    tol: number,
+    x: Vector3,
+    pcoords: Vector3
+  ): IIntersectWithLine;
 
   /**
    * Determine global coordinate (x[3]) from subId and parametric coordinates.
    * Also set interpolation weights. (There are two weights for the two
    * points of the line segment specified by subId)
-   * 
+   *
    * @param {number} subId
    * @param {Vector3} pcoords The parametric coordinates
    * @param {Vector3} x The global coordinate
    * @param {Vector2} weights The interpolation weights
    */
-  evaluateLocation(subId: number, pcoords: Vector3, x: Vector3, weights: Vector2): void
+  evaluateLocation(
+    subId: number,
+    pcoords: Vector3,
+    x: Vector3,
+    weights: Vector2
+  ): void;
 
   /**
    * Determine global orientation (q[3]) from subId and parametric coordinates.
    * This uses the same algorithm as vtkLine (interpolates using slerp).
    * Also set interpolation weights. (There are two weights for the two
    * points of the line segment specified by subId)
-   * 
+   *
    * @param {number} subId
    * @param {Vector3} pcoords The parametric coordinates
    * @param {Vector3} q The global orientation
    * @param {Vector2} weights The interpolation weights
    * @returns {boolean} Wether the orientation has been set in `q'
    */
-  evaluateOrientation(subId: number, pcoords: Vector3, q: quat, weights: Vector2): boolean
+  evaluateOrientation(
+    subId: number,
+    pcoords: Vector3,
+    q: quat,
+    weights: Vector2
+  ): boolean;
 
   /**
    * Returns an array containing for each pointIdx between 0 (included) and
@@ -56,14 +73,14 @@ export interface vtkPolyLine extends vtkCell {
    * In particular if tda = publicAPI.getDistancesToFirstPoint(), then tda[0] = 0
    * and tda[tda.length - 1] is the total length of the polyline
    */
-  getDistancesToFirstPoint(): number[]
+  getDistancesToFirstPoint(): number[];
 
   /**
    * Returns the subId of the segment at the given distance from the first
    * point of the polyline
    * If the distance is negative or greater than the total length of the
    * polyline, returns -1
-   * 
+   *
    * @param distance The distance from the first point of the polyline
    */
   findPointIdAtDistanceFromFirstPoint(distance: number): number;
@@ -101,22 +118,28 @@ export interface vtkPolyLine extends vtkCell {
  * @param model object on which data structure will be bounds (protected)
  * @param {IPolyLineInitialValues} [initialValues] (default: {})
  */
-export function extend(publicAPI: object, model: object, initialValues?: IPolyLineInitialValues): void;
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IPolyLineInitialValues
+): void;
 
 /**
  * Method used to create a new instance of vtkPolyLine.
  * @param {IPolyLineInitialValues} [initialValues] for pre-setting some of its content
  */
-export function newInstance(initialValues?: IPolyLineInitialValues): vtkPolyLine;
+export function newInstance(
+  initialValues?: IPolyLineInitialValues
+): vtkPolyLine;
 
-/** 
+/**
  * vtkPolyLine is a cell which representant a poly line.
- * 
+ *
  * @see vtkCell
  */
 export declare const vtkPolyLine: {
-	newInstance: typeof newInstance,
-	extend: typeof extend;
+  newInstance: typeof newInstance;
+  extend: typeof extend;
 };
 
 export default vtkPolyLine;

package/Common/DataModel/Polygon.d.ts

@@ -2,43 +2,41 @@ import { vtkObject } from './../../interfaces';
 import { Bounds, TypedArray, Vector3 } from './../../types';
 
 export interface IPolygonInitialValues {
-	firstPoint?: Vector3,
-	pointCount?: number,
-	tris?: Vector3[],
+  firstPoint?: Vector3;
+  pointCount?: number;
+  tris?: Vector3[];
 }
 
 /**
  * Different states which pointInPolygon could return.
  */
 export enum PolygonIntersectionState {
-	FAILURE,
-	OUTSIDE,
-	INSIDE,
-	INTERSECTION,
-	ON_LINE,
+  FAILURE,
+  OUTSIDE,
+  INSIDE,
+  INTERSECTION,
+  ON_LINE,
 }
 
 export interface vtkPolygon extends vtkObject {
+  /**
+   * Get the array of triangles that triangulate the polygon.
+   */
+  getPointArray(): Vector3[];
 
-	/**
-	 * Get the array of triangles that triangulate the polygon.
-	 */
-	getPointArray(): Vector3[];
-
-	/**
-	 * Set the polygon's points.
-	 * @param {Vector3[]} points The polygon's points.
-	 */
-	setPoints(points: Vector3[]): void;
-
-	/**
-	 * Triangulate this polygon. 
-	 * The output data must be accessed through `getPointArray`.
-	 * The output data contains points by group of three: each three-group
-	 * defines one triangle.
-	 */
-	triangulate(): void;
+  /**
+   * Set the polygon's points.
+   * @param {Vector3[]} points The polygon's points.
+   */
+  setPoints(points: Vector3[]): void;
 
+  /**
+   * Triangulate this polygon.
+   * The output data must be accessed through `getPointArray`.
+   * The output data contains points by group of three: each three-group
+   * defines one triangle.
+   */
+  triangulate(): void;
 }
 
 /**
@@ -57,7 +55,7 @@ export interface vtkPolygon extends vtkObject {
  */
 export function pointInPolygon(
   point: Vector3,
-  vertices: Array<number>|TypedArray,
+  vertices: Array<number> | TypedArray,
   bounds: Bounds,
   normal: Vector3
 ): PolygonIntersectionState;
@@ -69,7 +67,11 @@ export function pointInPolygon(
  * @param model object on which data structure will be bounds (protected)
  * @param {IPolygonInitialValues} [initialValues] (default: {})
  */
-export function extend(publicAPI: object, model: object, initialValues?: IPolygonInitialValues): void;
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IPolygonInitialValues
+): void;
 
 /**
  * Method used to create a new instance of vtkPolygon.
@@ -79,15 +81,14 @@ export function newInstance(initialValues?: IPolygonInitialValues): vtkPolygon;
 
 /**
  * vtkPolygon represents a 2D n-sided polygon.
- * 
+ *
  * The polygons cannot have any internal holes, and cannot self-intersect.
  * Define the polygon with n-points ordered in the counter-clockwise direction.
  * Do not repeat the last point.
  */
 export declare const vtkPolygon: {
-	newInstance: typeof newInstance,
-	extend: typeof extend;
-	// static
-
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+  // static
 };
 export default vtkPolygon;

package/Common/DataModel/SelectionNode/Constants.d.ts

@@ -1,27 +1,27 @@
 export declare enum SelectionContent {
-    GLOBALIDS = 0,
-    PEDIGREEIDS = 1,
-    VALUES = 2,
-    INDICES = 3,
-    FRUSTUM = 4,
-    LOCATIONS = 5,
-    THRESHOLDS = 6,
-    BLOCKS = 7,
-    QUERY = 8,
+  GLOBALIDS = 0,
+  PEDIGREEIDS = 1,
+  VALUES = 2,
+  INDICES = 3,
+  FRUSTUM = 4,
+  LOCATIONS = 5,
+  THRESHOLDS = 6,
+  BLOCKS = 7,
+  QUERY = 8,
 }
 
 export declare enum SelectionField {
-    CELL = 0,
-    POINT = 1,
-    FIELD = 2,
-    VERTEX = 3,
-    EDGE = 4,
-    ROW = 5,
+  CELL = 0,
+  POINT = 1,
+  FIELD = 2,
+  VERTEX = 3,
+  EDGE = 4,
+  ROW = 5,
 }
 
 declare const _default: {
-    SelectionContent: typeof SelectionContent;
-    SelectionField: typeof SelectionField;
-}
+  SelectionContent: typeof SelectionContent;
+  SelectionField: typeof SelectionField;
+};
 
 export default _default;