@kitware/vtk.js 30.6.0 → 30.6.2

package/Rendering/Core/Picker.d.ts

@@ -1,110 +1,114 @@
 import { Vector3, Nullable } from './../../types';
-import vtkAbstractPicker, { IAbstractPickerInitialValues } from './AbstractPicker';
+import vtkAbstractPicker, {
+  IAbstractPickerInitialValues,
+} from './AbstractPicker';
 import vtkActor from './Actor';
 import vtkMapper from './Mapper';
 import vtkProp3D from './Prop3D';
 import vtkRenderer from './Renderer';
 import { vtkSubscription } from './../../interfaces';
 
-
 export interface IPickerInitialValues extends IAbstractPickerInitialValues {
-	tolerance?: number;
-	mapperPosition?: number[];
-	actors?: vtkActor[];
-	pickedPositions?: Array<any>;
-	globalTMin?: number;
+  tolerance?: number;
+  mapperPosition?: number[];
+  actors?: vtkActor[];
+  pickedPositions?: Array<any>;
+  globalTMin?: number;
 }
 
-type OnPickChangeCallback = (pickedPositions: Vector3[]) => void
+type OnPickChangeCallback = (pickedPositions: Vector3[]) => void;
 
 export interface vtkPicker extends vtkAbstractPicker {
-
-	/**
-	 * Get a collection of all the actors that were intersected.
-	 */
-	getActors(): vtkActor[];
-
-	/**
-	 * Get the dataset that was picked (if any).
-	 */
-	getDataSet(): any;
-
-	/**
-	 * Get mapper that was picked (if any)
-	 */
-	getMapper(): Nullable<vtkMapper>;
-
-	/**
-	 * Get position in mapper (i.e., non-transformed) coordinates of pick point.
-	 */
-	getMapperPosition(): Vector3;
-
-	/**
-	 * Get position in mapper (i.e., non-transformed) coordinates of pick point.
-	 */
-	getMapperPositionByReference(): Vector3;
-
-	/**
-	 * Get a list of the points the actors returned by getActors were intersected at.
-	 */
-	getPickedPositions(): Vector3[];
-
-	/**
-	 * Get tolerance for performing pick operation.
-	 */
-	getTolerance(): number;
-
-	/**
-	 * Invoke a pick change event with the list of picked points.
-	 * This function is called internally by VTK.js and is not intended for public use.
-	 * @param {Vector3[]} pickedPositions
-	 */
-	invokePickChange(pickedPositions: Vector3[]): void;
-
-	/**
-	 * Execute the given callback when the pickChange event is fired.
-	 * The callback receives an array of picked point positions.
-	 * @param {OnPickChangeCallback}
-	 */
-	onPickChange(callback: OnPickChangeCallback): vtkSubscription;
-
-	/**
-	 * Perform pick operation with selection point provided.
-	 * @param {Vector3} selection First two values should be x-y pixel coordinate, the third is usually zero.
-	 * @param {vtkRenderer} renderer The renderer on which you want to do picking.
-	 */
-	pick(selection: Vector3, renderer: vtkRenderer): void;
-
-	/**
-	 * Perform pick operation with the provided selection and focal points.
-	 * Both point are in world coordinates.
-	 * @param {Vector3} selectionPoint
-	 * @param {Vector3} focalPoint
-	 * @param {vtkRenderer} renderer
-	 */
-	pick3DPoint(selectionPoint: Vector3, focalPoint: Vector3, renderer: vtkRenderer): void;
-
-	/**
-	 * Set position in mapper coordinates of pick point.
-	 * @param {Number} x The x coordinate.
-	 * @param {Number} y The y coordinate.
-	 * @param {Number} z The z coordinate.
-	 */
-	setMapperPosition(x: number, y: number, z: number): boolean;
-
-	/**
-	 * Set position in mapper coordinates of pick point.
-	 * @param {Vector3} mapperPosition The mapper coordinates of pick point.
-	 */
-	setMapperPositionFrom(mapperPosition: Vector3): boolean;
-
-	/**
-	 * Specify tolerance for performing pick operation. Tolerance is specified
-	 * as fraction of rendering window size. (Rendering window size is measured
-	 * across diagonal.)
-	 * @param {Number} tolerance The tolerance value.
-	 */
-	setTolerance(tolerance: number): boolean;
+  /**
+   * Get a collection of all the actors that were intersected.
+   */
+  getActors(): vtkActor[];
+
+  /**
+   * Get the dataset that was picked (if any).
+   */
+  getDataSet(): any;
+
+  /**
+   * Get mapper that was picked (if any)
+   */
+  getMapper(): Nullable<vtkMapper>;
+
+  /**
+   * Get position in mapper (i.e., non-transformed) coordinates of pick point.
+   */
+  getMapperPosition(): Vector3;
+
+  /**
+   * Get position in mapper (i.e., non-transformed) coordinates of pick point.
+   */
+  getMapperPositionByReference(): Vector3;
+
+  /**
+   * Get a list of the points the actors returned by getActors were intersected at.
+   */
+  getPickedPositions(): Vector3[];
+
+  /**
+   * Get tolerance for performing pick operation.
+   */
+  getTolerance(): number;
+
+  /**
+   * Invoke a pick change event with the list of picked points.
+   * This function is called internally by VTK.js and is not intended for public use.
+   * @param {Vector3[]} pickedPositions
+   */
+  invokePickChange(pickedPositions: Vector3[]): void;
+
+  /**
+   * Execute the given callback when the pickChange event is fired.
+   * The callback receives an array of picked point positions.
+   * @param {OnPickChangeCallback}
+   */
+  onPickChange(callback: OnPickChangeCallback): vtkSubscription;
+
+  /**
+   * Perform pick operation with selection point provided.
+   * @param {Vector3} selection First two values should be x-y pixel coordinate, the third is usually zero.
+   * @param {vtkRenderer} renderer The renderer on which you want to do picking.
+   */
+  pick(selection: Vector3, renderer: vtkRenderer): void;
+
+  /**
+   * Perform pick operation with the provided selection and focal points.
+   * Both point are in world coordinates.
+   * @param {Vector3} selectionPoint
+   * @param {Vector3} focalPoint
+   * @param {vtkRenderer} renderer
+   */
+  pick3DPoint(
+    selectionPoint: Vector3,
+    focalPoint: Vector3,
+    renderer: vtkRenderer
+  ): void;
+
+  /**
+   * Set position in mapper coordinates of pick point.
+   * @param {Number} x The x coordinate.
+   * @param {Number} y The y coordinate.
+   * @param {Number} z The z coordinate.
+   */
+  setMapperPosition(x: number, y: number, z: number): boolean;
+
+  /**
+   * Set position in mapper coordinates of pick point.
+   * @param {Vector3} mapperPosition The mapper coordinates of pick point.
+   */
+  setMapperPositionFrom(mapperPosition: Vector3): boolean;
+
+  /**
+   * Specify tolerance for performing pick operation. Tolerance is specified
+   * as fraction of rendering window size. (Rendering window size is measured
+   * across diagonal.)
+   * @param {Number} tolerance The tolerance value.
+   */
+  setTolerance(tolerance: number): boolean;
 }
 
 /**
@@ -112,31 +116,35 @@ export interface vtkPicker extends vtkAbstractPicker {
  *
  * @param publicAPI object on which methods will be bounds (public)
  * @param model object on which data structure will be bounds (protected)
- * @param {IPickerInitialValues} [initialValues] 
+ * @param {IPickerInitialValues} [initialValues]
  */
