@kitware/vtk.js 23.4.2 → 23.4.4

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

@@ -0,0 +1,11 @@
+export declare enum SlabTypes {
+	MIN = 0,
+	MAX = 1,
+	MEAN = 2,
+	SUM = 3,
+}
+
+declare const _default: {
+	SlabTypes: typeof SlabTypes;
+};
+export default _default;

package/Rendering/Core/ImageResliceMapper/Constants.js

@@ -0,0 +1,11 @@
+var SlabTypes = {
+  MIN: 0,
+  MAX: 1,
+  MEAN: 2,
+  SUM: 3
+};
+var Constants = {
+  SlabTypes: SlabTypes
+};
+
+export { SlabTypes, Constants as default };

package/Rendering/Core/ImageResliceMapper.d.ts

@@ -0,0 +1,245 @@
+import vtkAbstractImageMapper, { IAbstractImageMapperInitialValues } from './AbstractImageMapper';
+import vtkImageData from './../../Common/DataModel/ImageData';
+import vtkPlane from './../../Common/DataModel/Plane';
+import vtkPolyData from './../../Common/DataModel/PolyData';
+import { Bounds, Nullable, Vector3 } from './../../types';
+import { SlabTypes } from './ImageResliceMapper/Constants';
+
+
+interface ICoincidentTopology {
+	factor: number;
+	offset: number;
+}
+
+export interface IImageResliceMapperInitialValues extends IAbstractImageMapperInitialValues {
+	slabThickness?: number;
+	slabTrapezoidIntegration?: number;
+	slabType?: SlabTypes;
+	slicePlane?: vtkPlane;
+	slicePolyData?: vtkPolyData;
+}
+
+export interface vtkImageResliceMapper extends vtkAbstractImageMapper {
+
+	/**
+     * Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].
+	 * @return {Bounds} The bounds for the mapper.
+	 */
+	getBounds(): Bounds;
+
+	/**
+	 *
+	 */
+	getIsOpaque(): boolean;
+
+	/**
+	 *
+	 */
+	getResolveCoincidentTopology(): ICoincidentTopology
+
+	/**
+	 *
+	 */
+	getResolveCoincidentTopologyAsString(): ICoincidentTopology
+
+	/**
+	 *
+	 */
+	getResolveCoincidentTopologyLineOffsetParameters(): ICoincidentTopology
+
+	/**
+	 *
+	 */
+	getResolveCoincidentTopologyPointOffsetParameters(): ICoincidentTopology
+
+	/**
+	 *
+	 */
+	getResolveCoincidentTopologyPolygonOffsetFaces(): ICoincidentTopology
+
+	/**
+	 *
+	 */
+	getResolveCoincidentTopologyPolygonOffsetParameters(): ICoincidentTopology;
+
+	/**
+	 *
+	 * Get the slab thickness in world space (mm).
+	 */
+	getSlabThickness(): number;
+
+	/**
+	 *
+	 * Get whether slab trapezoid integration is enabled.
+	 */
+	getSlabTrapezoidIntegration(): number;
+
+	/**
+	 *
+	 * Get the slab composite function.
+	 */
+	getSlabType(): boolean;
+
+	/**
+	 *
+	 * Get the implicit plane used to slice the volume with.
+	 */
+	getSlicePlane(): vtkPlane;
+
+	/**
+	 *
+	 * Get the custom polydata used to slice the volume with.
+	 */
+	getSlicePolyData(): vtkPolyData;
+
+	/**
+	 *
+	 * @param {Number} factor 
+	 * @param {Number} offset 
+	 */
+	setRelativeCoincidentTopologyLineOffsetParameters(factor: number, offset: number): boolean;
+
+	/**
+	 *
+	 * @param {Number} factor 
+	 * @param {Number} offset 
+	 */
+	setRelativeCoincidentTopologyPointOffsetParameters(factor: number, offset: number): boolean;
+
+	/**
+	 *
+	 * @param {Number} factor 
+	 * @param {Number} offset 
+	 */
+	setRelativeCoincidentTopologyPolygonOffsetParameters(factor: number, offset: number): boolean;
+
+	/**
+	 *
+	 * @param resolveCoincidentTopology
+	 * @default false
+	 */
+	setResolveCoincidentTopology(resolveCoincidentTopology: boolean): boolean;
+
+	/**
+	 *
+	 * @param {Number} factor 
+	 * @param {Number} offset 
+	 */
+	setResolveCoincidentTopologyLineOffsetParameters(factor: number, offset: number): boolean;
+
+	/**
+	 *
+	 * @param {Number} factor 
+	 * @param {Number} offset 
+	 */
+	setResolveCoincidentTopologyPointOffsetParameters(factor: number, offset: number): boolean;
+
+	/**
+	 *
+	 * @param value
+	 */
+	setResolveCoincidentTopologyPolygonOffsetFaces(value: number): boolean;
+
+	/**
+	 *
+	 * @param {Number} factor 
+	 * @param {Number} offset 
+	 */
+	setResolveCoincidentTopologyPolygonOffsetParameters(factor: number, offset: number): boolean;
+
+	/**
+	 *
+	 */
+	setResolveCoincidentTopologyToDefault(): boolean;
+
+	/**
+	 *
+	 */
+	setResolveCoincidentTopologyToOff(): boolean;
+
+	/**
+	 *
+	 */
+	setResolveCoincidentTopologyToPolygonOffset(): boolean;
+
+	/**
+	 *
+	 * Enable slab slicing mode and set the slab thickness in world space (mm).
+	 * @param {Boolean} slabThickness The slab thickness in world space (mm). Default: 0. 
+	 */
+	setSlabThickness(slabThickness: number): number;
+
+	/**
+	 *
+	 * When a slab thickness larger than 0 is provided, the mapper will composite multile slices
+	 * together using different composite functions based on the slabType. When
+	 * slabTrapezoidIntegration is enabled, the first and the last slices in the slab are weighted at
+	 * half their original intensity for sum and mean slab types.
+	 * @param {Number} slabTrapezoidIntegration Enable/disable trapezoid integration for slab slicing.
+	 * Default: 0
+	 */
+	setSlabTrapezoidIntegration(slabTrapezoidIntegration: number): number;
+
+	/**
+	 *
+	 * When a slab thickness larger than 0 is provided, the mapper will composite multile slices
+	 * together using different composite functions based on the slabType. Available options are max,
+	 * min, mean and sum.
+	 * @param {SlabTypes} slabType The blend function used to composite slab slices.
+	 * Default: SlabTypes.MEAN
+	 */
+	setSlabType(slabType: SlabTypes): boolean;
+
+	/**
+	 *
+	 * The vtkImageResliceMapper provides flexibility in how the reslice source is provided. The user
+	 * can either provide an implicit vtkPlane (defined with its origin and normal), or a custom
+	 * vtkPolyData. When both sources are provided, the mapper chooses the custom polydata over the
+	 * implicit plane. When providing custom polydata as the source, it is required that the polydata
+	 * has point normals for slab slicing. When neither sources are provided, the mapper creates a
+	 * default implicit plane with normal (0, 0, 1) and origin at the mid-point of the volume's Z
+	 * bounds.
+	 * @param {vtkPlane} slicePlane The implicit plane to slice the volume with. Default: null
+	 */
+	setSlicePlane(slicePlane: vtkPlane): vtkPlane;
+
+	/**
+	 *
+	 * The vtkImageResliceMapper provides flexibility in how the reslice source is provided. The user
+	 * can either provide an implicit vtkPlane (defined with its origin and normal), or a custom
+	 * vtkPolyData. When both sources are provided, the mapper chooses the custom polydata over the
+	 * implicit plane. When providing custom polydata as the source, it is required that the polydata
+	 * has point normals for slab slicing. When neither sources are provided, the mapper creates a
+	 * default implicit plane with normal (0, 0, 1) and origin at the mid-point of the volume's Z
+	 * bounds.
+	 * @param {vtkPolyData} slicePolyData The polydata to slice the volume with. Default: null
+	 */
+	setSlicePolyData(slicePolyData: vtkPolyData): vtkPolyData;
+}
+
+/**
+ * Method use to decorate a given object (publicAPI+model) with vtkImageResliceMapper characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IImageResliceMapperInitialValues} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues?: IImageResliceMapperInitialValues): void;
+
+/**
+ * Method use to create a new instance of vtkImageResliceMapper
+ * @param {IImageResliceMapperInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(initialValues?: IImageResliceMapperInitialValues): vtkImageResliceMapper;
+
+/**
+ * vtkImageResliceMapper provides hardware accelerated slicing of 3D image data / volumes.
+ * It can be associated with a vtkImageSlice prop and placed within a Renderer.
+ *
+ * This class resolves coincident topology with the same methods as vtkMapper.
+ */
+export declare const vtkImageResliceMapper: {
+	newInstance: typeof newInstance;
+	extend: typeof extend;
+}
+export default vtkImageResliceMapper;

