@kitware/vtk.js 28.10.2 → 28.11.0

package/Rendering/Core/VolumeProperty.js

@@ -1,28 +1,28 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkColorTransferFunction from './ColorTransferFunction.js';
 import vtkPiecewiseFunction from '../../Common/DataModel/PiecewiseFunction.js';
 import Constants from './VolumeProperty/Constants.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 {
+  InterpolationType,
+  OpacityMode
+} = Constants;
+const {
+  vtkErrorMacro
+} = macro;
+const VTK_MAX_VRCOMP = 4;
 
-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 InterpolationType = Constants.InterpolationType,
-    OpacityMode = Constants.OpacityMode;
-var vtkErrorMacro = macro.vtkErrorMacro;
-var VTK_MAX_VRCOMP = 4; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkVolumeProperty methods
 // ----------------------------------------------------------------------------
 
 function vtkVolumeProperty(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkVolumeProperty');
-
-  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].colorChannels === 1) {
         if (model.componentData[index].grayTransferFunction) {
@@ -36,15 +36,14 @@ function vtkVolumeProperty(publicAPI, model) {
           time = model.componentData[index].rGBTransferFunction.getMTime();
           mTime = mTime > time ? mTime : time;
         }
-      } // Opacity MTimes
-
+      }
 
+      // Opacity MTimes
       if (model.componentData[index].scalarOpacity) {
         // time that Scalar opacity transfer function was last modified
         time = model.componentData[index].scalarOpacity.getMTime();
         mTime = mTime > time ? mTime : time;
       }
-
       if (model.componentData[index].gradientOpacity) {
         if (!model.componentData[index].disableGradientOpacity) {
           // time that Gradient opacity transfer function was last modified
@@ -53,188 +52,146 @@ function vtkVolumeProperty(publicAPI, model) {
         }
       }
     }
-
     return mTime;
   };
-
-  publicAPI.getColorChannels = function (index) {
+  publicAPI.getColorChannels = index => {
     if (index < 0 || index > 3) {
       vtkErrorMacro('Bad index - must be between 0 and 3');
       return 0;
     }
-
     return model.componentData[index].colorChannels;
-  }; // Set the color of a volume to a gray transfer function
-
-
-  publicAPI.setGrayTransferFunction = function (index, func) {
-    var modified = false;
+  };
 
+  // Set the color of a volume to a gray transfer function
+  publicAPI.setGrayTransferFunction = (index, func) => {
+    let modified = false;
     if (model.componentData[index].grayTransferFunction !== func) {
       model.componentData[index].grayTransferFunction = func;
       modified = true;
     }
-
     if (model.componentData[index].colorChannels !== 1) {
       model.componentData[index].colorChannels = 1;
       modified = true;
     }
-
     if (modified) {
       publicAPI.modified();
     }
-
     return modified;
-  }; // Get the currently set gray transfer function. Create one if none set.
-
+  };
 
-  publicAPI.getGrayTransferFunction = function (index) {
+  // Get the currently set gray transfer function. Create one if none set.
+  publicAPI.getGrayTransferFunction = index => {
     if (model.componentData[index].grayTransferFunction === null) {
       model.componentData[index].grayTransferFunction = vtkPiecewiseFunction.newInstance();
       model.componentData[index].grayTransferFunction.addPoint(0, 0.0);
       model.componentData[index].grayTransferFunction.addPoint(1024, 1.0);
-
       if (model.componentData[index].colorChannels !== 1) {
         model.componentData[index].colorChannels = 1;
       }
-
       publicAPI.modified();
     }
-
     return model.componentData[index].grayTransferFunction;
-  }; // Set the color of a volume to an RGB transfer function
-
-
-  publicAPI.setRGBTransferFunction = function (index, func) {
-    var modified = false;
+  };
 
+  // Set the color of a volume to an RGB transfer function
+  publicAPI.setRGBTransferFunction = (index, func) => {
+    let modified = false;
     if (model.componentData[index].rGBTransferFunction !== func) {
       model.componentData[index].rGBTransferFunction = func;
       modified = true;
     }
-
     if (model.componentData[index].colorChannels !== 3) {
       model.componentData[index].colorChannels = 3;
       modified = true;
     }
-
     if (modified) {
       publicAPI.modified();
     }
-
     return modified;
-  }; // Get the currently set RGB transfer function. Create one if none set.
-
+  };
 
-  publicAPI.getRGBTransferFunction = function (index) {
+  // Get the currently set RGB transfer function. Create one if none set.
+  publicAPI.getRGBTransferFunction = index => {
     if (model.componentData[index].rGBTransferFunction === null) {
       model.componentData[index].rGBTransferFunction = vtkColorTransferFunction.newInstance();
       model.componentData[index].rGBTransferFunction.addRGBPoint(0, 0.0, 0.0, 0.0);
       model.componentData[index].rGBTransferFunction.addRGBPoint(1024, 1.0, 1.0, 1.0);
-
       if (model.componentData[index].colorChannels !== 3) {
         model.componentData[index].colorChannels = 3;
       }
-
       publicAPI.modified();
     }
-
     return model.componentData[index].rGBTransferFunction;
-  }; // Set the scalar opacity of a volume to a transfer function
-
+  };
 
