@kitware/vtk.js 28.10.2 → 28.11.1

package/Rendering/Core/Volume.js

@@ -1,117 +1,85 @@
 import { mat4, vec3 } from 'gl-matrix';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkProp3D from './Prop3D.js';
 import vtkVolumeProperty from './VolumeProperty.js';
 
-var vtkDebugMacro = macro.vtkDebugMacro; // ----------------------------------------------------------------------------
+const {
+  vtkDebugMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
 // vtkVolume methods
 // ----------------------------------------------------------------------------
 
 function vtkVolume(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkVolume');
-
-  publicAPI.getVolumes = function () {
-    return publicAPI;
-  };
-
+  publicAPI.getVolumes = () => publicAPI;
   publicAPI.makeProperty = vtkVolumeProperty.newInstance;
-
-  publicAPI.getProperty = function () {
+  publicAPI.getProperty = () => {
     if (model.property === null) {
       model.property = publicAPI.makeProperty();
     }
-
     return model.property;
   };
-
-  publicAPI.getBounds = function () {
+  publicAPI.getBounds = () => {
     if (model.mapper === null) {
       return model.bounds;
-    } // Check for the special case when the mapper's bounds are unknown
-
-
-    var bds = model.mapper.getBounds();
+    }
 
+    // Check for the special case when the mapper's bounds are unknown
+    const bds = model.mapper.getBounds();
     if (!bds || bds.length !== 6) {
       return bds;
-    } // Check for the special case when the actor is empty.
-
+    }
 
+    // Check for the special case when the actor is empty.
     if (bds[0] > bds[1]) {
       model.mapperBounds = bds.concat(); // copy the mapper's bounds
-
       model.bounds = [1, -1, 1, -1, 1, -1];
       model.boundsMTime.modified();
       return bds;
-    } // Check if we have cached values for these bounds - we cache the
+    }
+
+    // Check if we have cached values for these bounds - we cache the
     // values returned by model.mapper.getBounds() and we store the time
     // of caching. If the values returned this time are different, or
     // the modified time of this class is newer than the cached time,
     // then we need to rebuild.
-
-
-    var zip = function zip(rows) {
-      return rows[0].map(function (_, c) {
-        return rows.map(function (row) {
-          return row[c];
-        });
-      });
-    };
-
-    if (!model.mapperBounds || !zip([bds, model.mapperBounds]).reduce(function (a, b) {
-      return a && b[0] === b[1];
-    }, true) || publicAPI.getMTime() > model.boundsMTime.getMTime()) {
+    const zip = rows => rows[0].map((_, c) => rows.map(row => row[c]));
+    if (!model.mapperBounds || !zip([bds, model.mapperBounds]).reduce((a, b) => a && b[0] === b[1], true) || publicAPI.getMTime() > model.boundsMTime.getMTime()) {
       vtkDebugMacro('Recomputing bounds...');
-      model.mapperBounds = bds.map(function (x) {
-        return x;
-      });
-      var bbox = [];
+      model.mapperBounds = bds.map(x => x);
+      const bbox = [];
       vtkBoundingBox.getCorners(bds, bbox);
       publicAPI.computeMatrix();
-      var tmp4 = new Float64Array(16);
+      const tmp4 = new Float64Array(16);
       mat4.transpose(tmp4, model.matrix);
-      bbox.forEach(function (pt) {
-        return vec3.transformMat4(pt, pt, tmp4);
-      });
-      /* eslint-disable no-multi-assign */
+      bbox.forEach(pt => vec3.transformMat4(pt, pt, tmp4));
 
+      /* eslint-disable no-multi-assign */
       model.bounds[0] = model.bounds[2] = model.bounds[4] = Number.MAX_VALUE;
       model.bounds[1] = model.bounds[3] = model.bounds[5] = -Number.MAX_VALUE;
       /* eslint-enable no-multi-assign */
-
-      model.bounds = model.bounds.map(function (d, i) {
-        return i % 2 === 0 ? bbox.reduce(function (a, b) {
-          return a > b[i / 2] ? b[i / 2] : a;
-        }, d) : bbox.reduce(function (a, b) {
-          return a < b[(i - 1) / 2] ? b[(i - 1) / 2] : a;
-        }, d);
-      });
+      model.bounds = model.bounds.map((d, i) => i % 2 === 0 ? bbox.reduce((a, b) => a > b[i / 2] ? b[i / 2] : a, d) : bbox.reduce((a, b) => a < b[(i - 1) / 2] ? b[(i - 1) / 2] : a, d));
       model.boundsMTime.modified();
     }
-
     return model.bounds;
   };
-
-  publicAPI.getMTime = function () {
-    var mt = model.mtime;
-
+  publicAPI.getMTime = () => {
+    let mt = model.mtime;
     if (model.property !== null) {
-      var time = model.property.getMTime();
+      const time = model.property.getMTime();
       mt = time > mt ? time : mt;
     }
-
     return mt;
   };
-
-  publicAPI.getRedrawMTime = function () {
-    var mt = model.mtime;
-
+  publicAPI.getRedrawMTime = () => {
+    let mt = model.mtime;
     if (model.mapper !== null) {
-      var time = model.mapper.getMTime();
+      let time = model.mapper.getMTime();
       mt = time > mt ? time : mt;
-
       if (model.mapper.getInput() !== null) {
         // FIXME !!! getInputAlgorithm / getInput
         model.mapper.getInputAlgorithm().update();
@@ -119,41 +87,51 @@ function vtkVolume(publicAPI, model) {
         mt = time > mt ? time : mt;
       }
     }
-
     return mt;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   mapper: null,
   property: null,
   bounds: [1, -1, 1, -1, 1, -1]
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
-  vtkProp3D.extend(publicAPI, model, initialValues); // vtkTimeStamp
+  // Inheritance
+  vtkProp3D.extend(publicAPI, model, initialValues);
 
+  // vtkTimeStamp
   model.boundsMTime = {};
-  macro.obj(model.boundsMTime); // Build VTK API
+  macro.obj(model.boundsMTime);
 
+  // Build VTK API
   macro.set(publicAPI, model, ['property']);
   macro.setGet(publicAPI, model, ['mapper']);
-  macro.getArray(publicAPI, model, ['bounds'], 6); // Object methods
+  macro.getArray(publicAPI, model, ['bounds'], 6);
 
+  // Object methods
   vtkVolume(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkVolume'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkVolume');
+
+// ----------------------------------------------------------------------------
 
 var vtkVolume$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkVolume$1 as default, extend, newInstance };

package/Rendering/Core/VolumeMapper/Constants.js

@@ -1,4 +1,4 @@
-var BlendMode = {
+const BlendMode = {
   COMPOSITE_BLEND: 0,
   MAXIMUM_INTENSITY_BLEND: 1,
   MINIMUM_INTENSITY_BLEND: 2,
@@ -6,14 +6,14 @@ var BlendMode = {
   ADDITIVE_INTENSITY_BLEND: 4,
   RADON_TRANSFORM_BLEND: 5
 };
-var FilterMode = {
+const FilterMode = {
   OFF: 0,
   NORMALIZED: 1,
   RAW: 2
 };
 var Constants = {
-  BlendMode: BlendMode,
-  FilterMode: FilterMode
+  BlendMode,
+  FilterMode
 };
 
 export { BlendMode, FilterMode, Constants as default };

package/Rendering/Core/VolumeMapper.js

@@ -1,147 +1,107 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
-import { F as createUninitializedBounds, C as clampValue, K as floor } from '../../Common/Core/Math/index.js';
+import { m as macro } from '../../macros2.js';
+import { F as createUninitializedBounds, C as clampValue, G as floor } from '../../Common/Core/Math/index.js';
 import Constants from './VolumeMapper/Constants.js';
 import vtkAbstractMapper from './AbstractMapper.js';
 import vtkPiecewiseFunction from '../../Common/DataModel/PiecewiseFunction.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 BlendMode = Constants.BlendMode,
-    FilterMode = Constants.FilterMode;
-
+const {
+  BlendMode,
+  FilterMode
+} = Constants;
 function createRadonTransferFunction(firstAbsorbentMaterialHounsfieldValue, firstAbsorbentMaterialAbsorption, maxAbsorbentMaterialHounsfieldValue, maxAbsorbentMaterialAbsorption, outputTransferFunction) {
-  var ofun = null;
-
+  let ofun = null;
   if (outputTransferFunction) {
     ofun = outputTransferFunction;
     ofun.removeAllPoints();
   } else {
     ofun = vtkPiecewiseFunction.newInstance();
   }
-
   ofun.addPointLong(-1024, 0, 1, 1); // air (i.e. material with no absorption)
-
   ofun.addPoint(firstAbsorbentMaterialHounsfieldValue, firstAbsorbentMaterialAbsorption);
   ofun.addPoint(maxAbsorbentMaterialHounsfieldValue, maxAbsorbentMaterialAbsorption);
   return ofun;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Static API
 // ----------------------------------------------------------------------------
 
+const STATIC = {
+  createRadonTransferFunction
+};
 
-var STATIC = {
-  createRadonTransferFunction: createRadonTransferFunction
-}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkVolumeMapper methods
 // ----------------------------------------------------------------------------
 
 function vtkVolumeMapper(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkVolumeMapper');
-
-  var superClass = _objectSpread({}, publicAPI);
-
-  publicAPI.getBounds = function () {
-    var input = publicAPI.getInputData();
-
+  const superClass = {
+    ...publicAPI
+  };
+  publicAPI.getBounds = () => {
+    const input = publicAPI.getInputData();
     if (!input) {
       model.bounds = createUninitializedBounds();
     } else {
       if (!model.static) {
         publicAPI.update();
       }
-
       model.bounds = input.getBounds();
     }
-
     return model.bounds;
   };
-
-  publicAPI.update = function () {
+  publicAPI.update = () => {
     publicAPI.getInputData();
   };
-
-  publicAPI.setBlendModeToComposite = function () {
+  publicAPI.setBlendModeToComposite = () => {
     publicAPI.setBlendMode(BlendMode.COMPOSITE_BLEND);
   };
-
-  publicAPI.setBlendModeToMaximumIntensity = function () {
+  publicAPI.setBlendModeToMaximumIntensity = () => {
     publicAPI.setBlendMode(BlendMode.MAXIMUM_INTENSITY_BLEND);
   };
-
-  publicAPI.setBlendModeToMinimumIntensity = function () {
+  publicAPI.setBlendModeToMinimumIntensity = () => {
     publicAPI.setBlendMode(BlendMode.MINIMUM_INTENSITY_BLEND);
   };
-
-  publicAPI.setBlendModeToAverageIntensity = function () {
+  publicAPI.setBlendModeToAverageIntensity = () => {
     publicAPI.setBlendMode(BlendMode.AVERAGE_INTENSITY_BLEND);
   };
-
-  publicAPI.setBlendModeToAdditiveIntensity = function () {
+  publicAPI.setBlendModeToAdditiveIntensity = () => {
     publicAPI.setBlendMode(BlendMode.ADDITIVE_INTENSITY_BLEND);
   };
-
-  publicAPI.setBlendModeToRadonTransform = function () {
+  publicAPI.setBlendModeToRadonTransform = () => {
     publicAPI.setBlendMode(BlendMode.RADON_TRANSFORM_BLEND);
   };
-
-  publicAPI.getBlendModeAsString = function () {
-    return macro.enumToString(BlendMode, model.blendMode);
-  };
-
-  publicAPI.setAverageIPScalarRange = function (min, max) {
+  publicAPI.getBlendModeAsString = () => macro.enumToString(BlendMode, model.blendMode);
+  publicAPI.setAverageIPScalarRange = (min, max) => {
     console.warn('setAverageIPScalarRange is deprecated use setIpScalarRange');
     publicAPI.setIpScalarRange(min, max);
   };
-
-  publicAPI.getFilterModeAsString = function () {
-    return macro.enumToString(FilterMode, model.filterMode);
-  };
-
-  publicAPI.setFilterModeToOff = function () {
+  publicAPI.getFilterModeAsString = () => macro.enumToString(FilterMode, model.filterMode);
+  publicAPI.setFilterModeToOff = () => {
     publicAPI.setFilterMode(FilterMode.OFF);
   };
-
-  publicAPI.setFilterModeToNormalized = function () {
+  publicAPI.setFilterModeToNormalized = () => {
     publicAPI.setFilterMode(FilterMode.NORMALIZED);
   };
-
-  publicAPI.setFilterModeToRaw = function () {
+  publicAPI.setFilterModeToRaw = () => {
     publicAPI.setFilterMode(FilterMode.RAW);
   };
+  publicAPI.setGlobalIlluminationReach = gl => superClass.setGlobalIlluminationReach(clampValue(gl, 0.0, 1.0));
+  publicAPI.setVolumetricScatteringBlending = vsb => superClass.setVolumetricScatteringBlending(clampValue(vsb, 0.0, 1.0));
+  publicAPI.setVolumeShadowSamplingDistFactor = vsdf => superClass.setVolumeShadowSamplingDistFactor(vsdf >= 1.0 ? vsdf : 1.0);
+  publicAPI.setAnisotropy = at => superClass.setAnisotropy(clampValue(at, -0.99, 0.99));
+  publicAPI.setLAOKernelSize = ks => superClass.setLAOKernelSize(floor(clampValue(ks, 1, 32)));
+  publicAPI.setLAOKernelRadius = kr => superClass.setLAOKernelRadius(kr >= 1 ? kr : 1);
+}
 
-  publicAPI.setGlobalIlluminationReach = function (gl) {
-    return superClass.setGlobalIlluminationReach(clampValue(gl, 0.0, 1.0));
-  };
-
-  publicAPI.setVolumetricScatteringBlending = function (vsb) {
-    return superClass.setVolumetricScatteringBlending(clampValue(vsb, 0.0, 1.0));
-  };
-
-  publicAPI.setVolumeShadowSamplingDistFactor = function (vsdf) {
-    return superClass.setVolumeShadowSamplingDistFactor(vsdf >= 1.0 ? vsdf : 1.0);
-  };
-
-  publicAPI.setAnisotropy = function (at) {
-    return superClass.setAnisotropy(clampValue(at, -0.99, 0.99));
-  };
-
-  publicAPI.setLAOKernelSize = function (ks) {
-    return superClass.setLAOKernelSize(floor(clampValue(ks, 1, 32)));
-  };
-
-  publicAPI.setLAOKernelRadius = function (kr) {
-    return superClass.setLAOKernelRadius(kr >= 1 ? kr : 1);
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
-// TODO: what values to use for averageIPScalarRange to get GLSL to use max / min values like [-Math.inf, Math.inf]?
-
 
-var DEFAULT_VALUES = {
+// TODO: what values to use for averageIPScalarRange to get GLSL to use max / min values like [-Math.inf, Math.inf]?
+const DEFAULT_VALUES = {
   bounds: [1, -1, 1, -1, 1, -1],
   sampleDistance: 1.0,
   imageSampleDistance: 1.0,
@@ -165,24 +125,32 @@ var DEFAULT_VALUES = {
   localAmbientOcclusion: false,
   LAOKernelSize: 15,
   LAOKernelRadius: 7
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
   vtkAbstractMapper.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['sampleDistance', 'imageSampleDistance', 'maximumSamplesPerRay', 'autoAdjustSampleDistances', 'initialInteractionScale', 'interactionSampleDistanceFactor', 'blendMode', 'filterMode', 'preferSizeOverAccuracy', 'computeNormalFromOpacity', 'volumetricScatteringBlending', 'globalIlluminationReach', 'volumeShadowSamplingDistFactor', 'anisotropy', 'localAmbientOcclusion', 'LAOKernelSize', 'LAOKernelRadius']);
   macro.setGetArray(publicAPI, model, ['ipScalarRange'], 2);
-  macro.event(publicAPI, model, 'lightingActivated'); // Object methods
+  macro.event(publicAPI, model, 'lightingActivated');
 
+  // Object methods
   vtkVolumeMapper(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkVolumeMapper');
 
-var newInstance = macro.newInstance(extend, 'vtkVolumeMapper'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
-var vtkVolumeMapper$1 = _objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, STATIC);
+var vtkVolumeMapper$1 = {
+  newInstance,
+  extend,
+  ...STATIC
+};
 
 export { STATIC, vtkVolumeMapper$1 as default, extend, newInstance };

package/Rendering/Core/VolumeProperty/Constants.js

@@ -1,15 +1,15 @@
-var InterpolationType = {
+const InterpolationType = {
   NEAREST: 0,
   LINEAR: 1,
   FAST_LINEAR: 2
 };
-var OpacityMode = {
+const OpacityMode = {
   FRACTIONAL: 0,
   PROPORTIONAL: 1
 };
 var Constants = {
-  InterpolationType: InterpolationType,
-  OpacityMode: OpacityMode
+  InterpolationType,
+  OpacityMode
 };
 
 export { InterpolationType, OpacityMode, Constants as default };