package/Rendering/Core/ImageResliceMapper.js

@@ -0,0 +1,70 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
+import Constants from './ImageResliceMapper/Constants.js';
+import macro from '../../macros.js';
+import vtkAbstractImageMapper from './AbstractImageMapper.js';
+import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var SlabTypes = Constants.SlabTypes;
+var staticOffsetAPI = CoincidentTopologyHelper.staticOffsetAPI,
+    otherStaticMethods = CoincidentTopologyHelper.otherStaticMethods; // ----------------------------------------------------------------------------
+// vtkImageResliceMapper methods
+// ----------------------------------------------------------------------------
+
+function vtkImageResliceMapper(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkImageResliceMapper');
+
+  publicAPI.getBounds = function () {
+    var bds = _toConsumableArray(vtkBoundingBox.INIT_BOUNDS);
+
+    var image = publicAPI.getInputData();
+
+    if (publicAPI.getSlicePolyData()) {
+      bds = publicAPI.getSlicePolyData().getBounds();
+    } else if (image) {
+      bds = image.getBounds();
+
+      if (publicAPI.getSlicePlane()) {
+        vtkBoundingBox.cutWithPlane(bds, publicAPI.getSlicePlane().getOrigin(), publicAPI.getSlicePlane().getNormal());
+      }
+    }
+
+    return bds;
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {
+  slabThickness: 0.0,
+  slabTrapezoidIntegration: 0,
+  slabType: SlabTypes.MEAN,
+  slicePlane: null,
+  slicePolyData: null
+}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+
+  vtkAbstractImageMapper.extend(publicAPI, model, initialValues);
+  macro.setGet(publicAPI, model, ['slabThickness', 'slabTrapezoidIntegration', 'slabType', 'slicePlane', 'slicePolyData']);
+  CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model); // Object methods
+
+  vtkImageResliceMapper(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkImageResliceMapper'); // ----------------------------------------------------------------------------
+
+var vtkImageResliceMapper$1 = _objectSpread(_objectSpread({
+  newInstance: newInstance,
+  extend: extend
+}, staticOffsetAPI), otherStaticMethods);
+
+export { vtkImageResliceMapper$1 as default, extend, newInstance };

package/Rendering/Core/InteractorObserver.d.ts

@@ -0,0 +1,132 @@
+import vtkRenderer from './Renderer';
+import vtkRenderWindowInteractor from './RenderWindowInteractor';
+import { vtkObject, EventHandler, vtkSubscription } from './../../interfaces';
+import { Vector3 } from './../../types';
+
+export interface vtkInteractorObserver extends vtkObject {
+  /**
+   * Invoke an interaction event.
+   * 
+   * @param args Event payload.
+   */
+  invokeInteractionEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback to be invoked when an interaction event occurs.
+   * 
+   * @param {EventHandler} cb The callback to be called.
+   * @param {Number} [priority] The priority of the event.
+   */
+  onInteractionEvent(cb: EventHandler, priority?: number): Readonly<vtkSubscription>;
+
+  /**
+   * Invoke a start interaction event.
+   * 
+   * @param args Event payload. 
+   */
+  invokeStartInteractionEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback to be invoked when a start interaction event occurs.
+   * 
+   * @param {EventHandler} cb The callback to be called. 
+   * @param {Number} [priority] The callback to be called
+   */
+  onStartInteractionEvent(cb: EventHandler, priority?: number): Readonly<vtkSubscription>;
+
+  /**
+   * Invoke an end interaction event.
+   * 
+   * @param args Event payload. 
+   */
+  invokeEndInteractionEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback to be invoked when an end interaction event occurs.
+   * 
+   * @param {EventHandler} cb The callback to be called. 
+   * @param {Number?} [priority] The callback to be called
+   */
+  onEndInteractionEvent(cb: EventHandler, priority?: number): Readonly<vtkSubscription>;
+
+  /** 
+   * Retrieve the render window interactor instance. 
+   */
+  getInteractor(): vtkRenderWindowInteractor;
+
+  /** 
+   * Get wether or not this InteractorObserver instance is enabled. 
+   */
+  getEnabled(): boolean;
+  
+  /**
+   * Enable/disable the interactor observer. Note that if you are enabling the interactor observer, an interactor instance must exists on the model.
+   * Typically you can call `setInteractor`
+   * 
+   * @param {Boolean} enable 
+   */
+  setEnabled(enable: boolean): void;
+
+  /**
+   * Set the priority.
+   * 
+   * @param {Number} priority The priority level.
+   */
+  setPriority(priority: number): void;
+
+  /**
+   * Get the priority.
+   */
+  getPriority(): number;
+
+  /**
+   * Set whether or not the interactor observer instance should process events.
+   * 
+   * @param {Boolean} processEvents 
+   */
+  setProcessEvents(processEvents: boolean): boolean;
+
+  /**
+   * Get whether or not the interactor observer instance should process events.
+   */
+  getProcessEvents(): boolean;
+
+  /**
+   * Set the interactor instance.
+   * 
+   * @param {vtkRenderWindowInteractor} interactor 
+   */
+  setInteractor(interactor: vtkRenderWindowInteractor): void;
+
+  /**
+   * Transform from world to display coordinates.
+   * 
+   * @param {vtkRenderer} renderer The vtkRenderer instance.
+   * @param {Number} x 
+   * @param {Number} y 
+   * @param {Number} z 
+   */
+  computeWorldToDisplay(
+    renderer: vtkRenderer,
+    x: number,
+    y: number,
+    z: number
+  ): Vector3;
+
+  /**
+   * Transform from display to world coordinates.
+   *
+   * @param {vtkRenderer} renderer The vtkRenderer instance.
+   * @param {Number} x 
+   * @param {Number} y 
+   * @param {Number} z 
+   */
+  computeDisplayToWorld(
+    renderer: vtkRenderer,
+    x: number,
+    y: number,
+    z: number
+  ): Vector3;
+}
+
+export default vtkInteractorObserver;

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

@@ -0,0 +1,16 @@
+export declare enum States {
+  IS_START = 0,
+  IS_NONE = 0,
+  IS_ROTATE = 1,
+  IS_PAN = 2,
+  IS_SPIN = 3,
+  IS_DOLLY = 4,
+  IS_CAMERA_POSE = 11,
+  IS_WINDOW_LEVEL = 1024,
+  IS_SLICE = 1025,
+}
+
+declare const _default: {
+  States: States;
+};
+export default _default;