@kitware/vtk.js 28.10.2 → 28.11.1

package/Proxy/Representations/SliceRepresentationProxy.js

@@ -1,39 +1,36 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkImageSlice from '../../Rendering/Core/ImageSlice.js';
 import vtkImageMapper from '../../Rendering/Core/ImageMapper.js';
 import vtkAbstractRepresentationProxy from '../Core/AbstractRepresentationProxy.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; }
+// ----------------------------------------------------------------------------
 
 function sum(a, b) {
   return a + b;
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
 function mean() {
   for (var _len = arguments.length, array = new Array(_len), _key = 0; _key < _len; _key++) {
     array[_key] = arguments[_key];
   }
-
   return array.reduce(sum, 0) / array.length;
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
 function updateDomains(dataset, dataArray, model, updateProp) {
-  var dataRange = dataArray.getRange();
-  var spacing = dataset.getSpacing();
-  var bounds = dataset.getBounds();
-  var extent = dataset.getExtent();
-  var sliceMin;
-  var sliceMax;
-  var stepVal;
-  var axisIndex;
-  var sliceMode = model.mapper.getSlicingMode();
-  var sliceModeLabel = 'IJKXYZ'[sliceMode];
-
+  const dataRange = dataArray.getRange();
+  const spacing = dataset.getSpacing();
+  const bounds = dataset.getBounds();
+  const extent = dataset.getExtent();
+  let sliceMin;
+  let sliceMax;
+  let stepVal;
+  let axisIndex;
+  const sliceMode = model.mapper.getSlicingMode();
+  const sliceModeLabel = 'IJKXYZ'[sliceMode];
   switch (sliceMode) {
     case vtkImageMapper.SlicingMode.I:
     case vtkImageMapper.SlicingMode.J:
@@ -43,7 +40,6 @@ function updateDomains(dataset, dataArray, model, updateProp) {
       sliceMax = extent[axisIndex * 2 + 1];
       stepVal = 1;
       break;
-
     case vtkImageMapper.SlicingMode.X:
     case vtkImageMapper.SlicingMode.Y:
     case vtkImageMapper.SlicingMode.Z:
@@ -51,16 +47,14 @@ function updateDomains(dataset, dataArray, model, updateProp) {
         axisIndex = 'XYZ'.indexOf(sliceModeLabel);
         sliceMin = bounds[axisIndex * 2];
         sliceMax = bounds[axisIndex * 2 + 1];
-
-        var _model$mapper$getClos = model.mapper.getClosestIJKAxis(),
-            ijkMode = _model$mapper$getClos.ijkMode;
-
+        const {
+          ijkMode
+        } = model.mapper.getClosestIJKAxis();
         stepVal = spacing[ijkMode];
       }
       break;
   }
-
-  var propToUpdate = {
+  const propToUpdate = {
     slice: {
       domain: {
         min: sliceMin,
@@ -91,201 +85,184 @@ function updateDomains(dataset, dataArray, model, updateProp) {
     windowWidth: propToUpdate.windowWidth.domain.max,
     windowLevel: Math.floor(mean(propToUpdate.windowLevel.domain.min, propToUpdate.windowLevel.domain.max))
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // vtkSliceRepresentationProxy methods
 // ----------------------------------------------------------------------------
 
-
 function vtkSliceRepresentationProxy(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkSliceRepresentationProxy');
   model.mapper = vtkImageMapper.newInstance();
   model.actor = vtkImageSlice.newInstance();
-  model.property = model.actor.getProperty(); // connect rendering pipeline
+  model.property = model.actor.getProperty();
 
+  // connect rendering pipeline
   model.actor.setMapper(model.mapper);
   model.actors.push(model.actor);
-
   function setInputData(inputDataset) {
-    var state = updateDomains(inputDataset, publicAPI.getDataArray(), model, publicAPI.updateProxyProperty);
-    publicAPI.set(state); // Init slice location
-
-    var bounds = inputDataset.getBounds();
-    var extent = inputDataset.getExtent();
+    const state = updateDomains(inputDataset, publicAPI.getDataArray(), model, publicAPI.updateProxyProperty);
+    publicAPI.set(state);
 
+    // Init slice location
+    const bounds = inputDataset.getBounds();
+    const extent = inputDataset.getExtent();
     switch (model.mapper.getSlicingMode()) {
       case vtkImageMapper.SlicingMode.I:
         publicAPI.setSlice(Math.floor(mean(extent[0], extent[1])));
         break;
-
       case vtkImageMapper.SlicingMode.J:
         publicAPI.setSlice(Math.floor(mean(extent[2], extent[3])));
         break;
-
       case vtkImageMapper.SlicingMode.K:
         publicAPI.setSlice(Math.floor(mean(extent[4], extent[5])));
         break;
-
       case vtkImageMapper.SlicingMode.X:
         publicAPI.setSlice(mean(bounds[0], bounds[1]));
         break;
-
       case vtkImageMapper.SlicingMode.Y:
         publicAPI.setSlice(mean(bounds[2], bounds[3]));
         break;
-
       case vtkImageMapper.SlicingMode.Z:
         publicAPI.setSlice(mean(bounds[4], bounds[5]));
         break;
     }
-  } // Keep things updated
-
+  }
 
+  // Keep things updated
   model.sourceDependencies.push(model.mapper);
   model.sourceDependencies.push({
-    setInputData: setInputData
-  }); // keeps the slicing mode and domain info updated
+    setInputData
+  });
 
+  // keeps the slicing mode and domain info updated
   function updateSlicingMode(mode) {
-    model.mapper.setSlicingMode(vtkImageMapper.SlicingMode[mode]); // Update to previously set position
-
-    var modelKey = "".concat(mode.toLowerCase(), "Slice");
+    model.mapper.setSlicingMode(vtkImageMapper.SlicingMode[mode]);
 
+    // Update to previously set position
+    const modelKey = `${mode.toLowerCase()}Slice`;
     if (modelKey in model && model[modelKey] !== undefined) {
       model.mapper.setSlice(model[modelKey]);
     }
-
     if (model.input) {
       // Update domains for UI...
-      var state = updateDomains(publicAPI.getInputDataSet(), publicAPI.getDataArray(), model, publicAPI.updateProxyProperty);
+      const state = updateDomains(publicAPI.getInputDataSet(), publicAPI.getDataArray(), model, publicAPI.updateProxyProperty);
       publicAPI.set(state);
     }
-
     publicAPI.modified();
-  } // API ----------------------------------------------------------------------
+  }
 
+  // API ----------------------------------------------------------------------
 
-  publicAPI.setSlicingMode = function (mode) {
+  publicAPI.setSlicingMode = mode => {
     if (!mode) {
       return false;
     }
-
     if (model.slicingMode !== mode) {
       // Update Mode
       model.slicingMode = mode;
       updateSlicingMode(mode);
       return true;
     }
-
     return false;
   };
-
-  publicAPI.getSliceIndex = function () {
+  publicAPI.getSliceIndex = () => {
     if ('XYZ'.indexOf(model.slicingMode) !== -1) {
       return model.mapper.getSliceAtPosition(model.mapper.getSlice());
     }
-
     return model.mapper.getSlice();
   };
-
-  publicAPI.getAnnotations = function () {
-    var dynamicAddOn = {};
-    var sliceIndex = publicAPI.getSliceIndex();
-    var sliceBounds = model.mapper.getBoundsForSlice();
-    var sliceNormal = model.mapper.getSlicingModeNormal();
-
-    var _model$mapper$getClos2 = model.mapper.getClosestIJKAxis(),
-        ijkMode = _model$mapper$getClos2.ijkMode;
-
-    var sliceOrigin = [(sliceBounds[0] + sliceBounds[1]) * 0.5, (sliceBounds[2] + sliceBounds[3]) * 0.5, (sliceBounds[4] + sliceBounds[5]) * 0.5];
-    var slicePosition = 0;
-
+  publicAPI.getAnnotations = () => {
+    const dynamicAddOn = {};
+    const sliceIndex = publicAPI.getSliceIndex();
+    const sliceBounds = model.mapper.getBoundsForSlice();
+    const sliceNormal = model.mapper.getSlicingModeNormal();
+    const {
+      ijkMode
+    } = model.mapper.getClosestIJKAxis();
+    const sliceOrigin = [(sliceBounds[0] + sliceBounds[1]) * 0.5, (sliceBounds[2] + sliceBounds[3]) * 0.5, (sliceBounds[4] + sliceBounds[5]) * 0.5];
+    let slicePosition = 0;
     if (sliceBounds[1] - sliceBounds[0] < Number.EPSILON) {
       slicePosition = sliceBounds[0];
     }
-
     if (sliceBounds[3] - sliceBounds[2] < Number.EPSILON) {
       slicePosition = sliceBounds[2];
     }
-
     if (sliceBounds[5] - sliceBounds[4] < Number.EPSILON) {
       slicePosition = sliceBounds[4];
     }
-
-    var imageData = model.mapper.getInputData();
-
+    const imageData = model.mapper.getInputData();
     if (imageData) {
       dynamicAddOn.sliceSpacing = imageData.getSpacing()[ijkMode];
       dynamicAddOn.dimensions = imageData.getDimensions();
       dynamicAddOn.sliceCount = imageData.getDimensions()[ijkMode];
-      var ijkOrientation = [];
-
-      for (var i = 0; i < 3; i++) {
-        var extent = [0, 0, 0, 0, 0, 0];
+      const ijkOrientation = [];
+      for (let i = 0; i < 3; i++) {
+        const extent = [0, 0, 0, 0, 0, 0];
         extent[i * 2 + 1] = 1;
-        var tmpBounds = imageData.extentToBounds(extent);
-
+        const tmpBounds = imageData.extentToBounds(extent);
         if (tmpBounds[1] - tmpBounds[0] > Number.EPSILON) {
           ijkOrientation[0] = 'IJK'[i];
         }
-
         if (tmpBounds[3] - tmpBounds[2] > Number.EPSILON) {
           ijkOrientation[1] = 'IJK'[i];
         }
-
         if (tmpBounds[5] - tmpBounds[4] > Number.EPSILON) {
           ijkOrientation[2] = 'IJK'[i];
         }
       }
-
       dynamicAddOn.ijkOrientation = ijkOrientation.join('');
     }
-
-    return _objectSpread({
-      ijkMode: ijkMode,
-      sliceBounds: sliceBounds,
-      sliceIndex: sliceIndex,
-      sliceNormal: sliceNormal,
-      sliceOrigin: sliceOrigin,
-      slicePosition: slicePosition
-    }, dynamicAddOn);
+    return {
+      ijkMode,
+      sliceBounds,
+      sliceIndex,
+      sliceNormal,
+      sliceOrigin,
+      slicePosition,
+      ...dynamicAddOn
+    };
   };
-
-  var parentSetColorBy = publicAPI.setColorBy;
-
+  const parentSetColorBy = publicAPI.setColorBy;
   publicAPI.setColorBy = function (arrayName, arrayLocation) {
-    var componentIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
-
+    let componentIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
     if (arrayName === null) {
       model.property.setRGBTransferFunction(null);
       model.property.setPiecewiseFunction(null);
     } else {
       parentSetColorBy(arrayName, arrayLocation, componentIndex);
-      var lutProxy = publicAPI.getLookupTableProxy(arrayName);
-      var pwfProxy = publicAPI.getPiecewiseFunctionProxy(arrayName);
+      const lutProxy = publicAPI.getLookupTableProxy(arrayName);
+      const pwfProxy = publicAPI.getPiecewiseFunctionProxy(arrayName);
       model.property.setRGBTransferFunction(lutProxy.getLookupTable());
       model.property.setPiecewiseFunction(pwfProxy.getPiecewiseFunction());
     }
-  }; // Initialize slicing mode
-
+  };
 
+  // Initialize slicing mode
   updateSlicingMode(model.slicingMode || 'X');
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
+const DEFAULT_VALUES = {};
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Object methods
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Object methods
   vtkAbstractRepresentationProxy.extend(publicAPI, model, initialValues);
-  macro.get(publicAPI, model, ['slicingMode']); // Object specific methods
+  macro.get(publicAPI, model, ['slicingMode']);
 
-  vtkSliceRepresentationProxy(publicAPI, model); // Proxyfy
+  // Object specific methods
+  vtkSliceRepresentationProxy(publicAPI, model);
 
+  // Proxyfy
   macro.proxyPropertyMapping(publicAPI, model, {
     visibility: {
       modelKey: 'actor',
@@ -308,13 +285,17 @@ function extend(publicAPI, model) {
       property: 'slice'
     }
   });
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkSliceRepresentationProxy'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkSliceRepresentationProxy');
+
+// ----------------------------------------------------------------------------
 
 var vtkSliceRepresentationProxy$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkSliceRepresentationProxy$1 as default, extend, newInstance };

package/Proxy/Representations/SlicedGeometryRepresentationProxy.js

@@ -1,4 +1,4 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkActor from '../../Rendering/Core/Actor.js';
 import vtkCutter from '../../Filters/Core/Cutter.js';
 import vtkImageMapper from '../../Rendering/Core/ImageMapper.js';
@@ -6,110 +6,110 @@ import vtkMapper from '../../Rendering/Core/Mapper.js';
 import vtkPlane from '../../Common/DataModel/Plane.js';
 import vtkAbstractRepresentationProxy from '../Core/AbstractRepresentationProxy.js';
 
+// ----------------------------------------------------------------------------
 // vtkSlicedGeometryRepresentationProxy methods
 // ----------------------------------------------------------------------------
 
 function vtkSlicedGeometryRepresentationProxy(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkSlicedGeometryRepresentationProxy'); // Internals
+  model.classHierarchy.push('vtkSlicedGeometryRepresentationProxy');
 
+  // Internals
   model.plane = vtkPlane.newInstance();
   model.cutter = vtkCutter.newInstance();
   model.cutter.setCutFunction(model.plane);
   model.mapper = vtkMapper.newInstance();
   model.actor = vtkActor.newInstance();
   model.property = model.actor.getProperty();
-  model.property.setLighting(false); // connect rendering pipeline
+  model.property.setLighting(false);
 
+  // connect rendering pipeline
   model.mapper.setInputConnection(model.cutter.getOutputPort());
   model.actor.setMapper(model.mapper);
-  model.actors.push(model.actor); // Keep things updated
+  model.actors.push(model.actor);
 
-  model.sourceDependencies.push(model.cutter); // API ----------------------------------------------------------------------
+  // Keep things updated
+  model.sourceDependencies.push(model.cutter);
 
+  // API ----------------------------------------------------------------------
   publicAPI.setSlice = function () {
-    var slice = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-    var stateModified = model.slice !== slice;
+    let slice = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    const stateModified = model.slice !== slice;
     model.slice = slice;
-    var n = model.plane.getNormal();
-    var planeModified = model.plane.setOrigin(n[0] * slice, n[1] * slice, n[2] * slice);
-
+    const n = model.plane.getNormal();
+    const planeModified = model.plane.setOrigin(n[0] * slice, n[1] * slice, n[2] * slice);
     if (planeModified || stateModified) {
       publicAPI.modified();
       return true;
     }
-
     return false;
   };
-
   publicAPI.setOffset = function () {
-    var offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-    var stateModified = model.offset !== offset;
+    let offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    const stateModified = model.offset !== offset;
     model.offset = offset;
-    var normal = model.plane.getNormal();
-    var actorModified = model.actor.setPosition(offset * normal[0], offset * normal[1], offset * normal[2]);
-
+    const normal = model.plane.getNormal();
+    const actorModified = model.actor.setPosition(offset * normal[0], offset * normal[1], offset * normal[2]);
     if (actorModified || stateModified) {
       publicAPI.modified();
       return true;
     }
-
     return false;
   };
-
-  publicAPI.setSlicingMode = function (mode) {
+  publicAPI.setSlicingMode = mode => {
     if (model.slicingMode === mode || !mode) {
       console.log('skip setSlicingMode', mode);
       return;
     }
-
     model.slicingMode = mode;
-
     switch (vtkImageMapper.SlicingMode[mode]) {
       case vtkImageMapper.SlicingMode.X:
         model.plane.setNormal(1, 0, 0);
         break;
-
       case vtkImageMapper.SlicingMode.Y:
         model.plane.setNormal(0, 1, 0);
         break;
-
       case vtkImageMapper.SlicingMode.Z:
         model.plane.setNormal(0, 0, 1);
         break;
-
       default:
         return;
-    } // Reslice properly along that new axis
-
-
-    var alreadyModified = publicAPI.setSlice(model.slice);
-    alreadyModified = publicAPI.setOffset(model.offset) || alreadyModified; // Update pipeline
+    }
+    // Reslice properly along that new axis
+    let alreadyModified = publicAPI.setSlice(model.slice);
+    alreadyModified = publicAPI.setOffset(model.offset) || alreadyModified;
 
+    // Update pipeline
     if (!alreadyModified) {
       publicAPI.modified();
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   slicingMode: vtkImageMapper.SlicingMode.NONE,
   slice: 0,
   offset: 0
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Object methods
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Object methods
   vtkAbstractRepresentationProxy.extend(publicAPI, model, initialValues);
-  macro.get(publicAPI, model, ['slicingMode', 'slice', 'offset']); // Object specific methods
+  macro.get(publicAPI, model, ['slicingMode', 'slice', 'offset']);
 
-  vtkSlicedGeometryRepresentationProxy(publicAPI, model); // Map proxy properties
+  // Object specific methods
+  vtkSlicedGeometryRepresentationProxy(publicAPI, model);
 
+  // Map proxy properties
   macro.proxyPropertyState(publicAPI, model);
   macro.proxyPropertyMapping(publicAPI, model, {
     opacity: {
@@ -133,13 +133,17 @@ function extend(publicAPI, model) {
       property: 'useBounds'
     }
   });
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkSlicedGeometryRepresentationProxy');
 
-var newInstance = macro.newInstance(extend, 'vtkSlicedGeometryRepresentationProxy'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkSlicedGeometryRepresentationProxy$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkSlicedGeometryRepresentationProxy$1 as default, extend, newInstance };