@kitware/vtk.js 28.10.2 → 28.11.1

package/Rendering/Core/ImageMapper.js

@@ -1,335 +1,266 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import Constants from './ImageMapper/Constants.js';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkAbstractImageMapper from './AbstractImageMapper.js';
 import { intersectWithLineForPointPicking, intersectWithLineForCellPicking } from './AbstractImageMapper/helper.js';
 import { C as clampValue, O as multiply3x3_vect3, F as createUninitializedBounds, P as getSparseOrthogonalMatrix } from '../../Common/Core/Math/index.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; }
+const {
+  staticOffsetAPI,
+  otherStaticMethods
+} = CoincidentTopologyHelper;
+const {
+  SlicingMode
+} = Constants;
 
-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 SlicingMode = Constants.SlicingMode; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkImageMapper methods
 // ----------------------------------------------------------------------------
 
 function vtkImageMapper(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkImageMapper');
-
-  publicAPI.getSliceAtPosition = function (pos) {
-    var image = publicAPI.getCurrentImage();
-    var pos3;
-
+  publicAPI.getSliceAtPosition = pos => {
+    const image = publicAPI.getCurrentImage();
+    let pos3;
     if (pos.length === 3) {
       pos3 = pos;
     } else if (Number.isFinite(pos)) {
-      var bds = image.getBounds();
-
+      const bds = image.getBounds();
       switch (model.slicingMode) {
         case SlicingMode.X:
           pos3 = [pos, (bds[3] + bds[2]) / 2, (bds[5] + bds[4]) / 2];
           break;
-
         case SlicingMode.Y:
           pos3 = [(bds[1] + bds[0]) / 2, pos, (bds[5] + bds[4]) / 2];
           break;
-
         case SlicingMode.Z:
           pos3 = [(bds[1] + bds[0]) / 2, (bds[3] + bds[2]) / 2, pos];
           break;
       }
     }
-
-    var ijk = [0, 0, 0];
+    const ijk = [0, 0, 0];
     image.worldToIndex(pos3, ijk);
-    var ex = image.getExtent();
-
-    var _publicAPI$getClosest = publicAPI.getClosestIJKAxis(),
-        ijkMode = _publicAPI$getClosest.ijkMode;
-
-    var slice = 0;
-
+    const ex = image.getExtent();
+    const {
+      ijkMode
+    } = publicAPI.getClosestIJKAxis();
+    let slice = 0;
     switch (ijkMode) {
       case SlicingMode.I:
         slice = clampValue(ijk[0], ex[0], ex[1]);
         break;
-
       case SlicingMode.J:
         slice = clampValue(ijk[1], ex[2], ex[3]);
         break;
-
       case SlicingMode.K:
         slice = clampValue(ijk[2], ex[4], ex[5]);
         break;
-
       default:
         return 0;
     }
-
     return slice;
   };
-
-  publicAPI.setSliceFromCamera = function (cam) {
-    var fp = cam.getFocalPoint();
-
+  publicAPI.setSliceFromCamera = cam => {
+    const fp = cam.getFocalPoint();
     switch (model.slicingMode) {
       case SlicingMode.I:
       case SlicingMode.J:
       case SlicingMode.K:
         {
-          var slice = publicAPI.getSliceAtPosition(fp);
+          const slice = publicAPI.getSliceAtPosition(fp);
           publicAPI.setSlice(slice);
         }
         break;
-
       case SlicingMode.X:
         publicAPI.setSlice(fp[0]);
         break;
-
       case SlicingMode.Y:
         publicAPI.setSlice(fp[1]);
         break;
-
       case SlicingMode.Z:
         publicAPI.setSlice(fp[2]);
         break;
     }
   };
-
-  publicAPI.setXSlice = function (id) {
+  publicAPI.setXSlice = id => {
     publicAPI.setSlicingMode(SlicingMode.X);
     publicAPI.setSlice(id);
   };
-
-  publicAPI.setYSlice = function (id) {
+  publicAPI.setYSlice = id => {
     publicAPI.setSlicingMode(SlicingMode.Y);
     publicAPI.setSlice(id);
   };
-
-  publicAPI.setZSlice = function (id) {
+  publicAPI.setZSlice = id => {
     publicAPI.setSlicingMode(SlicingMode.Z);
     publicAPI.setSlice(id);
   };
-
-  publicAPI.setISlice = function (id) {
+  publicAPI.setISlice = id => {
     publicAPI.setSlicingMode(SlicingMode.I);
     publicAPI.setSlice(id);
   };
-
-  publicAPI.setJSlice = function (id) {
+  publicAPI.setJSlice = id => {
     publicAPI.setSlicingMode(SlicingMode.J);
     publicAPI.setSlice(id);
   };
-
-  publicAPI.setKSlice = function (id) {
+  publicAPI.setKSlice = id => {
     publicAPI.setSlicingMode(SlicingMode.K);
     publicAPI.setSlice(id);
   };
-
-  publicAPI.getSlicingModeNormal = function () {
-    var out = [0, 0, 0];
-    var mat3 = publicAPI.getCurrentImage().getDirection();
-
+  publicAPI.getSlicingModeNormal = () => {
+    const out = [0, 0, 0];
+    const mat3 = publicAPI.getCurrentImage().getDirection();
     switch (model.slicingMode) {
       case SlicingMode.X:
         out[0] = 1;
         break;
-
       case SlicingMode.Y:
         out[1] = 1;
         break;
-
       case SlicingMode.Z:
         out[2] = 1;
         break;
-
       case SlicingMode.I:
         multiply3x3_vect3(mat3, [1, 0, 0], out);
         break;
-
       case SlicingMode.J:
         multiply3x3_vect3(mat3, [0, 1, 0], out);
         break;
-
       case SlicingMode.K:
         multiply3x3_vect3(mat3, [0, 0, 1], out);
         break;
     }
-
     return out;
   };
-
   function computeClosestIJKAxis() {
-    var xyzMode;
-
+    let xyzMode;
     switch (model.slicingMode) {
       case SlicingMode.X:
         xyzMode = 0;
         break;
-
       case SlicingMode.Y:
         xyzMode = 1;
         break;
-
       case SlicingMode.Z:
         xyzMode = 2;
         break;
-
       default:
         model.closestIJKAxis = {
           ijkMode: model.slicingMode,
           flip: false
         };
         return;
-    } // The direction matrix in vtkImageData is the indexToWorld rotation matrix
-    // with a column-major data layout since it is stored as a WebGL matrix.
-
+    }
 
-    var direction = publicAPI.getCurrentImage().getDirection();
-    var newMatrix = getSparseOrthogonalMatrix(direction); // With {foo}Vector filled with 0s except at {foo}Mode position where it is 1
+    // The direction matrix in vtkImageData is the indexToWorld rotation matrix
+    // with a column-major data layout since it is stored as a WebGL matrix.
+    const direction = publicAPI.getCurrentImage().getDirection();
+    const newMatrix = getSparseOrthogonalMatrix(direction);
+    // With {foo}Vector filled with 0s except at {foo}Mode position where it is 1
     // We have xyzVector = (+/-) newMatrix * ijkVector
-
-    var ijkMode = 0;
-
+    let ijkMode = 0;
     for (; ijkMode < 3; ++ijkMode) {
       if (newMatrix[xyzMode + 3 * ijkMode] !== 0) {
         break;
       }
     }
-
-    var flip = newMatrix[xyzMode + 3 * ijkMode] < 0;
+    const flip = newMatrix[xyzMode + 3 * ijkMode] < 0;
     model.closestIJKAxis = {
-      ijkMode: ijkMode,
-      flip: flip
+      ijkMode,
+      flip
     };
   }
-
-  publicAPI.setSlicingMode = function (mode) {
+  publicAPI.setSlicingMode = mode => {
     if (model.slicingMode === mode) {
       return;
     }
-
     model.slicingMode = mode;
-
     if (publicAPI.getCurrentImage()) {
       computeClosestIJKAxis();
     }
-
     publicAPI.modified();
   };
-
-  publicAPI.getClosestIJKAxis = function () {
+  publicAPI.getClosestIJKAxis = () => {
     if ((model.closestIJKAxis === undefined || model.closestIJKAxis.ijkMode === SlicingMode.NONE) && publicAPI.getCurrentImage()) {
       computeClosestIJKAxis();
     }
-
     return model.closestIJKAxis;
   };
-
-  publicAPI.getBounds = function () {
-    var image = publicAPI.getCurrentImage();
-
+  publicAPI.getBounds = () => {
+    const image = publicAPI.getCurrentImage();
     if (!image) {
       return createUninitializedBounds();
     }
-
     if (!model.useCustomExtents) {
       return image.getBounds();
     }
-
-    var ex = model.customDisplayExtent.slice();
-
-    var _publicAPI$getClosest2 = publicAPI.getClosestIJKAxis(),
-        ijkMode = _publicAPI$getClosest2.ijkMode;
-
-    var nSlice = model.slice;
-
+    const ex = model.customDisplayExtent.slice();
+    const {
+      ijkMode
+    } = publicAPI.getClosestIJKAxis();
+    let nSlice = model.slice;
     if (ijkMode !== model.slicingMode) {
       // If not IJK slicing, get the IJK slice from the XYZ position/slice
       nSlice = publicAPI.getSliceAtPosition(model.slice);
     }
-
     switch (ijkMode) {
       case SlicingMode.I:
         ex[0] = nSlice;
         ex[1] = nSlice;
         break;
-
       case SlicingMode.J:
         ex[2] = nSlice;
         ex[3] = nSlice;
         break;
-
       case SlicingMode.K:
         ex[4] = nSlice;
         ex[5] = nSlice;
         break;
     }
-
     return image.extentToBounds(ex);
   };
-
   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.getCurrentImage();
-
+    let slice = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : model.slice;
+    let halfThickness = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    const image = publicAPI.getCurrentImage();
     if (!image) {
       return createUninitializedBounds();
     }
-
-    var extent = image.getSpatialExtent();
-
-    var _publicAPI$getClosest3 = publicAPI.getClosestIJKAxis(),
-        ijkMode = _publicAPI$getClosest3.ijkMode;
-
-    var nSlice = slice;
-
+    const extent = image.getSpatialExtent();
+    const {
+      ijkMode
+    } = publicAPI.getClosestIJKAxis();
+    let nSlice = slice;
     if (ijkMode !== model.slicingMode) {
       // If not IJK slicing, get the IJK slice from the XYZ position/slice
       nSlice = publicAPI.getSliceAtPosition(slice);
     }
-
     switch (ijkMode) {
       case SlicingMode.I:
         extent[0] = nSlice - halfThickness;
         extent[1] = nSlice + halfThickness;
         break;
-
       case SlicingMode.J:
         extent[2] = nSlice - halfThickness;
         extent[3] = nSlice + halfThickness;
         break;
-
       case SlicingMode.K:
         extent[4] = nSlice - halfThickness;
         extent[5] = nSlice + halfThickness;
         break;
     }
-
     return image.extentToBounds(extent);
   };
+  publicAPI.intersectWithLineForPointPicking = (p1, p2) => intersectWithLineForPointPicking(p1, p2, publicAPI);
+  publicAPI.intersectWithLineForCellPicking = (p1, p2) => intersectWithLineForCellPicking(p1, p2, publicAPI);
+  publicAPI.getCurrentImage = () => publicAPI.getInputData();
+}
 
-  publicAPI.intersectWithLineForPointPicking = function (p1, p2) {
-    return intersectWithLineForPointPicking(p1, p2, publicAPI);
-  };
-
-  publicAPI.intersectWithLineForCellPicking = function (p1, p2) {
-    return intersectWithLineForCellPicking(p1, p2, publicAPI);
-  };
-
-  publicAPI.getCurrentImage = function () {
-    return publicAPI.getInputData();
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   slicingMode: SlicingMode.NONE,
   closestIJKAxis: {
     ijkMode: SlicingMode.NONE,
@@ -338,26 +269,36 @@ var DEFAULT_VALUES = {
   renderToRectangle: false,
   sliceAtFocalPoint: false,
   preferSizeOverAccuracy: false // Whether to use halfFloat representation of float, when it is inaccurate
+};
 
-}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Build VTK API
   vtkAbstractImageMapper.extend(publicAPI, model, initialValues);
   macro.get(publicAPI, model, ['slicingMode']);
   macro.setGet(publicAPI, model, ['closestIJKAxis', 'renderToRectangle', 'sliceAtFocalPoint', 'preferSizeOverAccuracy']);
-  CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model); // Object methods
+  CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model);
 
+  // Object methods
   vtkImageMapper(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkImageMapper'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkImageMapper');
+
+// ----------------------------------------------------------------------------
 
-var vtkImageMapper$1 = _objectSpread(_objectSpread(_objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, staticOffsetAPI), otherStaticMethods), Constants);
+var vtkImageMapper$1 = {
+  newInstance,
+  extend,
+  ...staticOffsetAPI,
+  ...otherStaticMethods,
+  ...Constants
+};
 
 export { vtkImageMapper$1 as default, extend, newInstance };

package/Rendering/Core/ImageProperty/Constants.js

@@ -1,9 +1,9 @@
-var InterpolationType = {
+const InterpolationType = {
   NEAREST: 0,
   LINEAR: 1
 };
 var Constants = {
-  InterpolationType: InterpolationType
+  InterpolationType
 };
 
 export { InterpolationType, Constants as default };