@kitware/vtk.js/interfaces.d.ts

Visualization Toolkit for the Web

import vtkDataArray from './Common/Core/DataArray';
import { vtkPipelineConnection } from './types';
import { EVENT_ABORT, VOID } from './macros';

/**
 * Object returned on any subscription call
 */
export interface vtkSubscription {
	unsubscribe(): void;
}

/**
 * Basic object representing a data range
 */
export interface vtkRange {
	min: number;
	max: number;
}

/**
 * Represents a debounced function.
 */
export interface vtkDebouncedFunction {
  (...args: any) : any;
  cancel() : void;
}

export interface vtkOutputPort {
	filter: vtkAlgorithm;
}

/**
 * vtkAlgorithm API
 */
export interface vtkAlgorithm {

	/**
	 * Assign a data object as input.
	 * @param dataset The dataset object.
	 * @param {Number} [port] The port number (default 0).
	 */
	setInputData(dataset: any, port?: number): void;

	/**
	 * @param {Number} [port] The port number (default 0).
	 */
	getInputData(port?: number): any;

	/**
	 * @param outputPort
	 * @param {Number} [port] The port number (default 0).
	 */
	setInputConnection(outputPort: vtkPipelineConnection, port?: number): void;

	/**
	 * @param {Number} [port] The port number (default 0).
	 */
	getInputConnection(port?: number): vtkPipelineConnection;

	/**
	 * Add a connection to the given input port index.
	 * @param {vtkPipelineConnection} outputPort 
	 */
	addInputConnection(outputPort: vtkPipelineConnection): void;

	/**
	 * 
	 * @param dataset 
	 */
	addInputData(dataset: any): void;

	/**
	 * Get the data object that will contain the algorithm output for the given
	 * port.
	 * @param {Number} [port] The port number (default 0).
	 */
	getOutputData(port?: number): any;

	/**
	 * 
	 */
	shouldUpdate(): boolean;

	/**
	 * Get a proxy object corresponding to the given output port of this
	 * algorithm. 
	 * @param {Number} [port] The port number (default 0).
	 */
	getOutputPort(port?: number): vtkPipelineConnection;

	/**
	 * Bring this algorithm's outputs up-to-date.
	 */
	update(): void;

	/**
	 * Get the number of input ports used by the algorithm.
	 */
	getNumberOfInputPorts(): number;

	/**
	 * Get the number of output ports provided by the algorithm.
	 */
	getNumberOfOutputPorts(): number;

	/**
	 * Get the actual data array for the input array sepcified by idx.
	 * @param {Number} port (default 0)
	 */
	getInputArrayToProcess(inputPort?: number): vtkDataArray;

	/**
	 * Set the input data arrays that this algorithm will process. 
	 * @param {Number} inputPort The port number.
	 * @param {String} arrayName The name of the array.
	 * @param {String} fieldAssociation The name of the association field.
	 * @param {String} attributeType (default 'Scalars')
	 */
	setInputArrayToProcess(
		inputPort: number,
		arrayName: string,
		fieldAssociation: string,
		attributeType?: string
	): void;
}

/**
* Base vtkClass which provides MTime tracking and class infrastructure
*/
export interface vtkObject {
	
	/**
	 * Allow to check if that object was deleted (.delete() was called before).
	 * @returns true if delete() was previously called
	 */
	isDeleted(): boolean;

	/**
	 * Mark the object dirty by increasing its MTime.
	 * Such action also trigger the onModified() callbacks if any was registered.
	 * This naturally happens when you call any setXXX(value) with a different value.
	 */
	modified(): void;

	/**
	 * Method to register callback when the object is modified().
	 *
	 * @param callback function
	 * @returns subscription object so you can easily unsubscribe later on
	 */
	onModified(callback: (instance: vtkObject) => any): vtkSubscription;

	/**
	 * Return the `Modified Time` which is a monotonic increasing integer
	 * global for all vtkObjects.
	 *
	 * This allow to solve a question such as:
	 *  - Is that object created/modified after another one?
	 *  - Do I need to re-execute this filter, or not? ...
	 *
	 * @return {Number} the global modified time.
	 */
	getMTime(): number;