-  publicAPI.setScalarOpacity = function (index, func) {
+  // Set the scalar opacity of a volume to a transfer function
+  publicAPI.setScalarOpacity = (index, func) => {
     if (model.componentData[index].scalarOpacity !== func) {
       model.componentData[index].scalarOpacity = func;
       publicAPI.modified();
       return true;
     }
-
     return false;
-  }; // Get the scalar opacity transfer function. Create one if none set.
-
+  };
 
-  publicAPI.getScalarOpacity = function (index) {
+  // Get the scalar opacity transfer function. Create one if none set.
+  publicAPI.getScalarOpacity = index => {
     if (model.componentData[index].scalarOpacity === null) {
       model.componentData[index].scalarOpacity = vtkPiecewiseFunction.newInstance();
       model.componentData[index].scalarOpacity.addPoint(0, 1.0);
       model.componentData[index].scalarOpacity.addPoint(1024, 1.0);
       publicAPI.modified();
     }
-
     return model.componentData[index].scalarOpacity;
   };
-
-  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 = function () {
-    return publicAPI.setInterpolationType(InterpolationType.NEAREST);
-  };
-
-  publicAPI.setInterpolationTypeToLinear = function () {
-    return publicAPI.setInterpolationType(InterpolationType.LINEAR);
-  };
-
-  publicAPI.setInterpolationTypeToFastLinear = function () {
-    return publicAPI.setInterpolationType(InterpolationType.FAST_LINEAR);
-  };
-
-  publicAPI.getInterpolationTypeAsString = function () {
-    return macro.enumToString(InterpolationType, model.interpolationType);
-  };
-
-  var sets = ['useGradientOpacity', 'scalarOpacityUnitDistance', 'gradientOpacityMinimumValue', 'gradientOpacityMinimumOpacity', 'gradientOpacityMaximumValue', 'gradientOpacityMaximumOpacity', 'opacityMode'];
-  sets.forEach(function (val) {
-    var cap = macro.capitalize(val);
-
-    publicAPI["set".concat(cap)] = function (index, value) {
-      if (model.componentData[index]["".concat(val)] !== value) {
-        model.componentData[index]["".concat(val)] = value;
+  publicAPI.setInterpolationTypeToNearest = () => publicAPI.setInterpolationType(InterpolationType.NEAREST);
+  publicAPI.setInterpolationTypeToLinear = () => publicAPI.setInterpolationType(InterpolationType.LINEAR);
+  publicAPI.setInterpolationTypeToFastLinear = () => publicAPI.setInterpolationType(InterpolationType.FAST_LINEAR);
+  publicAPI.getInterpolationTypeAsString = () => macro.enumToString(InterpolationType, model.interpolationType);
+  const sets = ['useGradientOpacity', 'scalarOpacityUnitDistance', 'gradientOpacityMinimumValue', 'gradientOpacityMinimumOpacity', 'gradientOpacityMaximumValue', 'gradientOpacityMaximumOpacity', 'opacityMode'];
+  sets.forEach(val => {
+    const cap = macro.capitalize(val);
+    publicAPI[`set${cap}`] = (index, value) => {
+      if (model.componentData[index][`${val}`] !== value) {
+        model.componentData[index][`${val}`] = value;
         publicAPI.modified();
         return true;
       }
-
       return false;
     };
   });
-  var gets = ['useGradientOpacity', 'scalarOpacityUnitDistance', 'gradientOpacityMinimumValue', 'gradientOpacityMinimumOpacity', 'gradientOpacityMaximumValue', 'gradientOpacityMaximumOpacity', 'opacityMode'];
-  gets.forEach(function (val) {
-    var cap = macro.capitalize(val);
-
-    publicAPI["get".concat(cap)] = function (index) {
-      return model.componentData[index]["".concat(val)];
-    };
+  const gets = ['useGradientOpacity', 'scalarOpacityUnitDistance', 'gradientOpacityMinimumValue', 'gradientOpacityMinimumOpacity', 'gradientOpacityMaximumValue', 'gradientOpacityMaximumOpacity', 'opacityMode'];
+  gets.forEach(val => {
+    const cap = macro.capitalize(val);
+    publicAPI[`get${cap}`] = index => model.componentData[index][`${val}`];
   });
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   independentComponents: true,
   interpolationType: InterpolationType.FAST_LINEAR,
   shade: false,
@@ -245,18 +202,19 @@ var DEFAULT_VALUES = {
   useLabelOutline: false,
   labelOutlineThickness: 1,
   labelOutlineOpacity: 1.0
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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({
         colorChannels: 1,
         grayTransferFunction: null,
@@ -273,17 +231,22 @@ function extend(publicAPI, model) {
       });
     }
   }
+  macro.setGet(publicAPI, model, ['independentComponents', 'interpolationType', 'shade', 'ambient', 'diffuse', 'specular', 'specularPower', 'useLabelOutline', 'labelOutlineThickness', 'labelOutlineOpacity']);
 
-  macro.setGet(publicAPI, model, ['independentComponents', 'interpolationType', 'shade', 'ambient', 'diffuse', 'specular', 'specularPower', 'useLabelOutline', 'labelOutlineThickness', 'labelOutlineOpacity']); // Object methods
-
+  // Object methods
   vtkVolumeProperty(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkVolumeProperty'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkVolumeProperty');
+
+// ----------------------------------------------------------------------------
 
-var vtkVolumeProperty$1 = _objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, Constants);
+var vtkVolumeProperty$1 = {
+  newInstance,
+  extend,
+  ...Constants
+};
 
 export { vtkVolumeProperty$1 as default, extend, newInstance };

package/Rendering/Core.js

@@ -1,4 +1,3 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import vtkColorMaps from './Core/ColorTransferFunction/ColorMaps.js';
 import vtkAbstractMapper from './Core/AbstractMapper.js';
 import vtkAbstractMapper3D from './Core/AbstractMapper3D.js';
@@ -44,55 +43,54 @@ import vtkVolume from './Core/Volume.js';
 import vtkVolumeMapper from './Core/VolumeMapper.js';
 import vtkVolumeProperty from './Core/VolumeProperty.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; }
+// Bundle size management - start
 var Core = {
-  vtkAbstractMapper: vtkAbstractMapper,
-  vtkAbstractMapper3D: vtkAbstractMapper3D,
-  vtkAbstractPicker: vtkAbstractPicker,
-  vtkActor: vtkActor,
-  vtkActor2D: vtkActor2D,
-  vtkAnnotatedCubeActor: vtkAnnotatedCubeActor,
-  vtkAxesActor: vtkAxesActor,
-  vtkCamera: vtkCamera,
-  vtkCellPicker: vtkCellPicker,
-  vtkColorTransferFunction: _objectSpread({
-    vtkColorMaps: vtkColorMaps
-  }, vtkColorTransferFunction),
-  vtkCoordinate: vtkCoordinate,
-  vtkCubeAxesActor: vtkCubeAxesActor,
-  vtkFollower: vtkFollower,
-  vtkGlyph3DMapper: vtkGlyph3DMapper,
-  vtkHardwareSelector: vtkHardwareSelector,
-  vtkImageMapper: vtkImageMapper,
-  vtkImageProperty: vtkImageProperty,
-  vtkImageResliceMapper: vtkImageResliceMapper,
-  vtkImageSlice: vtkImageSlice,
-  vtkInteractorObserver: vtkInteractorObserver,
-  vtkInteractorStyle: vtkInteractorStyle,
-  vtkLight: vtkLight,
-  vtkMapper: vtkMapper,
-  vtkMapper2D: vtkMapper2D,
-  vtkPicker: vtkPicker,
-  vtkPixelSpaceCallbackMapper: vtkPixelSpaceCallbackMapper,
-  vtkPointPicker: vtkPointPicker,
-  vtkProp: vtkProp,
-  vtkProp3D: vtkProp3D,
-  vtkProperty: vtkProperty,
-  vtkProperty2D: vtkProperty2D,
-  vtkRenderer: vtkRenderer,
-  vtkRenderWindow: vtkRenderWindow,
-  vtkRenderWindowInteractor: vtkRenderWindowInteractor,
-  vtkScalarBarActor: vtkScalarBarActor,
-  vtkSkybox: vtkSkybox,
-  vtkSphereMapper: vtkSphereMapper,
-  vtkStickMapper: vtkStickMapper,
-  vtkTexture: vtkTexture,
-  vtkViewport: vtkViewport,
-  vtkVolume: vtkVolume,
-  vtkVolumeMapper: vtkVolumeMapper,
-  vtkVolumeProperty: vtkVolumeProperty
+  vtkAbstractMapper,
+  vtkAbstractMapper3D,
+  vtkAbstractPicker,
+  vtkActor,
+  vtkActor2D,
+  vtkAnnotatedCubeActor,
+  vtkAxesActor,
+  vtkCamera,
+  vtkCellPicker,
+  vtkColorTransferFunction: {
+    vtkColorMaps,
+    ...vtkColorTransferFunction
+  },
+  vtkCoordinate,
+  vtkCubeAxesActor,
+  vtkFollower,
+  vtkGlyph3DMapper,
+  vtkHardwareSelector,
+  vtkImageMapper,
+  vtkImageProperty,
+  vtkImageResliceMapper,
+  vtkImageSlice,
+  vtkInteractorObserver,
+  vtkInteractorStyle,
+  vtkLight,
+  vtkMapper,
+  vtkMapper2D,
+  vtkPicker,
+  vtkPixelSpaceCallbackMapper,
+  vtkPointPicker,
+  vtkProp,
+  vtkProp3D,
+  vtkProperty,
+  vtkProperty2D,
+  vtkRenderer,
+  vtkRenderWindow,
+  vtkRenderWindowInteractor,
+  vtkScalarBarActor,
+  vtkSkybox,
+  vtkSphereMapper,
+  vtkStickMapper,
+  vtkTexture,
+  vtkViewport,
+  vtkVolume,
+  vtkVolumeMapper,
+  vtkVolumeProperty
 };
 
 export { Core as default };