284 lines
7.8 KiB
TypeScript
284 lines
7.8 KiB
TypeScript
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;
|