-export function extend(publicAPI: object, model: object, initialValues?: IPickerInitialValues): void;
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IPickerInitialValues
+): void;
 
 /**
- * Method use to create a new instance of vtkPicker with its focal point at the origin, 
- * and position=(0,0,1). The view up is along the y-axis, view angle is 30 degrees, 
+ * Method use to create a new instance of vtkPicker with its focal point at the origin,
+ * and position=(0,0,1). The view up is along the y-axis, view angle is 30 degrees,
  * and the clipping range is (.1,1000).
  * @param {IPickerInitialValues} [initialValues] for pre-setting some of its content
  */
 export function newInstance(initialValues?: IPickerInitialValues): vtkPicker;
 
 /**
- * vtkPicker is used to select instances of vtkProp3D by shooting 
+ * vtkPicker is used to select instances of vtkProp3D by shooting
  * a ray into a graphics window and intersecting with the actor's bounding box.
- * The ray is defined from a point defined in window (or pixel) coordinates, 
+ * The ray is defined from a point defined in window (or pixel) coordinates,
  * and a point located from the camera's position.
- * 
+ *
  * vtkPicker may return more than one vtkProp3D, since more than one bounding box may be intersected.
  * vtkPicker returns an unsorted list of props that were hit, and a list of the corresponding world points of the hits.
  * For the vtkProp3D that is closest to the camera, vtkPicker returns the pick coordinates in world and untransformed mapper space,
- * the prop itself, the data set, and the mapper. 
+ * the prop itself, the data set, and the mapper.
  * For vtkPicker the closest prop is the one whose center point (i.e., center of bounding box) projected on the view ray is closest
  * to the camera. Subclasses of vtkPicker use other methods for computing the pick point.
- * 
+ *
  * vtkPicker is used for quick geometric picking. If you desire more precise
  * picking of points or cells based on the geometry of any vtkProp3D, use the
  * subclasses vtkPointPicker or vtkCellPicker.  For hardware-accelerated
@@ -145,7 +153,7 @@ export function newInstance(initialValues?: IPickerInitialValues): vtkPicker;
  * Note that only vtkProp3D's can be picked by vtkPicker.
  */
 export declare const vtkPicker: {
-	newInstance: typeof newInstance,
-	extend: typeof extend,
+  newInstance: typeof newInstance;
+  extend: typeof extend;
 };
 export default vtkPicker;