	/**
	 * Method to check if an instance is of a given class name.
	 * For example such method for a vtkCellArray will return true
	 * for any of the following string: ['vtkObject', 'vtkDataArray', 'vtkCellArray']
	 */
	isA(className: string): boolean;

	/**
	 * Return the instance class name.
	 */
	getClassName(): string;

	/**
	 * Generic method to set many fields at one.
	 *
	 * For example calling the following function
	 * ```js
	 * changeDetected = sphereSourceInstance.set({
	 *    phiResolution: 10,
	 *    thetaResolution: 20,
	 * });
	 * ```
	 * will be equivalent of calling
	 * ```js
	 * changeDetected += sphereSourceInstance.setPhiResolution(10);
	 * changeDetected += sphereSourceInstance.setThetaResolution(20);
	 * changeDetected = !!changeDetected;
	 * ```
	 *
	 * In case you provide other field names that do not belong to the instance,
	 * vtkWarningMacro will be used to warn you. To disable those warning,
	 * you can set `noWarning` to true.
	 *
	 * If `noFunction` is set to true, the field will be set directly on the model
	 * without calling the `set${FieldName}()` method.
	 *
	 * @param [map] (default: {}) Object capturing the set of fieldNames and associated values to set.
	 * @param [noWarning] (default: false) Boolean to disable any warning.
	 * @param [noFunctions] (default: false) Boolean to skip any function execution and rely on only setting the fields on the model.
	 * @return true if a change was actually performed. False otherwise when the value provided were equal to the ones already set inside the instance.
	 */
	set(map?: object, noWarning?: boolean, noFunction?: boolean): boolean;

	/**
	 * Extract a set of properties at once from a vtkObject.
	 *
	 * This can be convenient to pass a partial state of
	 * one object to another.
	 *
	 * ```
	 * cameraB.set(cameraA.get('position', 'viewUp', 'focalPoint'));
	 * ```
	 *
	 * @param listOfKeys set of field names that you want to retrieve. If not provided, the full model get returned as a new object.
	 * @returns a new object containing only the values of requested fields
	 */
	get(...listOfKeys: Array<string>): object;

	/**
	 * Allow to get a direct reference of a model element
	 *
	 * @param name of the field to extract from the instance model
	 * @returns model[name]
	 */
	getReferenceByName(name: string): any;

	/**
	 * Dereference any internal object and remove any subscription.
	 * It gives custom class to properly detach themselves from the DOM
	 * or any external dependency that could prevent their deletion
	 * when the GC runs.
	 */
	delete(): void;

	/**
	 * Try to extract a serializable (JSON) object of the given
	 * instance tree.
	 *
	 * Such state can then be reused to clone or rebuild a full
	 * vtkObject tree using the root vtk() function.
	 *
	 * The following example will grab mapper and dataset that are
	 * beneath the vtkActor instance as well.
	 *
	 * ```
	 * const actorStr = JSON.stringify(actor.getState());
	 * const newActor = vtk(JSON.parse(actorStr));
	 * ```
	 */
	getState(): object;

	/**
	 * Used internally by JSON.stringify to get the content to serialize.
	 * Allow to call directly JSON.stringify on the vtkObject instead of using getState before doing so.
	 *
	 * ```
	 * const actorStr = JSON.stringify(actor);
	 * const newActor = vtk(JSON.parse(actorStr));
	 * ```
	 */
	toJSON(): object;

	/**
	 * Try to copy the state of the other to ourselves by just using references.
	 *
	 * @param {vtkObject} other instance to copy the reference from
	 * @param {Boolean} [debug] (default: false) if true feedback will be provided when mismatch happen
	 */
	shallowCopy(other: vtkObject, debug?: boolean): void;
}

export interface vtkProperty {
	name: string;
	children?: vtkProperty[];
}

export interface vtkPropertyDomain {}

export type EventHandler = (...args: unknown[]) => typeof EVENT_ABORT | typeof VOID | void;