@kitware/vtk.js 28.10.2 → 28.11.1

package/Proxy/Core/AbstractRepresentationProxy.js

@@ -1,149 +1,119 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-import { setGet, get, proxy, chain } from '../../macros.js';
+import { e as setGet, g as get, p as proxy, h as chain } from '../../macros2.js';
 import vtkProp from '../../Rendering/Core/Prop.js';
 import vtkMapper from '../../Rendering/Core/Mapper.js';
 import vtkScalarsToColors from '../../Common/Core/ScalarsToColors.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 
+// ----------------------------------------------------------------------------
 // vtkAbstractRepresentationProxy methods
 // ----------------------------------------------------------------------------
 
 function vtkAbstractRepresentationProxy(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkAbstractRepresentationProxy');
-
   function updateConnectivity() {
     if (model.input) {
-      for (var i = 0; i < model.sourceDependencies.length; ++i) {
+      for (let i = 0; i < model.sourceDependencies.length; ++i) {
         model.sourceDependencies[i].setInputData(model.input.getDataset());
       }
     }
   }
-
-  publicAPI.setInput = function (source) {
+  publicAPI.setInput = source => {
     if (model.sourceSubscription) {
       model.sourceSubscription.unsubscribe();
       model.sourceSubscription = null;
     }
-
     publicAPI.gcPropertyLinks('source');
     model.input = source;
     publicAPI.updateColorByDomain();
-
     if (model.input) {
       updateConnectivity();
       model.sourceSubscription = model.input.onDatasetChange(updateConnectivity);
-    } // Allow dynamic registration of links at the source level
-
+    }
 
+    // Allow dynamic registration of links at the source level
     if (model.links) {
-      for (var i = 0; i < model.links.length; i++) {
-        var _model$links$i = model.links[i],
-            link = _model$links$i.link,
-            property = _model$links$i.property,
-            persistent = _model$links$i.persistent,
-            updateOnBind = _model$links$i.updateOnBind,
-            type = _model$links$i.type;
-
+      for (let i = 0; i < model.links.length; i++) {
+        const {
+          link,
+          property,
+          persistent,
+          updateOnBind,
+          type
+        } = model.links[i];
         if (type === undefined || type === 'source') {
-          var sLink = source.getPropertyLink(link, persistent);
+          const sLink = source.getPropertyLink(link, persistent);
           publicAPI.registerPropertyLinkForGC(sLink, 'source');
           sLink.bind(publicAPI, property, updateOnBind);
         }
       }
     }
   };
-
-  publicAPI.getInputDataSet = function () {
-    return model.input ? model.input.getDataset() : null;
-  };
-
-  publicAPI.getDataArray = function (arrayName, arrayLocation) {
-    var _publicAPI$getColorBy = publicAPI.getColorBy(),
-        _publicAPI$getColorBy2 = _slicedToArray(_publicAPI$getColorBy, 2),
-        selectedArray = _publicAPI$getColorBy2[0],
-        selectedLocation = _publicAPI$getColorBy2[1];
-
-    var ds = publicAPI.getInputDataSet();
-    var fields = ds ? ds.getReferenceByName(arrayLocation || selectedLocation) : null;
-    var array = fields ? fields.getArrayByName(arrayName || selectedArray) : null;
+  publicAPI.getInputDataSet = () => model.input ? model.input.getDataset() : null;
+  publicAPI.getDataArray = (arrayName, arrayLocation) => {
+    const [selectedArray, selectedLocation] = publicAPI.getColorBy();
+    const ds = publicAPI.getInputDataSet();
+    const fields = ds ? ds.getReferenceByName(arrayLocation || selectedLocation) : null;
+    const array = fields ? fields.getArrayByName(arrayName || selectedArray) : null;
     return array;
   };
-
-  publicAPI.getLookupTableProxy = function (arrayName) {
-    var arrayNameToUse = arrayName || publicAPI.getColorBy()[0];
-
+  publicAPI.getLookupTableProxy = arrayName => {
+    const arrayNameToUse = arrayName || publicAPI.getColorBy()[0];
     if (arrayNameToUse) {
       return model.proxyManager.getLookupTable(arrayNameToUse);
     }
-
     return null;
-  }; // In place edits, no need to re-assign it...
-
-
-  publicAPI.setLookupTableProxy = function () {};
-
-  publicAPI.getPiecewiseFunctionProxy = function (arrayName) {
-    var arrayNameToUse = arrayName || publicAPI.getColorBy()[0];
+  };
 
+  // In place edits, no need to re-assign it...
+  publicAPI.setLookupTableProxy = () => {};
+  publicAPI.getPiecewiseFunctionProxy = arrayName => {
+    const arrayNameToUse = arrayName || publicAPI.getColorBy()[0];
     if (arrayNameToUse) {
       return model.proxyManager.getPiecewiseFunction(arrayNameToUse);
     }
-
     return null;
-  }; // In place edits, no need to re-assign it...
-
-
-  publicAPI.setPiecewiseFunctionProxy = function () {};
+  };
 
+  // In place edits, no need to re-assign it...
+  publicAPI.setPiecewiseFunctionProxy = () => {};
   publicAPI.rescaleTransferFunctionToDataRange = function (n, l) {
-    var c = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
-    var array = publicAPI.getDataArray(n, l);
-    var dataRange = array.getRange(c);
+    let c = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
+    const array = publicAPI.getDataArray(n, l);
+    const dataRange = array.getRange(c);
     model.proxyManager.rescaleTransferFunctionToDataRange(n, dataRange);
   };
-
-  publicAPI.isVisible = function () {
+  publicAPI.isVisible = () => {
     if (model.actors.length) {
       return model.actors[0].getVisibility();
     }
-
     if (model.volumes.length) {
       return model.volumes[0].getVisibility();
     }
-
     return false;
   };
-
-  publicAPI.setVisibility = function (visible) {
-    var change = 0;
-    var count = model.actors.length;
-
+  publicAPI.setVisibility = visible => {
+    let change = 0;
+    let count = model.actors.length;
     while (count--) {
       change += model.actors[count].setVisibility(visible);
     }
-
     count = model.volumes.length;
-
     while (count--) {
       change += model.volumes[count].setVisibility(visible);
     }
-
     if (change) {
       publicAPI.modified();
     }
   };
-
   publicAPI.setColorBy = function (arrayName, arrayLocation) {
-    var componentIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
-    var colorMode = vtkMapper.ColorMode.DEFAULT;
-    var scalarMode = vtkMapper.ScalarMode.DEFAULT;
-    var colorByArrayName = arrayName;
-    var activeArray = publicAPI.getDataArray(arrayName, arrayLocation);
-    var scalarVisibility = !!activeArray;
-    var lookupTable = arrayName ? publicAPI.getLookupTableProxy(arrayName).getLookupTable() : null;
-
+    let componentIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
+    let colorMode = vtkMapper.ColorMode.DEFAULT;
+    let scalarMode = vtkMapper.ScalarMode.DEFAULT;
+    const colorByArrayName = arrayName;
+    const activeArray = publicAPI.getDataArray(arrayName, arrayLocation);
+    const scalarVisibility = !!activeArray;
+    const lookupTable = arrayName ? publicAPI.getLookupTableProxy(arrayName).getLookupTable() : null;
     if (lookupTable) {
       if (componentIndex === -1) {
         lookupTable.setVectorModeToMagnitude();
@@ -152,115 +122,95 @@ function vtkAbstractRepresentationProxy(publicAPI, model) {
         lookupTable.setVectorComponent(componentIndex);
       }
     }
-
     if (scalarVisibility) {
       colorMode = vtkMapper.ColorMode.MAP_SCALARS;
       scalarMode = arrayLocation === 'pointData' ? vtkMapper.ScalarMode.USE_POINT_FIELD_DATA : vtkMapper.ScalarMode.USE_CELL_FIELD_DATA;
-
       if (model.mapper.setLookupTable) {
         model.mapper.setLookupTable(lookupTable);
       }
-
       if (model.rescaleOnColorBy) {
         publicAPI.rescaleTransferFunctionToDataRange(arrayName, arrayLocation, componentIndex);
       }
-    } // Not all mappers have those fields
-
+    }
 
+    // Not all mappers have those fields
     model.mapper.set({
-      colorByArrayName: colorByArrayName,
-      colorMode: colorMode,
-      scalarMode: scalarMode,
-      scalarVisibility: scalarVisibility
+      colorByArrayName,
+      colorMode,
+      scalarMode,
+      scalarVisibility
     }, true);
   };
-
-  publicAPI.getColorBy = function () {
+  publicAPI.getColorBy = () => {
     if (!model.mapper.getColorByArrayName) {
-      var ds = publicAPI.getInputDataSet();
-
+      const ds = publicAPI.getInputDataSet();
       if (ds.getPointData().getScalars()) {
         return [ds.getPointData().getScalars().getName(), 'pointData', -1];
       }
-
       if (ds.getCellData().getScalars()) {
         return [ds.getCellData().getScalars().getName(), 'cellData', -1];
       }
-
       if (ds.getPointData().getNumberOfArrays()) {
         return [ds.getPointData().getArrayByIndex(0).getName(), 'pointData', -1];
       }
-
       if (ds.getCellData().getNumberOfArrays()) {
         return [ds.getCellData().getArrayByIndex(0).getName(), 'cellData', -1];
       }
-
       return [];
     }
-
-    var result = [];
-
-    var _model$mapper$get = model.mapper.get('colorByArrayName', 'colorMode', 'scalarMode', 'scalarVisibility'),
-        colorByArrayName = _model$mapper$get.colorByArrayName,
-        colorMode = _model$mapper$get.colorMode,
-        scalarMode = _model$mapper$get.scalarMode,
-        scalarVisibility = _model$mapper$get.scalarVisibility;
-
+    const result = [];
+    const {
+      colorByArrayName,
+      colorMode,
+      scalarMode,
+      scalarVisibility
+    } = model.mapper.get('colorByArrayName', 'colorMode', 'scalarMode', 'scalarVisibility');
     if (scalarVisibility && colorByArrayName) {
       result.push(colorByArrayName);
       result.push(scalarMode === vtkMapper.ScalarMode.USE_POINT_FIELD_DATA ? 'pointData' : 'cellData');
     }
-
     if (colorMode === vtkMapper.ColorMode.MAP_SCALARS && colorByArrayName) {
-      var lut = publicAPI.getLookupTableProxy(colorByArrayName).getLookupTable();
-      var componentIndex = lut.getVectorMode() === vtkScalarsToColors.VectorMode.MAGNITUDE ? -1 : lut.getVectorComponent();
+      const lut = publicAPI.getLookupTableProxy(colorByArrayName).getLookupTable();
+      const componentIndex = lut.getVectorMode() === vtkScalarsToColors.VectorMode.MAGNITUDE ? -1 : lut.getVectorComponent();
       result.push(componentIndex);
     }
-
     return result;
   };
-
-  publicAPI.listDataArrays = function () {
-    var arrayList = [];
-
+  publicAPI.listDataArrays = () => {
+    const arrayList = [];
     if (!model.input) {
       return arrayList;
     }
+    const dataset = publicAPI.getInputDataSet();
 
-    var dataset = publicAPI.getInputDataSet(); // Point data
-
-    var pointData = dataset.getPointData();
-    var size = pointData.getNumberOfArrays();
-
-    for (var idx = 0; idx < size; idx++) {
-      var array = pointData.getArrayByIndex(idx);
+    // Point data
+    const pointData = dataset.getPointData();
+    let size = pointData.getNumberOfArrays();
+    for (let idx = 0; idx < size; idx++) {
+      const array = pointData.getArrayByIndex(idx);
       arrayList.push({
         name: array.getName(),
         location: 'pointData',
         numberOfComponents: array.getNumberOfComponents(),
         dataRange: array.getRange()
       });
-    } // Cell data
-
+    }
 
-    var cellData = dataset.getCellData();
+    // Cell data
+    const cellData = dataset.getCellData();
     size = cellData.getNumberOfArrays();
-
-    for (var _idx = 0; _idx < size; _idx++) {
-      var _array = cellData.getArrayByIndex(_idx);
-
+    for (let idx = 0; idx < size; idx++) {
+      const array = cellData.getArrayByIndex(idx);
       arrayList.push({
-        name: _array.getName(),
+        name: array.getName(),
         location: 'cellData',
-        numberOfComponents: _array.getNumberOfComponents(),
-        dataRange: _array.getRange()
+        numberOfComponents: array.getNumberOfComponents(),
+        dataRange: array.getRange()
       });
     }
-
     return arrayList;
   };
-
-  publicAPI.updateColorByDomain = function () {
+  publicAPI.updateColorByDomain = () => {
     publicAPI.updateProxyProperty('colorBy', {
       domain: {
         arrays: publicAPI.listDataArrays(),
@@ -268,30 +218,24 @@ function vtkAbstractRepresentationProxy(publicAPI, model) {
       }
     });
   };
-
-  publicAPI.delete = chain(function () {
+  publicAPI.delete = chain(() => {
     if (model.sourceSubscription) {
       model.sourceSubscription.unsubscribe();
       model.sourceSubscription = null;
     }
-  }, publicAPI.delete); // Fast getter for rendering
-
-  var nestedProps = [];
-
-  var bbox = _toConsumableArray(vtkBoundingBox.INIT_BOUNDS);
+  }, publicAPI.delete);
 
+  // Fast getter for rendering
+  const nestedProps = [];
+  const bbox = [...vtkBoundingBox.INIT_BOUNDS];
   function handleProp(prop) {
     if (prop) {
       vtkBoundingBox.addBounds(bbox, prop.getBounds());
       nestedProps.push(prop);
     }
   }
-
-  publicAPI.getNestedProps = function () {
-    return nestedProps;
-  };
-
-  publicAPI.getBounds = function () {
+  publicAPI.getNestedProps = () => nestedProps;
+  publicAPI.getBounds = () => {
     if (model.boundMTime < model.mtime) {
       model.boundMTime = model.mtime;
       vtkBoundingBox.reset(bbox);
@@ -299,35 +243,37 @@ function vtkAbstractRepresentationProxy(publicAPI, model) {
       model.actors.forEach(handleProp);
       model.volumes.forEach(handleProp);
     }
-
     return bbox;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   boundMTime: 0,
   actors: [],
   volumes: [],
   sourceDependencies: [],
   rescaleOnColorBy: true
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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);
   vtkProp.extend(publicAPI, model, initialValues);
   setGet(publicAPI, model, ['rescaleOnColorBy']);
-  get(publicAPI, model, ['input', 'mapper', 'actors', 'volumes']); // Object specific methods
+  get(publicAPI, model, ['input', 'mapper', 'actors', 'volumes']);
 
+  // Object specific methods
   vtkAbstractRepresentationProxy(publicAPI, model);
   proxy(publicAPI, model);
 }
-
 var vtkAbstractRepresentationProxy$1 = {
-  extend: extend
+  extend
 };
 
 export { vtkAbstractRepresentationProxy$1 as default };

package/Proxy/Core/LookupTableProxy/Constants.js

@@ -1,10 +1,10 @@
-var Mode = {
+const Mode = {
   Preset: 0,
   RGBPoints: 1,
   HSVPoints: 2,
   Nodes: 3
 };
-var Defaults = {
+const Defaults = {
   Preset: 'Cool to Warm',
   RGBPoints: [[0, 0, 0, 0], [1, 1, 1, 1]],
   HSVPoints: [[0, 0, 0, 0], [1, 0, 0, 1]],
@@ -25,8 +25,8 @@ var Defaults = {
   }]
 };
 var Constants = {
-  Defaults: Defaults,
-  Mode: Mode
+  Defaults,
+  Mode
 };
 
 export { Constants as default };

package/Proxy/Core/LookupTableProxy.js

@@ -1,102 +1,92 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkColorMaps from '../../Rendering/Core/ColorTransferFunction/ColorMaps.js';
 import vtkColorTransferFunction from '../../Rendering/Core/ColorTransferFunction.js';
 import Constants from './LookupTableProxy/Constants.js';
 
-var Mode = Constants.Mode,
-    Defaults = Constants.Defaults; // ----------------------------------------------------------------------------
+const {
+  Mode,
+  Defaults
+} = Constants;
+
+// ----------------------------------------------------------------------------
 // vtkLookupTableProxy methods
 // ----------------------------------------------------------------------------
 
 function vtkLookupTableProxy(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkLookupTableProxy');
-  model.lookupTable = model.lookupTable || vtkColorTransferFunction.newInstance(); // Initialize lookup table
+  model.lookupTable = model.lookupTable || vtkColorTransferFunction.newInstance();
 
-  model.lookupTable.setVectorModeToMagnitude(); // Takes a preset colormap name
+  // Initialize lookup table
+  model.lookupTable.setVectorModeToMagnitude();
 
-  publicAPI.setPresetName = function (presetName) {
+  // Takes a preset colormap name
+  publicAPI.setPresetName = presetName => {
     if (model.presetName !== presetName) {
       model.presetName = presetName;
       model.mode = Mode.Preset;
       publicAPI.applyMode();
     }
-  }; // Takes an array of points [x, r, g, b, m=0.5, s=0.0]
-
+  };
 
-  publicAPI.setRGBPoints = function (rgbPoints) {
+  // Takes an array of points [x, r, g, b, m=0.5, s=0.0]
+  publicAPI.setRGBPoints = rgbPoints => {
     if (model.rgbPoints !== rgbPoints) {
       model.rgbPoints = (rgbPoints || Defaults.RGBPoints).slice();
       publicAPI.applyMode();
     }
-  }; // Takes an array of points [x, h, s, v, m=0.5, s=0.0]
-
+  };
 
-  publicAPI.setHSVPoints = function (hsvPoints) {
+  // Takes an array of points [x, h, s, v, m=0.5, s=0.0]
+  publicAPI.setHSVPoints = hsvPoints => {
     if (model.hsvPoints !== hsvPoints) {
       model.hsvPoints = (hsvPoints || Defaults.HSVPoints).slice();
       publicAPI.applyMode();
     }
-  }; // Takes an array of ColorTransferFunction nodes
-
+  };
 
-  publicAPI.setNodes = function (nodes) {
+  // Takes an array of ColorTransferFunction nodes
+  publicAPI.setNodes = nodes => {
     if (model.nodes !== nodes) {
       model.nodes = (nodes || Defaults.Nodes).slice();
       publicAPI.applyMode();
     }
   };
-
-  publicAPI.setMode = function (mode) {
+  publicAPI.setMode = mode => {
     if (model.mode !== mode) {
       model.mode = mode;
       publicAPI.applyMode();
     }
   };
-
-  publicAPI.applyMode = function () {
+  publicAPI.applyMode = () => {
     switch (model.mode) {
       case Mode.Preset:
         {
-          var preset = vtkColorMaps.getPresetByName(model.presetName);
-
+          const preset = vtkColorMaps.getPresetByName(model.presetName);
           if (preset) {
             model.lookupTable.applyColorMap(preset);
           }
         }
         break;
-
       case Mode.RGBPoints:
         model.lookupTable.removeAllPoints();
-        model.rgbPoints.forEach(function (point) {
-          var _model$lookupTable;
-
-          return (_model$lookupTable = model.lookupTable).addRGBPointLong.apply(_model$lookupTable, _toConsumableArray(point));
-        });
+        model.rgbPoints.forEach(point => model.lookupTable.addRGBPointLong(...point));
         break;
-
       case Mode.HSVPoints:
         model.lookupTable.removeAllPoints();
-        model.hsvPoints.forEach(function (point) {
-          var _model$lookupTable2;
-
-          return (_model$lookupTable2 = model.lookupTable).addHSVPointLong.apply(_model$lookupTable2, _toConsumableArray(point));
-        });
+        model.hsvPoints.forEach(point => model.lookupTable.addHSVPointLong(...point));
         break;
-
       case Mode.Nodes:
         model.lookupTable.setNodes(model.nodes);
         break;
-
+      // noop
     }
 
     model.lookupTable.setMappingRange(model.dataRange[0], model.dataRange[1]);
     model.lookupTable.updateRange();
     publicAPI.modified();
   };
-
-  publicAPI.setDataRange = function (min, max) {
+  publicAPI.setDataRange = (min, max) => {
     if (model.dataRange[0] !== min || model.dataRange[1] !== max) {
       model.dataRange[0] = min;
       model.dataRange[1] = max;
@@ -104,16 +94,18 @@ function vtkLookupTableProxy(publicAPI, model) {
       model.lookupTable.updateRange();
       publicAPI.applyMode();
     }
-  }; // Initialization ------------------------------------------------------------
+  };
 
+  // Initialization ------------------------------------------------------------
 
   publicAPI.applyMode();
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   mode: Mode.Preset,
   presetName: Defaults.Preset,
   rgbPoints: Defaults.RGBPoints,
@@ -122,27 +114,32 @@ var DEFAULT_VALUES = {
   arrayName: 'No array associated',
   arrayLocation: 'pointData',
   dataRange: [0, 1]
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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);
   macro.obj(publicAPI, model);
   macro.setGet(publicAPI, model, ['arrayName']);
-  macro.get(publicAPI, model, ['mode', 'lookupTable', 'presetName', 'rgbPoints', 'hsvPoints', 'nodes', 'dataRange']); // Object specific methods
+  macro.get(publicAPI, model, ['mode', 'lookupTable', 'presetName', 'rgbPoints', 'hsvPoints', 'nodes', 'dataRange']);
 
-  vtkLookupTableProxy(publicAPI, model); // Proxy handling
+  // Object specific methods
+  vtkLookupTableProxy(publicAPI, model);
 
+  // Proxy handling
   macro.proxy(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkLookupTableProxy'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkLookupTableProxy');
 var vtkLookupTableProxy$1 = {
-  newInstance: newInstance,
-  extend: extend,
-  Mode: Mode,
-  Defaults: Defaults
+  newInstance,
+  extend,
+  Mode,
+  Defaults
 };
 
 export { Mode, vtkLookupTableProxy$1 as default, newInstance };

package/Proxy/Core/PiecewiseFunctionProxy/Constants.js

@@ -1,4 +1,4 @@
-var Defaults = {
+const Defaults = {
   Gaussians: [{
     position: 0.5,
     height: 1,
@@ -19,14 +19,14 @@ var Defaults = {
     sharpness: 0
   }]
 };
-var Mode = {
+const Mode = {
   Gaussians: 0,
   Points: 1,
   Nodes: 2
 };
 var Constants = {
-  Defaults: Defaults,
-  Mode: Mode
+  Defaults,
+  Mode
 };
 
 export { Constants as default };