@kitware/vtk.js 22.6.0 → 23.0.1

package/Common/Core/MatrixBuilder.d.ts

@@ -1,5 +1,5 @@
 import { mat4 } from 'gl-matrix';
-import { TypedArray } from '@kitware/vtk.js/types';
+import { TypedArray, Vector3 } from '@kitware/vtk.js/types';
 
 declare interface Transform {
 
@@ -22,9 +22,9 @@ declare interface Transform {
 	 * Normalizes the axis of rotation then rotates the current matrix `angle`
 	 * degrees/radians around the provided axis.
 	 * @param {Number} angle 
-	 * @param {Number} axis 
+	 * @param {Vector3} axis 
 	 */
-	rotate(angle: number, axis: number): Transform
+	rotate(angle: number, axis: Vector3): Transform
 
 	/**
 	 * Rotates `angle` degrees/radians around the X axis.

package/Common/DataModel/ITKHelper.js

@@ -41,10 +41,11 @@ var ITKWASMPixelTypes = {
   VariableLengthVector: 'VariableLengthVector',
   VariableSizeMatrix: 'VariableSizeMatrix'
 };
+var vtkArrayTypeToItkComponentType = new Map([['Uint8Array', 'uint8'], ['Int8Array', 'int8'], ['Uint16Array', 'uint16'], ['Int16Array', 'int16'], ['Uint32Array', 'uint32'], ['Int32Array', 'int32'], ['Float32Array', 'float32'], ['Float64Array', 'float64']]);
 /**
- * Converts an itk.js image to a vtk.js image.
+ * Converts an itk-wasm Image to a vtk.js vtkImageData.
  *
- * Requires an itk.js image as input.
+ * Requires an itk-wasm Image as input.
  */
 
 function convertItkToVtkImage(itkImage) {
@@ -161,40 +162,35 @@ function convertItkToVtkImage(itkImage) {
 
   return imageData;
 }
-
-var vtkArrayTypeToItkComponentType = new Map([['Uint8Array', 'uint8_t'], ['Int8Array', 'int8_t'], ['Uint16Array', 'uint16_t'], ['Int16Array', 'int16_t'], ['Uint32Array', 'uint32_t'], ['Int32Array', 'int32_t'], ['Float32Array', 'float'], ['Float64Array', 'double']]);
 /**
- * Converts a vtk.js image to an itk.js image.
+ * Converts a vtk.js vtkImageData to an itk-wasm Image.
+ *
+ * Requires a vtk.js vtkImageData as input.
  *
- * Requires a vtk.js image as input.
  */
 
+
 function convertVtkToItkImage(vtkImage) {
   var copyData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  var dimension = 3;
   var itkImage = {
     imageType: {
-      dimension: 3,
-      pixelType: ITKJSPixelTypes.Scalar,
+      dimension: dimension,
+      pixelType: ITKWASMPixelTypes.Scalar,
       componentType: '',
       components: 1
     },
-    name: 'name',
+    name: 'vtkImageData',
     origin: vtkImage.getOrigin(),
     spacing: vtkImage.getSpacing(),
-    direction: {
-      data: [1, 0, 0, 0, 1, 0, 0, 0, 1]
-    },
+    direction: new Float64Array(9),
     size: vtkImage.getDimensions()
   };
-  var direction = vtkImage.getDirection();
-  var dimension = itkImage.size.length;
-  itkImage.imageType.dimension = dimension;
-  itkImage.direction.rows = dimension;
-  itkImage.direction.columns = dimension; // Transpose the direction matrix from column-major to row-major
+  var direction = vtkImage.getDirection(); // Transpose the direction matrix from column-major to row-major
 
   for (var idx = 0; idx < dimension; ++idx) {
     for (var idy = 0; idy < dimension; ++idy) {
-      itkImage.direction.data[idx + idy * dimension] = direction[idy + idx * dimension];
+      itkImage.direction[idx + idy * dimension] = direction[idy + idx * dimension];
     }
   }
 
@@ -202,10 +198,10 @@ function convertVtkToItkImage(vtkImage) {
   var vtkArray;
 
   if (pointData.getTensors() !== null) {
-    itkImage.imageType.pixelType = ITKJSPixelTypes.DiffusionTensor3D;
+    itkImage.imageType.pixelType = ITKWASMPixelTypes.DiffusionTensor3D;
     vtkArray = pointData.getTensors();
   } else if (pointData.getVectors() != null) {
-    itkImage.imageType.pixelType = ITKJSPixelTypes.Vector;
+    itkImage.imageType.pixelType = ITKWASMPixelTypes.Vector;
     vtkArray = pointData.getVectors();
   } else {
     vtkArray = pointData.getScalars();

package/Common/DataModel/ImageData.d.ts

@@ -1,5 +1,5 @@
 import { mat3, mat4, ReadonlyVec3, vec3 } from 'gl-matrix';
-import { Bounds, Vector3 } from '@kitware/vtk.js/types';
+import { Bounds, Extent, Vector3 } from '@kitware/vtk.js/types';
 import vtkDataSet, { IDataSetInitialValues } from '@kitware/vtk.js/Common/DataModel/DataSet';
 
 /**
@@ -28,29 +28,29 @@ export interface vtkImageData extends vtkDataSet {
 	 * `voxelFunc(index, bounds)` is an optional function that is called with
 	 * the `[i,j,k]` index and index `bounds`, expected to return truthy if the
 	 * data point should be counted in the histogram, and falsey if not.
-	 * @param {Number[]} worldBounds The bounds of the world.
+	 * @param {Bounds} worldBounds The bounds of the world.
 	 * @param [voxelFunc] 
 	 */
-	computeHistogram(worldBounds: number[], voxelFunc?: any): IComputeHistogram;
+	computeHistogram(worldBounds: Bounds, voxelFunc?: any): IComputeHistogram;
 
 	/**
 	 * Returns an `array[3]` of values to multiply an `[i,j,k]` index to convert
 	 * into the actual data array index, from the provided extent.
 	 * `numberOfComponents` should match the Scalar components.
 	 * @internal
-	 * @param {Number[]} extent 
+	 * @param {Extent} extent 
 	 * @param {Number} [numberOfComponents] 
 	 */
-	computeIncrements(extent: number[], numberOfComponents?: number): number[]
+	computeIncrements(extent: Extent, numberOfComponents?: number): number[]
 
 	/**
 	 * Converts an `[i,j,k]` index to the flat data array index. Returns `NaN`
 	 * if any of the i,j,k bounds are outside the data Extent.
 	 * @internal
-	 * @param {Number[]} ijk The localized `[i,j,k]` pixel array position. Float values will be rounded.
+	 * @param {Vector3} ijk The localized `[i,j,k]` pixel array position. Float values will be rounded.
 	 * @return {Number} the corresponding flattened index in the scalar array
 	 */
-	computeOffsetIndex(ijk: number[]): number;
+	computeOffsetIndex(ijk: Vector3): number;
 
 	/**
 	 * Calculates the `indexToWorld` and `worldToIndex` conversion matrices from
@@ -64,9 +64,9 @@ export interface vtkImageData extends vtkDataSet {
 	 * Returns a bounds array from a given Extent, useful if you need to
 	 * calculate the world bounds of a subset of the imageData's data.
 	 * @internal
-	 * @param {Number[]} ex 
+	 * @param {Extent} ex 
 	 */
-	extentToBounds(ex: number[]): number[];
+	extentToBounds(ex: Extent): Bounds;
 
 	/**
 	 * The Bounds of a vtkImage are returned as pairs of world coordinates
@@ -96,14 +96,14 @@ export interface vtkImageData extends vtkDataSet {
 	/**
 	 * Get the `[x,y,z]` location of the center of the imageData.
 	 */
-	getCenter(): number[];
+	getCenter(): Vector3;
 
 	/**
 	 * Get dimensions of this structured points dataset. It is the number of
 	 * points on each axis. Dimensions are computed from Extents during this
 	 * call.
 	 */
-	getDimensions(): number[];
+	getDimensions(): Vector3;
 
 	/**
 	 * Direction is a `mat3` matrix corresponding to the axes directions in
@@ -116,20 +116,20 @@ export interface vtkImageData extends vtkDataSet {
 	 * The maximal extent of the projection.
 	 * @default [0, -1, 0, -1, 0, -1]
 	 */
-	getExtent(): number[];
+	getExtent(): Extent;
 
 	/**
 	 *
 	 * @default [0, -1, 0, -1, 0, -1]
 	 */
-	getExtentByReference(): number[];
+	getExtentByReference(): Extent;
 
 	/**
 	 * Returns the data array index for the point at the provided world position.
-	 * @param {Number[]} xyz The [x,y,z] array in world coordinates.
-	 * @return {number|NaN} the corresponding pixel's index in the scalar array.
+	 * @param {Vector3} xyz The [x,y,z] array in world coordinates.
+	 * @return {number} the corresponding pixel's index in the scalar array.
 	 */
-	getOffsetIndexFromWorld(xyz: number[]): number;
+	getOffsetIndexFromWorld(xyz: Vector3): number;
 
 	/**
 	 *
@@ -144,9 +144,9 @@ export interface vtkImageData extends vtkDataSet {
 	/**
 	 * Get the world position of a data point. Index is the point's index in the
 	 * 1D data array.
-	 * @param index
+	 * @param {Number} index 
 	 */
-	getPoint(index: number): number[];
+	getPoint(index: number): Vector3;
 
 	/**
 	 * Get the origin of the dataset. The origin is the position in world
@@ -156,33 +156,33 @@ export interface vtkImageData extends vtkDataSet {
 	 * box. The origin plus spacing determine the position in space of the
 	 * points.
 	 */
-	getOrigin(): number[];
+	getOrigin(): Vector3;
 
 	/**
 	 * Get the origin of the dataset. The origin is the position in world
 	 */
-	getOriginByReference(): number[];
+	getOriginByReference(): Vector3;
 
 	/**
 	 * Returns the scalar value for the point at the provided world position, or
 	 * `NaN` if the world bounds are outside the volumeData bounds. `comp` is
 	 * the scalar component index, for multi-component scalar data.
-	 * @param {Number[]} xyz The [x,y,z] array in world coordinates.
+	 * @param {Vector3} xyz The [x,y,z] array in world coordinates.
 	 * @param {Number} [comp] The scalar component index for multi-component scalars.
 	 * @return {number|NaN} The corresponding pixel's scalar value.
 	 */
-	getScalarValueFromWorld(xyz: number[], comp?: number): number;
+	getScalarValueFromWorld(xyz: Vector3, comp?: number): number;
 
 	/**
 	 * Set the spacing [width, height, length] of the cubical cells that compose
 	 * the data set.
 	 */
-	getSpacing(): number[];
+	getSpacing(): Vector3;
 
 	/**
 	 *
 	 */
-	getSpacingByReference(): number[];
+	getSpacingByReference(): Vector3;
 
 	/**
 	 * Returns the `mat4` matrices used to convert between world and index.
@@ -201,26 +201,27 @@ export interface vtkImageData extends vtkDataSet {
 	/**
 	 * this is the fast version, requires vec3 arguments
 	 * @param {ReadonlyVec3} vin 
-	 * @param {vec3} vout 
+	 * @param {vec3} [vout] 
 	 */
-	indexToWorldVec3(vin: ReadonlyVec3, vout: vec3): vec3;
+	indexToWorldVec3(vin: ReadonlyVec3, vout?: vec3): vec3;
 
 	/**
-	 * Converts the input index vector `[i,j,k]` to world values `[x,y,z]`.
-	 * Modifies the out vector array in place, but also returns it.
+	 * Converts the input index vector `[i,j,k]` to world values `[x,y,z]`. 
+	 * If an out vector is not provided, a new one is created. If provided, it
+	 * modifies the out vector array in place, but also returns it.
 	 * @param {ReadonlyVec3} ain 
-	 * @param {vec3} aout 
+	 * @param {vec3} [aout] 
 	 */
-	indexToWorld(ain: ReadonlyVec3, aout: vec3): vec3;
+	indexToWorld(ain: ReadonlyVec3, aout?: vec3): vec3;
 
 	/**
 	 * Calculate the corresponding world bounds for the given index bounds
 	 * `[i_min, i_max, j_min, j_max, k_min, k_max]`. Modifies `out` in place if
 	 * provided, or returns a new array.
-	 * @param {Number[]} bin 
-	 * @param {Number[]} [bout] 
+	 * @param {Bounds} bin 
+	 * @param {Bounds} [bout] 
 	 */
-	indexToWorldBounds(bin: number[], bout?: number[]): number[];
+	indexToWorldBounds(bin: Bounds, bout?: Bounds): Bounds;
 
 	/**
 	 * Set the values of the extent, from `0` to `(i-1)`, etc.
@@ -230,9 +231,9 @@ export interface vtkImageData extends vtkDataSet {
 
 	/**
 	 * Set the values of the extent, from `0` to `(i-1)`, etc.
-	 * @param i
-	 * @param j
-	 * @param k
+	 * @param {Number} i 
+	 * @param {Number} j 
+	 * @param {Number} k 
 	 */
 	setDimensions(i: number, j: number, k: number): void;
 
@@ -266,9 +267,9 @@ export interface vtkImageData extends vtkDataSet {
 
 	/**
 	 * Set the extent.
-	 * @param extent 
+	 * @param {Extent} extent 
 	 */
-	setExtent(extent: number[]): boolean;
+	setExtent(extent: Extent): boolean;
 
 	/**
 	 *
@@ -308,27 +309,28 @@ export interface vtkImageData extends vtkDataSet {
 	/**
 	 * this is the fast version, requires vec3 arguments
 	 * @param vin 
-	 * @param vout 
+	 * @param [vout] 
 	 */
-	worldToIndexVec3(vin: ReadonlyVec3, vout: vec3): vec3;
+	worldToIndexVec3(vin: ReadonlyVec3, vout?: vec3): vec3;
 
 	/**
 	 * Converts the input world vector `[x,y,z]` to approximate index values
 	 * `[i,j,k]`. Should be rounded to integers before attempting to access the
-	 * index. Modifies the out vector array in place, but also returns it.
+	 * index. If an out vector is not provided, a new one is created. If provided, it
+	 * modifies the out vector array in place, but also returns it.
 	 * @param ain 
-	 * @param aout 
+	 * @param [aout] 
 	 */
-	worldToIndex(ain: ReadonlyVec3, aout: vec3): vec3;
+	worldToIndex(ain: ReadonlyVec3, aout?: vec3): vec3;
 
 	/**
 	 * Calculate the corresponding index bounds for the given world bounds
 	 * `[x_min, x_max, y_min, y_max, z_min, z_max]`. Modifies `out` in place if
 	 * provided, or returns a new array.
-	 * @param {Number[]} bin 
-	 * @param {Number[]} [bout] 
+	 * @param {Bounds} bin 
+	 * @param {Bounds} [bout] 
 	 */
-	worldToIndexBounds(bin: number[], bout?: number[]): number[];
+	worldToIndexBounds(bin: Bounds, bout?: Bounds): number[];
 }
 
 /**

package/Filters/General/ImageSliceFilter.d.ts

@@ -1,6 +1,6 @@
 import { vtkAlgorithm, vtkObject } from '@kitware/vtk.js/interfaces';
 
-/*
+/**
  * 
  */
 export interface IImageSliceFilterInitialValues {

package/Filters/General/ImageStreamline.d.ts

@@ -0,0 +1,135 @@
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import { vtkAlgorithm, vtkObject } from '@kitware/vtk.js/interfaces';
+import { Bounds, Extent, Vector2, Vector3 } from '@kitware/vtk.js/types';
+
+/**
+ * 
+ */
+export interface IImageStreamlineInitialValues {
+	integrationStep?: number,
+	maximumNumberOfSteps?: number,
+}
+
+type vtkImageStreamlineBase = vtkObject & vtkAlgorithm;
+
+export interface vtkImageStreamline extends vtkImageStreamlineBase {
+
+	/**
+	 * 
+	 * @param velArray 
+	 * @param image 
+	 * @param {Number} delT 
+	 * @param {Number[]} xyz 
+	 */
+	computeNextStep(velArray: any, image: any, delT: number, xyz: number[]): boolean;
+
+	/**
+	 * 
+	 * @param {Vector3} x 
+	 * @param {Vector3} ijk 
+	 * @param {Vector3} pcoords 
+	 * @param {Extent} extent 
+	 * @param {Vector3} spacing 
+	 * @param {Vector3} origin 
+	 * @param {Bounds} bounds 
+	 */
+	computeStructuredCoordinates(x: Vector3, ijk: Vector3, pcoords: Vector3, extent: Extent, spacing: Vector3, origin: Vector3, bounds: Bounds): boolean;
+
+	/**
+	 * Get the step length (delT) used during integration.
+	 */
+	getIntegrationStep(): number;
+
+	/**
+	 * Get the number of steps to be used in the integration. 
+	 */
+	getMaximumNumberOfSteps(): number;
+
+	/**
+	 * 
+	 * @param {Vector3} ijk 
+	 * @param {Vector2} dims 
+	 * @param {Number[]} ids 
+	 */
+	getVoxelIndices(ijk: Vector3, dims: Vector2, ids: number[]): void;
+
+	/**
+	 * 
+	 * @param {Vector3} pcoords 
+	 * @param {Number[]} sf 
+	 */
+	interpolationFunctions(pcoords: Vector3, sf: number[]): void;
+	/**
+	 *
+	 * @param inData
+	 * @param outData
+	 */
+	requestData(inData: any, outData: any): void;
+
+	/**
+	 * Set the step length (delT) used during integration.
+	 * @param {Number} integrationStep 
+	 */
+	setIntegrationStep(integrationStep: number): boolean;
+
+	/**
+	 * Set the number of steps to be used in the integration. 
+	 * Integration can terminal earlier if the streamline leaves the domain.
+	 * @param {Number} maximumNumberOfSteps 
+	 */
+	setMaximumNumberOfSteps(maximumNumberOfSteps: number): boolean;
+
+	/**
+	 * 
+	 * @param velArray 
+	 * @param {vtkImageData} image 
+	 * @param {Number[]} seed 
+	 * @param {Number} offset 
+	 */
+	streamIntegrate(velArray: any, image: vtkImageData, seed: number[], offset: number): any[];
+
+	/**
+	 * 
+	 * @param {Number[]} xyz 
+	 * @param velArray 
+	 * @param {vtkImageData} image 
+	 * @param velAtArg 
+	 */
+	vectorAt(xyz: number[], velArray: any, image: vtkImageData, velAtArg: any): boolean;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkImageStreamline characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IImageStreamlineInitialValues} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues?: IImageStreamlineInitialValues): void;
+
+/**
+ * Method used to create a new instance of vtkImageStreamline
+ * @param {IImageStreamlineInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(initialValues?: IImageStreamlineInitialValues): vtkImageStreamline;
+
+
+/**
+ * vtkImageStreamline - integrate streamlines in a vtkImageData
+ * 
+ * vtkImageStreamline is a filter that generates streamlines from a vtkImageData
+ * input over which a vector field is defined. This filter will look for vectors
+ * (i.e. getVectors()) in the input. It will then integrate these vectors, using
+ * Runge-Kutta 2, from a starting set of seeds defined by the points of the 2nd
+ * input until a specified maximum number of steps is reached or until the
+ * streamline leaves the domain.
+ *
+ * The output will be a vtkPolyData which contains a polyline for each
+ * streamline. Currently, this filter does not interpolate any input fields to
+ * the points of the streamline.
+ */
+export declare const vtkImageStreamline: {
+	newInstance: typeof newInstance;
+	extend: typeof extend;
+}
+export default vtkImageStreamline;

package/IO/Core/DataAccessHelper/HtmlDataAccessHelper.d.ts

@@ -0,0 +1,9 @@
+export interface HtmlDataAccessHelper {
+	fetchArray(instance: any, baseURL: string, array: object[], options?: object): Promise<object[]>;
+	fetchJSON(instance: any, url: string, options?: object): Promise<object>;
+	fetchText(instance: any, url: string, options?: object): Promise<string>;
+	fetchBinary(instance: any, url: string, options?: object): Promise<ArrayBuffer>;
+	fetchImage(instance: any, url: string, options?: object): Promise<HTMLImageElement>;
+}
+
+export default HtmlDataAccessHelper;

package/IO/Core/DataAccessHelper/HttpDataAccessHelper.d.ts

@@ -0,0 +1,9 @@
+export interface HttpDataAccessHelper {
+	fetchArray(instance: any, baseURL: string, array: object[], options?: object): Promise<object[]>;
+	fetchJSON(instance: any, url: string, options?: object): Promise<object>;
+	fetchText(instance: any, url: string, options?: object): Promise<string>;
+	fetchBinary(instance: any, url: string, options?: object): Promise<ArrayBuffer>;
+	fetchImage(instance: any, url: string, options?: object): Promise<HTMLImageElement>;
+}
+
+export default HttpDataAccessHelper;

package/IO/Core/DataAccessHelper/JSZipDataAccessHelper.d.ts

@@ -0,0 +1,13 @@
+interface IJSZipDataAccessHelper {
+	fetchArray(instance: any, baseURL: string, array: object[], options?: object): Promise<object[]>;
+	fetchJSON(instance: any, url: string, options?: object): Promise<object>;
+	fetchText(instance: any, url: string, options?: object): Promise<string>;
+	fetchBinary(instance: any, url: string, options?: object): Promise<ArrayBuffer>;
+	fetchImage(instance: any, url: string, options?: object): Promise<HTMLImageElement>;
+}
+
+export interface JSZipDataAccessHelper {
+	create(createOptions: object): IJSZipDataAccessHelper
+}
+
+export default JSZipDataAccessHelper;

package/IO/Core/DataAccessHelper/LiteHttpDataAccessHelper.d.ts

@@ -0,0 +1,9 @@
+export interface LiteHttpDataAccessHelper {
+	fetchArray(instance: any, baseURL: string, array: object[], options?: object): Promise<object[]>;
+	fetchJSON(instance: any, url: string, options?: object): Promise<object>;
+	fetchText(instance: any, url: string, options?: object): Promise<string>;
+	fetchBinary(instance: any, url: string, options?: object): Promise<ArrayBuffer>;
+	fetchImage(instance: any, url: string, options?: object): Promise<HTMLImageElement>;
+}
+
+export default LiteHttpDataAccessHelper;

package/IO/Core/DataAccessHelper.d.ts

@@ -0,0 +1,32 @@
+import HtmlDataAccessHelper from '@kitware/vtk.js/IO/Core/DataAccessHelper/HtmlDataAccessHelper';
+import HttpDataAccessHelper from '@kitware/vtk.js/IO/Core/DataAccessHelper/HttpDataAccessHelper';
+import JSZipDataAccessHelper from '@kitware/vtk.js/IO/Core/DataAccessHelper/JSZipDataAccessHelper';
+import LiteHttpDataAccessHelper from '@kitware/vtk.js/IO/Core/DataAccessHelper/LiteHttpDataAccessHelper';
+
+export function has(type: string): boolean;
+export function get(type?: string, options?: object): HtmlDataAccessHelper | HttpDataAccessHelper | JSZipDataAccessHelper | LiteHttpDataAccessHelper
+export function registerType(type: string, fn: any): void;
+
+export interface DataAccessHelper {
+	/**
+	 * 
+	 * @param {String} type 
+	 */
+	has(type: string): boolean;
+
+	/**
+	 * 
+	 * @param {String} type 
+	 * @param options 
+	 */
+	get(type?: string, options?: object): HtmlDataAccessHelper | HttpDataAccessHelper | JSZipDataAccessHelper | LiteHttpDataAccessHelper
+
+	/**
+	 * 
+	 * @param {String} type 
+	 * @param fn 
+	 */
+	registerType(type: string, fn: any): void;
+}
+
+export default DataAccessHelper;