@kitware/vtk.js 28.10.1 → 28.11.0

package/Rendering/Core/ImageProperty.js

@@ -1,153 +1,133 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import Constants from './ImageProperty/Constants.js';
 
-var InterpolationType = Constants.InterpolationType;
-var vtkErrorMacro = macro.vtkErrorMacro;
-var VTK_MAX_VRCOMP = 4; // ----------------------------------------------------------------------------
+const {
+  InterpolationType
+} = Constants;
+const {
+  vtkErrorMacro
+} = macro;
+const VTK_MAX_VRCOMP = 4;
+
+// ----------------------------------------------------------------------------
 // vtkImageProperty methods
 // ----------------------------------------------------------------------------
 
 function vtkImageProperty(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkImageProperty');
-
-  publicAPI.getMTime = function () {
-    var mTime = model.mtime;
-    var time;
-
-    for (var index = 0; index < VTK_MAX_VRCOMP; index++) {
+  publicAPI.getMTime = () => {
+    let mTime = model.mtime;
+    let time;
+    for (let index = 0; index < VTK_MAX_VRCOMP; index++) {
       // Color MTimes
       if (model.componentData[index].rGBTransferFunction) {
         // time that RGB transfer function was last modified
         time = model.componentData[index].rGBTransferFunction.getMTime();
         mTime = mTime > time ? mTime : time;
-      } // Piecewise function MTimes
-
+      }
 
+      // Piecewise function MTimes
       if (model.componentData[index].piecewiseFunction) {
         // time that weighting function was last modified
         time = model.componentData[index].piecewiseFunction.getMTime();
         mTime = mTime > time ? mTime : time;
       }
     }
-
     return mTime;
-  }; // Set the color of a volume to an RGB transfer function
-
+  };
 
-  publicAPI.setRGBTransferFunction = function (index, func) {
+  // Set the color of a volume to an RGB transfer function
+  publicAPI.setRGBTransferFunction = (index, func) => {
     // backwards compatible call without the component index
-    var idx = index;
-    var transferFunc = func;
-
+    let idx = index;
+    let transferFunc = func;
     if (!Number.isInteger(index)) {
       transferFunc = index;
       idx = 0;
     }
-
     if (model.componentData[idx].rGBTransferFunction !== transferFunc) {
       model.componentData[idx].rGBTransferFunction = transferFunc;
       publicAPI.modified();
       return true;
     }
-
     return false;
-  }; // Get the currently set RGB transfer function.
-
+  };
 
+  // Get the currently set RGB transfer function.
   publicAPI.getRGBTransferFunction = function () {
-    var idx = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let idx = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
     return model.componentData[idx].rGBTransferFunction;
-  }; // Set the piecewise function
-
-
-  publicAPI.setPiecewiseFunction = function (index, func) {
-    var idx = index;
-    var transferFunc = func;
+  };
 
+  // Set the piecewise function
+  publicAPI.setPiecewiseFunction = (index, func) => {
+    let idx = index;
+    let transferFunc = func;
     if (!Number.isInteger(index)) {
       transferFunc = index;
       idx = 0;
     }
-
     if (model.componentData[idx].piecewiseFunction !== transferFunc) {
       model.componentData[idx].piecewiseFunction = transferFunc;
       publicAPI.modified();
       return true;
     }
-
     return false;
-  }; // Get the component weighting function.
-
+  };
 
+  // Get the component weighting function.
   publicAPI.getPiecewiseFunction = function () {
-    var idx = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let idx = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
     return model.componentData[idx].piecewiseFunction;
-  }; // Alias to set the piecewise function
-
+  };
 
-  publicAPI.setScalarOpacity = function (index, func) {
+  // Alias to set the piecewise function
+  publicAPI.setScalarOpacity = (index, func) => {
     // backwards compatible call without the component index
-    var idx = index;
-    var transferFunc = func;
-
+    let idx = index;
+    let transferFunc = func;
     if (!Number.isInteger(index)) {
       transferFunc = index;
       idx = 0;
     }
-
     return publicAPI.setPiecewiseFunction(idx, transferFunc);
-  }; // Alias to get the piecewise function (backwards compatibility)
-
+  };
 
+  // Alias to get the piecewise function (backwards compatibility)
   publicAPI.getScalarOpacity = function () {
-    var idx = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let idx = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
     return publicAPI.getPiecewiseFunction(idx);
   };
