@kitware/vtk.js 26.3.2 → 26.4.1

package/Rendering/Core/ImageArrayMapper.js

@@ -0,0 +1,242 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import macro from '../../macros.js';
+import vtkAbstractImageMapper from './AbstractImageMapper.js';
+import vtkImageMapper from './ImageMapper.js';
+import { N as createUninitializedBounds } from '../../Common/Core/Math/index.js';
+import { intersectWithLineForPointPicking, intersectWithLineForCellPicking } from './AbstractImageMapper/helper.js';
+import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.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 staticOffsetAPI = CoincidentTopologyHelper.staticOffsetAPI,
+    otherStaticMethods = CoincidentTopologyHelper.otherStaticMethods;
+var vtkErrorMacro = macro.vtkErrorMacro,
+    vtkWarningMacro = macro.vtkWarningMacro;
+var SlicingMode = vtkImageMapper.SlicingMode; // ----------------------------------------------------------------------------
+// vtkImageArrayMapper methods
+// ----------------------------------------------------------------------------
+
+function vtkImageArrayMapper(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkImageArrayMapper'); //------------------
+  // Private functions
+
+  var _computeSliceToSubSliceMap = function _computeSliceToSubSliceMap() {
+    var inputCollection = publicAPI.getInputData();
+
+    if (!inputCollection || inputCollection.empty()) {
+      // clear the map
+      if (model.sliceToSubSliceMap.length !== 0) {
+        model.sliceToSubSliceMap.length = 0;
+        publicAPI.modified();
+      }
+
+      return;
+    }
+
+    if (model.sliceToSubSliceMap.length === 0 || inputCollection.getMTime() > publicAPI.getMTime()) {
+      var perImageMap = inputCollection.map(function (image, index) {
+        var dim = image.getDimensions();
+        var out = new Array(dim[model.slicingMode]);
+
+        for (var i = 0; i < out.length; ++i) {
+          out[i] = {
+            imageIndex: index,
+            subSlice: i
+          };
+        }
+
+        return out;
+      });
+      model.sliceToSubSliceMap = perImageMap.flat();
+      publicAPI.modified();
+    }
+  };
+
+  var _superSetInputData = publicAPI.setInputData;
+  var _superSetInputConnection = publicAPI.setInputConnection; //------------------
+  // Public functions
+
+  publicAPI.setInputData = function (inputData) {
+    _superSetInputData(inputData);
+
+    _computeSliceToSubSliceMap();
+  };
+
+  publicAPI.setInputConnection = function (outputPort) {
+    var port = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+
+    _superSetInputConnection(outputPort, port);
+
+    _computeSliceToSubSliceMap();
+  };
+
+  publicAPI.getImage = function () {
+    var slice = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : publicAPI.getSlice();
+    var inputCollection = publicAPI.getInputData();
+
+    if (!inputCollection) {
+      vtkWarningMacro('No input set.');
+    } else if (slice < 0 || slice >= publicAPI.getTotalSlices()) {
+      vtkWarningMacro('Invalid slice number.');
+    } else {
+      _computeSliceToSubSliceMap();
+
+      return inputCollection.getItem(model.sliceToSubSliceMap[slice].imageIndex);
+    }
+
+    return null;
+  };
+
+  publicAPI.getBounds = function () {
+    var image = publicAPI.getCurrentImage();
+
+    if (!image) {
+      return createUninitializedBounds();
+    }
+
+    if (!model.useCustomExtents) {
+      return image.getBounds();
+    }
+
+    var ex = model.customDisplayExtent.slice(); // use sub-slice of the current image,
+    // which is the k-coordinate.
+
+    var nSlice = publicAPI.getSubSlice();
+    ex[4] = nSlice;
+    ex[5] = nSlice;
+    return image.extentToBounds(ex);
+  };
+
+  publicAPI.getBoundsForSlice = function () {
+    var slice = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : publicAPI.getSlice();
+    var halfThickness = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    var image = publicAPI.getImage(slice);
+
+    if (!image) {
+      return createUninitializedBounds();
+    }
+
+    var extent = image.getSpatialExtent();
+    var nSlice = publicAPI.getSubSlice(slice);
+    extent[4] = nSlice - halfThickness;
+    extent[5] = nSlice + halfThickness;
+    return image.extentToBounds(extent);
+  };
+
+  publicAPI.getClosestIJKAxis = function () {
+    return {
+      ijkMode: model.slicingMode,
+      flip: false
+    };
+  };
+
+  publicAPI.computeTotalSlices = function () {
+    var inputCollection = publicAPI.getInputData();
+    var collectionLength = inputCollection.getNumberOfItems();
+    var slicesCount = 0;
+
+    for (var i = 0; i < collectionLength; ++i) {
+      var image = inputCollection.getItem(i);
+
+      if (image) {
+        slicesCount += image.getDimensions()[model.slicingMode];
+      }
+    }
+
+    return slicesCount;
+  };
+
+  publicAPI.getTotalSlices = function () {
+    _computeSliceToSubSliceMap();
+
+    return model.sliceToSubSliceMap.length;
+  }; // set slice number in terms of imageIndex and subSlice number.
+
+
+  publicAPI.setSlice = function (slice) {
+    var inputCollection = publicAPI.getInputData();
+
+    if (!inputCollection) {
+      // No input is set
+      vtkWarningMacro('No input set.');
+      return;
+    }
+
+    var totalSlices = publicAPI.getTotalSlices();
+
+    if (slice >= 0 && slice < totalSlices) {
+      model.slice = slice;
+      publicAPI.modified();
+    } else {
+      vtkErrorMacro("Slice number out of range. Acceptable range is: [0, ".concat(totalSlices > 0 ? totalSlices - 1 : 0, "]slice <= totalSlices"));
+    }
+  };
+
+  publicAPI.computeSlice = function (imageIndex, subSlice) {
+    _computeSliceToSubSliceMap();
+
+    return model.sliceToSubSliceMap.findIndex(function (x) {
+      return x.imageIndex === imageIndex && x.subSlice === subSlice;
+    });
+  };
+
+  publicAPI.getImageIndex = function () {
+    var _model$sliceToSubSlic;
+
+    var slice = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : publicAPI.getSlice();
+
+    _computeSliceToSubSliceMap();
+
+    return (_model$sliceToSubSlic = model.sliceToSubSliceMap[slice]) === null || _model$sliceToSubSlic === void 0 ? void 0 : _model$sliceToSubSlic.imageIndex;
+  };
+
+  publicAPI.getSubSlice = function () {
+    var _model$sliceToSubSlic2;
+
+    var slice = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : publicAPI.getSlice();
+
+    _computeSliceToSubSliceMap();
+
+    return (_model$sliceToSubSlic2 = model.sliceToSubSliceMap[slice]) === null || _model$sliceToSubSlic2 === void 0 ? void 0 : _model$sliceToSubSlic2.subSlice;
+  };
+
+  publicAPI.getCurrentImage = function () {
+    return publicAPI.getImage(publicAPI.getSlice());
+  };
+
+  publicAPI.intersectWithLineForPointPicking = function (p1, p2) {
+    return intersectWithLineForPointPicking(p1, p2, publicAPI);
+  };
+
+  publicAPI.intersectWithLineForCellPicking = function (p1, p2) {
+    return intersectWithLineForCellPicking(p1, p2, publicAPI);
+  };
+} // ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {
+  slicingMode: SlicingMode.K,
+  sliceToSubSliceMap: []
+};
+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); // Build VTK API
+
+  macro.get(publicAPI, model, ['slicingMode']);
+  CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model); // Object methods
+
+  vtkImageArrayMapper(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkImageArrayMapper'); // ----------------------------------------------------------------------------
+
+var index = _objectSpread(_objectSpread({
+  newInstance: newInstance,
+  extend: extend
+}, staticOffsetAPI), otherStaticMethods);
+
+export { index as default, extend, newInstance };

package/Rendering/Core/ImageMapper.d.ts

@@ -1,7 +1,8 @@
 import vtkCamera from './Camera';
 import vtkAbstractMapper, { IAbstractMapperInitialValues } from './AbstractMapper';
-import { Bounds, Vector3 } from './../../types';
+import { Bounds, Nullable, Vector3 } from './../../types';
 import { SlicingMode } from './ImageMapper/Constants';
+import vtkImageData from './../../Common/DataModel/ImageData';
 
 
 interface IClosestIJKAxis {
@@ -15,10 +16,6 @@ interface ICoincidentTopology {
 }
 
 export interface IImageMapperInitialValues extends IAbstractMapperInitialValues {
-	displayExtent?: number[];
-	customDisplayExtent?: number[];
-	useCustomExtents?: boolean;
-	slice?: number;
 	closestIJKAxis?: IClosestIJKAxis;
 	renderToRectangle?: boolean;
 	sliceAtFocalPoint?: boolean;
@@ -94,20 +91,16 @@ export interface vtkImageMapper extends vtkAbstractMapper {
 	getResolveCoincidentTopologyPolygonOffsetParameters(): ICoincidentTopology;
 
 	/**
-	 * Get the slice index.
+  	 * Return currently active image. By default, there can only be one image
+	 * for this mapper, if an input is set.
 	 */
-	getSlice(): number;
+	getCurrentImage(): Nullable<vtkImageData>;
 
 	/**
 	 * Get the slice number at a focal point.
 	 */
 	getSliceAtFocalPoint(): boolean;
 
-	/**
-	 *
-	 */
-	getUseCustomExtents(): boolean;
-
 	/**
 	 *
 	 * @param {Number[]} p1 The coordinates of the first point.
@@ -128,23 +121,6 @@ export interface vtkImageMapper extends vtkAbstractMapper {
 	 */
 	setClosestIJKAxis(closestIJKAxis: IClosestIJKAxis): boolean;
 
-	/**
-	 *
-	 * @param {Number} x1 The x coordinate of the first point.
-	 * @param {Number} x2 The x coordinate of the second point.
-	 * @param {Number} y1 The y coordinate of the first point.
-	 * @param {Number} y2 The y coordinate of the second point.
-	 * @param {Number} z1 The z coordinate of the first point.
-	 * @param {Number} z2 The z coordinate of the second point.
-	 */
-	setCustomDisplayExtent(x1: number, x2: number, y1: number, y2: number, z1: number, z2: number): boolean;
-
-	/**
-	 *
-	 * @param customDisplayExtent
-	 */
-	setCustomDisplayExtentFrom(customDisplayExtent: number[]): boolean;
-
 	/**
 	 *
 	 * @param {Number} factor 
@@ -239,12 +215,6 @@ export interface vtkImageMapper extends vtkAbstractMapper {
 	 */
 	sliceAtFocalPoint(sliceAtFocalPoint: boolean): boolean;
 
-	/**
-	 * 
-	 * @param {Boolean} useCustomExtents 
-	 */
-	setUseCustomExtents(useCustomExtents: boolean): boolean;
-
 	/**
 	 * Set the slice for the X axis. 
 	 * @param {Number} id The slice index.

package/Rendering/Core/ImageMapper.js

@@ -1,11 +1,10 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import Constants from './ImageMapper/Constants.js';
 import macro from '../../macros.js';
-import vtkAbstractMapper from './AbstractMapper.js';
+import vtkAbstractImageMapper from './AbstractImageMapper.js';
+import { intersectWithLineForPointPicking, intersectWithLineForCellPicking } from './AbstractImageMapper/helper.js';
 import { C as clampValue, O as multiply3x3_vect3, N as createUninitializedBounds } from '../../Common/Core/Math/index.js';
-import vtkPlane from '../../Common/DataModel/Plane.js';
 import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
-import { vec3 } from 'gl-matrix';
 
 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; }
 
@@ -22,7 +21,7 @@ function vtkImageMapper(publicAPI, model) {
   model.classHierarchy.push('vtkImageMapper');
 
   publicAPI.getSliceAtPosition = function (pos) {
-    var image = publicAPI.getInputData();
+    var image = publicAPI.getCurrentImage();
     var pos3;
 
     if (pos.length === 3) {
@@ -133,7 +132,7 @@ function vtkImageMapper(publicAPI, model) {
 
   publicAPI.getSlicingModeNormal = function () {
     var out = [0, 0, 0];
-    var a = publicAPI.getInputData().getDirection();
+    var a = publicAPI.getCurrentImage().getDirection();
     var mat3 = [[a[0], a[1], a[2]], [a[3], a[4], a[5]], [a[6], a[7], a[8]]];
 
     switch (model.slicingMode) {
@@ -200,7 +199,7 @@ function vtkImageMapper(publicAPI, model) {
     // that its inverse is equal to its transpose. We therefore need to apply two
     // transpositions resulting in a no-op.
 
-    var a = publicAPI.getInputData().getDirection();
+    var a = publicAPI.getCurrentImage().getDirection();
     multiply3x3_vect3(a, inVec3, out);
     var maxAbs = 0.0;
     var ijkMode = -1;
@@ -235,7 +234,7 @@ function vtkImageMapper(publicAPI, model) {
 
     model.slicingMode = mode;
 
-    if (publicAPI.getInputData()) {
+    if (publicAPI.getCurrentImage()) {
       computeClosestIJKAxis();
     }
 
@@ -243,7 +242,7 @@ function vtkImageMapper(publicAPI, model) {
   };
 
   publicAPI.getClosestIJKAxis = function () {
-    if ((model.closestIJKAxis === undefined || model.closestIJKAxis.ijkMode === SlicingMode.NONE) && publicAPI.getInputData()) {
+    if ((model.closestIJKAxis === undefined || model.closestIJKAxis.ijkMode === SlicingMode.NONE) && publicAPI.getCurrentImage()) {
       computeClosestIJKAxis();
     }
 
@@ -251,7 +250,7 @@ function vtkImageMapper(publicAPI, model) {
   };
 
   publicAPI.getBounds = function () {
-    var image = publicAPI.getInputData();
+    var image = publicAPI.getCurrentImage();
 
     if (!image) {
       return createUninitializedBounds();
@@ -296,7 +295,7 @@ function vtkImageMapper(publicAPI, model) {
   publicAPI.getBoundsForSlice = function () {
     var slice = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : model.slice;
     var halfThickness = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    var image = publicAPI.getInputData();
+    var image = publicAPI.getCurrentImage();
 
     if (!image) {
       return createUninitializedBounds();
@@ -334,102 +333,16 @@ function vtkImageMapper(publicAPI, model) {
     return image.extentToBounds(extent);
   };
 
-  publicAPI.getIsOpaque = function () {
-    return true;
-  };
-
-  function doPicking(p1, p2) {
-    var imageData = publicAPI.getInputData();
-    var extent = imageData.getExtent(); // Slice origin
-
-    var ijk = [extent[0], extent[2], extent[4]];
-
-    var _publicAPI$getClosest4 = publicAPI.getClosestIJKAxis(),
-        ijkMode = _publicAPI$getClosest4.ijkMode;
-
-    var nSlice = model.slice;
-
-    if (ijkMode !== model.slicingMode) {
-      // If not IJK slicing, get the IJK slice from the XYZ position/slice
-      nSlice = publicAPI.getSliceAtPosition(nSlice);
-    }
-
-    ijk[ijkMode] += nSlice;
-    var worldOrigin = [0, 0, 0];
-    imageData.indexToWorld(ijk, worldOrigin); // Normal computation
-
-    ijk[ijkMode] += 1;
-    var worldNormal = [0, 0, 0];
-    imageData.indexToWorld(ijk, worldNormal);
-    worldNormal[0] -= worldOrigin[0];
-    worldNormal[1] -= worldOrigin[1];
-    worldNormal[2] -= worldOrigin[2];
-    vec3.normalize(worldNormal, worldNormal);
-    var intersect = vtkPlane.intersectWithLine(p1, p2, worldOrigin, worldNormal);
-
-    if (intersect.intersection) {
-      var point = intersect.x;
-      var absoluteIJK = [0, 0, 0];
-      imageData.worldToIndex(point, absoluteIJK); // `t` is the parametric position along the line
-      // defined in Plane.intersectWithLine
-
-      return {
-        t: intersect.t,
-        absoluteIJK: absoluteIJK
-      };
-    }
-
-    return null;
-  }
-
   publicAPI.intersectWithLineForPointPicking = function (p1, p2) {
-    var pickingData = doPicking(p1, p2);
-
-    if (pickingData) {
-      var imageData = publicAPI.getInputData();
-      var extent = imageData.getExtent(); // Get closer integer ijk
-      // NB: point picking means closest slice, means rounding
-
-      var ijk = [Math.round(pickingData.absoluteIJK[0]), Math.round(pickingData.absoluteIJK[1]), Math.round(pickingData.absoluteIJK[2])]; // Are we outside our actual extent
-
-      if (ijk[0] < extent[0] || ijk[0] > extent[1] || ijk[1] < extent[2] || ijk[1] > extent[3] || ijk[2] < extent[4] || ijk[2] > extent[5]) {
-        return null;
-      }
-
-      return {
-        t: pickingData.t,
-        ijk: ijk
-      };
-    }
-
-    return null;
+    return intersectWithLineForPointPicking(p1, p2, publicAPI);
   };
 
   publicAPI.intersectWithLineForCellPicking = function (p1, p2) {
-    var pickingData = doPicking(p1, p2);
-
-    if (pickingData) {
-      var imageData = publicAPI.getInputData();
-      var extent = imageData.getExtent();
-      var absIJK = pickingData.absoluteIJK; // Get closer integer ijk
-      // NB: cell picking means closest voxel, means flooring
-
-      var ijk = [Math.floor(absIJK[0]), Math.floor(absIJK[1]), Math.floor(absIJK[2])]; // Are we outside our actual extent
-
-      if (ijk[0] < extent[0] || ijk[0] > extent[1] - 1 || ijk[1] < extent[2] || ijk[1] > extent[3] - 1 || ijk[2] < extent[4] || ijk[2] > extent[5] - 1) {
-        return null;
-      } // Parametric coordinates within cell
-
-
-      var pCoords = [absIJK[0] - ijk[0], absIJK[1] - ijk[1], absIJK[2] - ijk[2]];
-      return {
-        t: pickingData.t,
-        ijk: ijk,
-        pCoords: pCoords
-      };
-    }
+    return intersectWithLineForCellPicking(p1, p2, publicAPI);
+  };
 
-    return null;
+  publicAPI.getCurrentImage = function () {
+    return publicAPI.getInputData();
   };
 } // ----------------------------------------------------------------------------
 // Object factory
@@ -437,10 +350,6 @@ function vtkImageMapper(publicAPI, model) {
 
 
 var DEFAULT_VALUES = {
-  displayExtent: [0, 0, 0, 0, 0, 0],
-  customDisplayExtent: [0, 0, 0, 0],
-  useCustomExtents: false,
-  slice: 0,
   slicingMode: SlicingMode.NONE,
   closestIJKAxis: {
     ijkMode: SlicingMode.NONE,
@@ -454,10 +363,9 @@ function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
 
-  vtkAbstractMapper.extend(publicAPI, model, initialValues);
+  vtkAbstractImageMapper.extend(publicAPI, model, initialValues);
   macro.get(publicAPI, model, ['slicingMode']);
-  macro.setGet(publicAPI, model, ['slice', 'closestIJKAxis', 'useCustomExtents', 'renderToRectangle', 'sliceAtFocalPoint']);
-  macro.setGetArray(publicAPI, model, ['customDisplayExtent'], 4);
+  macro.setGet(publicAPI, model, ['closestIJKAxis', 'renderToRectangle', 'sliceAtFocalPoint']);
   CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model); // Object methods
 
   vtkImageMapper(publicAPI, model);

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;