@kitware/vtk.js 23.4.3 → 23.4.4

package/Common/DataModel/Collection.d.ts

@@ -0,0 +1,118 @@
+import { vtkObject } from './../../interfaces';
+import { Nullable } from './../../types';
+
+/**
+ *
+ */
+export interface ICollectionInitialValues {
+	collection?: vtkObject[];
+}
+
+
+export interface vtkCollection extends vtkObject {
+
+	/**
+	 * Add item (vtkObject) to the collection
+	 * @param {vtkObject} item item to be added to the collection
+	 */
+  	addItem(item: vtkObject): void;
+
+	/**
+	 * Add item (vtkObject) to the collection _at_ the given index.
+	 * This differs from VTK-C++ where insertItem inserts at position
+	 * after the provided index value.
+	 * @param {number} idx index where the new item should be inserted.
+	 * @param {vtkObject} item item to be inserted
+	 */
+	insertItem(idx: number, item: vtkObject): void;
+
+	/**
+	 * Replace an existing item (vtkObject) with a new one
+	 * @param {number} idx index of item to be replaced
+	 * @param {vtkObject} item
+	 */
+	replaceItem(idx: number, item: vtkObject): void;
+
+	/**
+	 * Remove an existing item from the collection
+	 * @param {number|vtkObject} inValue index or reference of an item to be removed
+	 */
+	removeItem(inValue: number|vtkObject): void;
+
+	/**
+	 * Remove all items from the collection
+	 */
+	removeAllItems(): void;
+
+	/**
+	 * Check if a provided item is already present in the collection
+	 */
+	isItemPresent(item: vtkObject): boolean;
+
+	/**
+	 * Get the total number of items in the collection
+	 */
+	getNumberOfItems(): number;
+
+	/**
+	 * Check if the collection is empty
+	 */
+	empty(): boolean;
+
+	/**
+	 * get the current item and provided index, returns null if index is out of bounds
+	 */
+	getItem(idx: number): Nullable<vtkObject>;
+
+	/**
+	 * Execute a passed function on every item in the collection
+	 * @param callbackfn callback function to be executed on every item in the collection
+	 */
+	forEach<T>(callbackfn: (value: T, index: number, array: readonly T[]) => void): void;
+
+	/**
+	 * Execute a passed function on every item in the collection, in order to calculate an aggregated return value.
+	 * @param callbackfn callback function to be used for aggregating a single value from each item in the collection
+	 * @param initialValue starting value to calculate aggregation
+	 */
+	reduce<T>(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T, initialValue: T): T;
+
+	/**
+	 * Similar to forEach, but returns an array of resulting values.
+	 * @param callbackfn callback function to execute on each item in the collection, that returns a value.
+	 */
+	map<T>(callbackfn: (value: T, index: number, array: readonly T[]) => void): void;
+
+	/**
+	 * Check each element for modified time and update the collection's
+	 * MTime to the latest timestamp from individual items in the collection.
+	 */
+	updateMTimeWithElements(): void;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkCollection characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {ICollectionInitialValues} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues? : ICollectionInitialValues): void;
+
+/**
+ * Method used to create a new instance of vtkCollection.
+ * @param {ICollectionInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(initialValues? : ICollectionInitialValues): vtkCollection;
+
+/**
+ * vtkCollection is a container of multiple vtkObject items.
+ * This can be useful for encapsulating multiple vtkObjects such as images
+ * into a single vtkObject (vtkCollection instance) to be passed as input
+ * to other filters and mappers as a single unit.
+ */
+export declare const vtkCollection: {
+	newInstance: typeof newInstance;
+	extend: typeof extend;
+};
+export default vtkCollection;

package/Common/DataModel/Collection.js