-
-  publicAPI.setComponentWeight = function (index, value) {
+  publicAPI.setComponentWeight = (index, value) => {
     if (index < 0 || index >= VTK_MAX_VRCOMP) {
       vtkErrorMacro('Invalid index');
       return false;
     }
-
-    var val = Math.min(1, Math.max(0, value));
-
+    const val = Math.min(1, Math.max(0, value));
     if (model.componentData[index].componentWeight !== val) {
       model.componentData[index].componentWeight = val;
       publicAPI.modified();
       return true;
     }
-
     return false;
   };
-
-  publicAPI.getComponentWeight = function (index) {
+  publicAPI.getComponentWeight = index => {
     if (index < 0 || index >= VTK_MAX_VRCOMP) {
       vtkErrorMacro('Invalid index');
       return 0.0;
     }
-
     return model.componentData[index].componentWeight;
   };
+  publicAPI.setInterpolationTypeToNearest = () => publicAPI.setInterpolationType(InterpolationType.NEAREST);
+  publicAPI.setInterpolationTypeToLinear = () => publicAPI.setInterpolationType(InterpolationType.LINEAR);
+  publicAPI.getInterpolationTypeAsString = () => macro.enumToString(InterpolationType, model.interpolationType);
+}
 
-  publicAPI.setInterpolationTypeToNearest = function () {
-    return publicAPI.setInterpolationType(InterpolationType.NEAREST);
-  };
-
-  publicAPI.setInterpolationTypeToLinear = function () {
-    return publicAPI.setInterpolationType(InterpolationType.LINEAR);
-  };
-
-  publicAPI.getInterpolationTypeAsString = function () {
-    return macro.enumToString(InterpolationType, model.interpolationType);
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
-
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   independentComponents: false,
   interpolationType: InterpolationType.LINEAR,
   colorWindow: 255,
@@ -156,18 +136,19 @@ var DEFAULT_VALUES = {
   diffuse: 0.0,
   opacity: 1.0,
   useLookupTableScalarRange: false
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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
   macro.obj(publicAPI, model);
-
   if (!model.componentData) {
     model.componentData = [];
-
-    for (var i = 0; i < VTK_MAX_VRCOMP; i++) {
+    for (let i = 0; i < VTK_MAX_VRCOMP; i++) {
       model.componentData.push({
         rGBTransferFunction: null,
         piecewiseFunction: null,
@@ -175,17 +156,21 @@ function extend(publicAPI, model) {
       });
     }
   }
+  macro.setGet(publicAPI, model, ['independentComponents', 'interpolationType', 'colorWindow', 'colorLevel', 'ambient', 'diffuse', 'opacity', 'useLookupTableScalarRange']);
 
-  macro.setGet(publicAPI, model, ['independentComponents', 'interpolationType', 'colorWindow', 'colorLevel', 'ambient', 'diffuse', 'opacity', 'useLookupTableScalarRange']); // Object methods
-
+  // Object methods
   vtkImageProperty(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkImageProperty');
 
-var newInstance = macro.newInstance(extend, 'vtkImageProperty'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkImageProperty$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkImageProperty$1 as default, extend, newInstance };

package/Rendering/Core/ImageResliceMapper/Constants.js

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

package/Rendering/Core/ImageResliceMapper.js

@@ -1,70 +1,77 @@
-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 { m as macro } from '../../macros2.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; }
+const {
+  SlabTypes
+} = Constants;
+const {
+  staticOffsetAPI,
+  otherStaticMethods
+} = CoincidentTopologyHelper;
 
-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();
-
+  publicAPI.getBounds = () => {
+    let bds = [...vtkBoundingBox.INIT_BOUNDS];
+    const 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 = {
+const 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
+  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.setGet(publicAPI, model, ['slabThickness', 'slabTrapezoidIntegration', 'slabType', 'slicePlane', 'slicePolyData']);
-  CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model); // Object methods
+  CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model);
 
+  // Object methods
   vtkImageResliceMapper(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkImageResliceMapper'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkImageResliceMapper');
+
+// ----------------------------------------------------------------------------
 
-var vtkImageResliceMapper$1 = _objectSpread(_objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, staticOffsetAPI), otherStaticMethods);
+var vtkImageResliceMapper$1 = {
+  newInstance,
+  extend,
+  ...staticOffsetAPI,
+  ...otherStaticMethods
+};
 
 export { vtkImageResliceMapper$1 as default, extend, newInstance };