package/Rendering/Core/PixelSpaceCallbackMapper.d.ts

@@ -3,41 +3,47 @@ import vtkCamera from './Camera';
 import vtkMapper, { IMapperInitialValues } from './Mapper';
 
 /**
- * 
+ *
  */
-export interface IPixelSpaceCallbackMapperInitialValues extends IMapperInitialValues {
-	callback?: any,
-	useZValues?: boolean;
+export interface IPixelSpaceCallbackMapperInitialValues
+  extends IMapperInitialValues {
+  callback?: any;
+  useZValues?: boolean;
 }
 
 interface IWindowSize {
-	usize: number;
-	vsize: number;
+  usize: number;
+  vsize: number;
 }
 
 export interface vtkPixelSpaceCallbackMapper extends vtkMapper {
+  /**
+   *
+   */
+  getCallback(): any;
 
-	/**
-	 * 
-	 */
-	getCallback(): any;
+  /**
+   *
+   */
+  getUseZValues(): boolean;
 
-	/**
-	 * 
-	 */
-	getUseZValues(): boolean
-	
-	/**
-	 * 
-	 * @param dataset 
-	 * @param camera 
-	 * @param aspect 
-	 * @param windowSize 
-	 * @param depthValues 
-	 */
-	invokeCallback(dataset: any, camera: vtkCamera, aspect: number, windowSize: IWindowSize, depthValues: number[]): void;
+  /**
+   *
+   * @param dataset
+   * @param camera
+   * @param aspect
+   * @param windowSize
+   * @param depthValues
+   */
+  invokeCallback(
+    dataset: any,
+    camera: vtkCamera,
+    aspect: number,
+    windowSize: IWindowSize,
+    depthValues: number[]
+  ): void;
 
-	/**
+  /**
 	 * Set the callback function the mapper will call, during the rendering
 	 * process, with the screen coords of the points in dataset. The callback
 	 * function will have the following parameters:
@@ -89,18 +95,23 @@ export interface vtkPixelSpaceCallbackMapper extends vtkMapper {
 	 * 
 	 * @param callback called with coords, camera, aspect and depthBuffer
 	 */
-	setCallback(callback: (coords: Vector3[], camera: vtkCamera, aspect: number, depthBuffer: Uint8Array) => any): boolean
-	
+  setCallback(
+    callback: (
+      coords: Vector3[],
+      camera: vtkCamera,
+      aspect: number,
+      depthBuffer: Uint8Array
+    ) => any
+  ): boolean;
 
-	/**
- 	 * Set whether or not this mapper should capture the zbuffer during 
-	 * rendering. Useful for allowing depth checks in the application code.
-	 * @param useZValues 
-	 */
-	setUseZValues(useZValues: boolean): boolean
+  /**
+   * Set whether or not this mapper should capture the zbuffer during
+   * rendering. Useful for allowing depth checks in the application code.
+   * @param useZValues
+   */
+  setUseZValues(useZValues: boolean): boolean;
 }
 
-
 /**
  * Method use to decorate a given object (publicAPI+model) with vtkPixelSpaceCallbackMapper characteristics.
  *
@@ -108,22 +119,27 @@ export interface vtkPixelSpaceCallbackMapper extends vtkMapper {
  * @param model object on which data structure will be bounds (protected)
  * @param {IPixelSpaceCallbackMapperInitialValues} [initialValues] (default: {})
  */
-export function extend(publicAPI: object, model: object, initialValues?: IPixelSpaceCallbackMapperInitialValues): void;
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IPixelSpaceCallbackMapperInitialValues
+): void;
 
 /**
  * Method use to create a new instance of vtkPixelSpaceCallbackMapper
  * @param {IPixelSpaceCallbackMapperInitialValues} [initialValues] for pre-setting some of its content
  */