@@ -0,0 +1,113 @@
+import macro from '../../macros.js';
+
+var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+// vtkCollection methods
+// ----------------------------------------------------------------------------
+
+function vtkCollection(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkCollection');
+
+  publicAPI.addItem = function (item) {
+    model.collection.push(item);
+    publicAPI.modified();
+  };
+
+  publicAPI.insertItem = function (idx, item) {
+    if (idx < 0 || model.collection.length < idx) {
+      vtkErrorMacro('idx out of bounds for insertion.');
+    }
+
+    model.collection.splice(idx, 0, item);
+    publicAPI.modified();
+  };
+
+  publicAPI.replaceItem = function (idx, item) {
+    model.collection.splice(idx, 1, item);
+    publicAPI.modified();
+  };
+
+  publicAPI.removeItem = function (inValue) {
+    var idx = typeof inValue === 'number' ? inValue : model.collection.indexOf(inValue);
+
+    if (idx >= 0 && idx < model.collection.length) {
+      model.collection.splice(idx, 1);
+      publicAPI.modified();
+    } else {
+      vtkErrorMacro('idx out of bounds for removeItem.');
+    }
+  };
+
+  publicAPI.removeAllItems = function () {
+    model.collection = [];
+    publicAPI.modified();
+  };
+
+  publicAPI.isItemPresent = function (item) {
+    return model.collection.includes(item);
+  };
+
+  publicAPI.getNumberOfItems = function () {
+    return model.collection.length;
+  };
+
+  publicAPI.empty = function () {
+    return model.collection.length === 0;
+  };
+
+  publicAPI.getItem = function (idx) {
+    return model.collection[idx];
+  };
+
+  publicAPI.forEach = function (ftor) {
+    model.collection.forEach(ftor); // Call modified() for the collection, since ftor could have modified the elements.
+
+    publicAPI.updateMTimeWithElements();
+  };
+
+  publicAPI.reduce = function (ftor, initialValue) {
+    return model.collection.reduce(ftor, initialValue);
+  };
+
+  publicAPI.map = function (ftor) {
+    return model.collection.map(ftor);
+  };
+
+  publicAPI.updateMTimeWithElements = function () {
+    var maxMTimeOfItems = 0; // we expect time values to be positive numbers
+
+    for (var i = 0; i < model.collection.length; ++i) {
+      var elem = model.collection[i];
+      maxMTimeOfItems = Math.max(maxMTimeOfItems, elem.getMTime());
+    }
+
+    if (maxMTimeOfItems > publicAPI.getMTime()) {
+      publicAPI.modified();
+    }
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {
+  collection: []
+}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues); // Object methods
+
+  macro.obj(publicAPI, model); // Object specific methods
+
+  vtkCollection(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkCollection'); // ----------------------------------------------------------------------------
+
+var index = {
+  newInstance: newInstance,
+  extend: extend
+};
+
+export { index as default, extend, newInstance };

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

@@ -0,0 +1,27 @@
+export declare enum FieldAssociations {
+	FIELD_ASSOCIATION_POINTS = 0,
+	FIELD_ASSOCIATION_CELLS = 1,
+	FIELD_ASSOCIATION_NONE = 2,
+	FIELD_ASSOCIATION_POINTS_THEN_CELLS = 3,
+	FIELD_ASSOCIATION_VERTICES = 4,
+	FIELD_ASSOCIATION_EDGES = 5,
+	FIELD_ASSOCIATION_ROWS = 6,
+	NUMBER_OF_ASSOCIATIONS = 7,
+}
+
+export declare enum FieldDataTypes {
+  UNIFORM = 0,
+  DATA_OBJECT_FIELD = 0,
+  COORDINATE = 1,
+  POINT_DATA = 1,
+  POINT = 2,
+  POINT_FIELD_DATA = 2, 
+  CELL = 3,
+  CELL_FIELD_DATA = 3,
+  VERTEX = 4,
+  VERTEX_FIELD_DATA = 4,
+  EDGE = 5,
+  EDGE_FIELD_DATA = 5,
+  ROW = 6,
+  ROW_DATA = 6,
+}

package/Common/DataModel/EdgeLocator.d.ts

@@ -0,0 +1,79 @@
+import { Nullable } from './../../types';
+
+/**
+ *
+ */
+export interface IEdgeLocatorInitialValues {
+	oriented?: boolean;
+}
+
+export interface IEdge<T = unknown> {
+	key: number;
+	edgeId: number;
+	value?: T;
+}
+
+export interface vtkEdgeLocator {
+	/**
+	 * Remove all the edges previously added.
+	 */
+	 initialize(): void;
+
+	/**
+	 * Returns the inserted edge or null if no edge was inserted.
+	 * @param {Number} pointId0 Edge first point id
+	 * @param {Number} pointId1 Edge last point id
+	 * @return {IEdge|null} an edge object ({ key, edgeId, value }) or null
+	 */
+	isInsertedEdge<T = unknown>(pointId0: number, pointId1: number): Nullable<IEdge<T>>;
+
+	/**
+	 * Insert edge if it does not already exist.
+	 * Returns the existing or newly inserted edge.
+	 *
+	 * @param {Number} pointId0 Edge first point id
+	 * @param {Number} pointId1 Edge last point id
+	 * @param {unknown} value Optional value option
+	 * @return {IEdge|null} an edge object ({ key, edgeId, value }) or null
+	 * @see insertEdge()
+	 * @see isInsertedEdge()
+	 */
+	insertUniqueEdge<T>(pointId0: number, pointId1: number, value?: T): IEdge<T>;
+
+	/**
+	 * Insert edge. If the edge already exists, it is overwritten by this
+	 * new edge. You may verify that the edge did not previously exist with
+	 * `isInsertedEdge()`.
+	 * Returns the newly inserted edge.
+	 * @param {Number} pointId0 Edge first point id
+	 * @param {Number} pointId1 Edge last point id
+	 * @param {unknown} value Optional value option
+	 * @return {Edge|null} an edge object ({ key, edgeId, value }) or null
+	 * @see isInsertedEdge
+	 * @see insertUniqueEdge
+	 */
+	insertEdge<T>(pointId0: number, pointId1: number, value?: T): IEdge<T>;
+}
+
+// ----------------------------------------------------------------------------
+// Static API
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+
+/**
+ * Method use to create a new instance of vtkEdgeLocator
+ * @param {IEdgeLocatorInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+	initialValues?: IEdgeLocatorInitialValues
+): vtkEdgeLocator;
+
+/**
+ * vtkEdgeLocator
+ */
+export declare const vtkEdgeLocator: {
+	newInstance: typeof newInstance;
+};
+
+export default vtkEdgeLocator;

package/Common/DataModel/EdgeLocator.js

@@ -0,0 +1,85 @@
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+
+var EdgeLocator = /*#__PURE__*/function () {
+  function EdgeLocator() {
+    var oriented = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+
+    _classCallCheck(this, EdgeLocator);
+
+    this.oriented = oriented;
+    this.edgeMap = new Map();
+  }
+
+  _createClass(EdgeLocator, [{
+    key: "initialize",
+    value: function initialize() {
+      this.edgeMap.clear();
+    }
+  }, {
+    key: "computeEdgeKey",
+    value: function computeEdgeKey(pointId0, pointId1) {
+      return this.oriented || pointId0 < pointId1 ? // Cantor pairing function:
+      0.5 * (pointId0 * pointId1) * (pointId0 * pointId1 + 1) + pointId1 : 0.5 * (pointId1 * pointId0) * (pointId1 * pointId0 + 1) + pointId0;
+    }
+  }, {
+    key: "insertUniqueEdge",
+    value: function insertUniqueEdge(pointId0, pointId1, newEdgeValue) {
+      // Generate a unique key
+      var key = this.computeEdgeKey(pointId0, pointId1);
+      var node = this.edgeMap.get(key);
+
+      if (!node) {
+        // Didn't find key, so add a new edge entry
+        node = {
+          key: key,
+          edgeId: this.edgeMap.size,
+          value: newEdgeValue
+        };
+        this.edgeMap.set(key, node);
+      }
+
+      return node;
+    }
+  }, {
+    key: "insertEdge",
+    value: function insertEdge(pointId0, pointId1, newEdgeValue) {
+      // Generate a unique key
+      var key = this.computeEdgeKey(pointId0, pointId1);
+      var node = {
+        key: key,
+        edgeId: this.edgeMap.size,
+        value: newEdgeValue
+      };
+      this.edgeMap.set(key, node);
+      return node;
+    }
+  }, {
+    key: "isInsertedEdge",
+    value: function isInsertedEdge(pointId0, pointId1) {
+      var key = this.computeEdgeKey(pointId0, pointId1);
+      return this.edgeMap.get(key);
+    }
+  }], [{
+    key: "getEdgePointIds",
+    value: function getEdgePointIds(node) {
+      var n = 0.5 * (-1 + Math.sqrt(8 * node.key + 1));
+      var pointId0 = node.key - 0.5 * (n + 1) * n;
+      var pointId1 = n - pointId0;
+      return [pointId0, pointId1];
+    }
+  }]);
+
+  return EdgeLocator;
+}();
+
+function newInstance() {
+  var initialValues = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return new EdgeLocator(initialValues.oriented);
+}
+
+var vtkEdgeLocator = {
+  newInstance: newInstance
+};
+
+export { vtkEdgeLocator as default };

package/Common/DataModel/ITKHelper.d.ts

@@ -0,0 +1,54 @@
+import vtkPolyData from './PolyData';
+import vtkImageData from './ImageData';
+
+export interface IOptions {
+	pointDataName?: string;
+	scalarArrayName?: string;
+	cellDataName?: string;
+}
+
+/**
+ * Converts an itk-wasm Image to a vtk.js vtkImageData.
+ * Requires an itk-wasm Image as input.
+ * @param itkImage 
+ * @param {IOptions} [options] 
+ */
+export function convertItkToVtkImage(itkImage: any, options?: IOptions): vtkImageData;
+
+/**
+ * Converts a vtk.js vtkImageData to an itk-wasm Image.
+ * Requires a vtk.js vtkImageData as input.
+ * @param {vtkImageData} vtkImage 
+ * @param {IOptions} [options] 
+ */
+export function convertVtkToItkImage(vtkImage: vtkImageData, options?: IOptions): any;
+
+/**
+ * Converts an itk-wasm PolyData to a vtk.js vtkPolyData.
+ * Requires an itk-wasm PolyData as input.
+ * @param itkPolyData 
+ * @param {IOptions} [options] 
+ */
+export function convertItkToVtkPolyData(itkPolyData: any, options?: IOptions): vtkPolyData;
+
+/**
+ * Converts a vtk.js vtkPolyData to an itk-wasm PolyData.
+ * Requires a vtk.js vtkPolyData as input.
+ * 
+ * @param {vtkPolyData} polyData 
+ * @param {IOptions} [options] 
+ */
+export function convertVtkToItkPolyData(polyData: vtkPolyData, options?: IOptions): any;
+
+
+/** 
+ * vtkITKHelper is a helper which provides a set of functions to work with
+ * itk-wasm module.
+ */
+export declare const vtkITKHelper: {
+	convertItkToVtkImage: typeof convertItkToVtkImage,
+	convertVtkToItkImage: typeof convertVtkToItkImage,
+	convertItkToVtkPolyData: typeof convertItkToVtkPolyData,
+	convertVtkToItkPolyData: typeof convertVtkToItkPolyData,
+};
+export default vtkITKHelper;