-export function newInstance(initialValues?: IPixelSpaceCallbackMapperInitialValues): vtkPixelSpaceCallbackMapper;
+export function newInstance(
+  initialValues?: IPixelSpaceCallbackMapperInitialValues
+): vtkPixelSpaceCallbackMapper;
 
-
-/** 
+/**
  * vtkPixelSpaceCallbackMapper iterates over the points of its input dataset,
  * using the transforms from the active camera to compute the screen coordinates
  * of each point.
  */
 export declare const vtkPixelSpaceCallbackMapper: {
-	newInstance: typeof newInstance,
-	extend: typeof extend,
+  newInstance: typeof newInstance;
+  extend: typeof extend;
 };
 export default vtkPixelSpaceCallbackMapper;

package/Rendering/Core/PointPicker.d.ts

@@ -5,39 +5,38 @@ import vtkProp3D from './Prop3D';
 import { Nullable } from './../../types';
 
 interface IPointPickerInitialValues extends IPickerInitialValues {
-	pointId?: number;
-	pointIJK?: number[];
-	useCells?: boolean;
+  pointId?: number;
+  pointIJK?: number[];
+  useCells?: boolean;
 }
 
 export interface vtkPointPicker extends vtkPicker {
+  /**
+   *
+   */
+  getPointIJK(): number[];
 
-	/**
-	 * 
-	 */
-	getPointIJK(): number[];
+  /**
+   *
+   */
+  getPointIJKByReference(): number[];
 
-	/**
-	 * 
-	 */
-	getPointIJKByReference(): number[];
+  /**
+   * Get the id of the picked point.
+   * If PointId = -1, nothing was picked.
+   */
+  getPointId(): number;
 
-	/**
-	 * Get the id of the picked point.
-	 * If PointId = -1, nothing was picked.
-	 */
-	getPointId(): number;
+  /**
+   *
+   */
+  getUseCells(): boolean;
 
-	/**
-	 * 
-	 */
-	getUseCells(): boolean;
-
-	/**
-	 * Specify whether the point search should be based on cell points or directly on the point list.
-	 * @param useCells 
-	 */
-	setUseCells(useCells: boolean): boolean;
+  /**
+   * Specify whether the point search should be based on cell points or directly on the point list.
+   * @param useCells
+   */
+  setUseCells(useCells: boolean): boolean;
 }
 
 /**
@@ -47,27 +46,33 @@ export interface vtkPointPicker extends vtkPicker {
  * @param model object on which data structure will be bounds (protected)
  * @param {IPointPickerInitialValues} [initialValues] (default: {})
  */
-export function extend(publicAPI: object, model: object, initialValues?: IPointPickerInitialValues): void;
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IPointPickerInitialValues
+): void;
 
 /**
  * Method use to create a new instance of vtkPointPicker
  * @param {IPointPickerInitialValues} [initialValues] for pre-setting some of its content
  */
-export function newInstance(initialValues?: IPointPickerInitialValues): vtkPointPicker;
+export function newInstance(
+  initialValues?: IPointPickerInitialValues
+): vtkPointPicker;
 
-/** 
- * vtkPointPicker is used to select a point by shooting a ray into a graphics window 
- * and intersecting with actor's defining geometry - specifically its points. 
+/**
+ * vtkPointPicker is used to select a point by shooting a ray into a graphics window
+ * and intersecting with actor's defining geometry - specifically its points.
  * Beside returning coordinates, actor, and mapper, vtkPointPicker returns the id of the point
- * projecting closest onto the ray (within the specified tolerance). 
- * Ties are broken (i.e., multiple points all projecting within the tolerance along 
+ * projecting closest onto the ray (within the specified tolerance).
+ * Ties are broken (i.e., multiple points all projecting within the tolerance along
  * the pick ray) by choosing the point closest to the ray origin (i.e., closest to the eye).
- * 
+ *
  * @see [vtkPicker](./Rendering_Core_Picker.html)
  * @see [vtkCellPicker](./Rendering_Core_CellPicker.html)
  */
- export declare const vtkPointPicker: {
-	newInstance: typeof newInstance,
-	extend: typeof extend,
+export declare const vtkPointPicker: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
 };
 export default vtkPointPicker;

package/Rendering/Core/Prop/Constants.d.ts

@@ -1,9 +1,9 @@
 export declare enum CoordinateSystem {
-	WORLD = 0,
-	DISPLAY = 1,
+  WORLD = 0,
+  DISPLAY = 1,
 }
 
 declare const _default: {
-	CoordinateSystem: typeof CoordinateSystem;
+  CoordinateSystem: typeof CoordinateSystem;
 };
 export default _default;