@kitware/vtk.js 28.10.2 → 28.11.0

package/IO/Core/HttpSceneLoader.js

@@ -1,6 +1,4 @@
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkActor from '../../Rendering/Core/Actor.js';
 import vtkVolume from '../../Rendering/Core/Volume.js';
 import vtkHttpDataSetReader from './HttpDataSetReader.js';
@@ -16,49 +14,41 @@ import vtkTimeStepBasedAnimationHandler from '../../Interaction/Animations/TimeS
 import DataAccessHelper from './DataAccessHelper.js';
 import './DataAccessHelper/LiteHttpDataAccessHelper.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; }
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/HttpDataAccessHelper'; // HTTP + zip
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/HtmlDataAccessHelper'; // html + base64 + zip
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/JSZipDataAccessHelper'; // zip
 
-var vtkErrorMacro = macro.vtkErrorMacro;
-var itemCount = 1;
-
+const {
+  vtkErrorMacro
+} = macro;
+let itemCount = 1;
 function applySettings(sceneItem, settings) {
   if (settings.actor) {
     sceneItem.actor.set(settings.actor);
   }
-
   if (settings.actorRotation) {
     sceneItem.actor.rotateWXYZ(settings.actorRotation[0], settings.actorRotation[1], settings.actorRotation[2], settings.actorRotation[3]);
   }
-
   if (settings.volumeRotation) {
     sceneItem.volume.rotateWXYZ(settings.volumeRotation[0], settings.volumeRotation[1], settings.volumeRotation[2], settings.volumeRotation[3]);
   }
-
   if (settings.property) {
     if (settings.volume) {
-      var volumePropertySettings = _objectSpread({}, settings.property);
-
+      const volumePropertySettings = {
+        ...settings.property
+      };
       delete volumePropertySettings.components;
       sceneItem.volume.getProperty().set(volumePropertySettings);
-
       if (settings.property.components) {
-        var volumeProperty = sceneItem.volume.getProperty();
-        sceneItem.volumeComponents.forEach(function (component, componentIndex) {
+        const volumeProperty = sceneItem.volume.getProperty();
+        sceneItem.volumeComponents.forEach((component, componentIndex) => {
           volumeProperty.setScalarOpacityUnitDistance(componentIndex, settings.property.components[componentIndex].scalarOpacityUnitDistance);
-
           if (component.rgbTransferFunction) {
             volumeProperty.setRGBTransferFunction(componentIndex, component.rgbTransferFunction);
           }
-
           if (component.grayTransferFunction) {
             volumeProperty.setGrayTransferFunction(componentIndex, component.grayTransferFunction);
           }
-
           if (component.scalarOpacity) {
             volumeProperty.setScalarOpacity(componentIndex, component.scalarOpacity);
           }
@@ -68,298 +58,255 @@ function applySettings(sceneItem, settings) {
       sceneItem.actor.getProperty().set(settings.property);
     }
   }
-
   if (settings.mapper) {
     if (settings.mapper.colorByArrayName) {
       sceneItem.source.enableArray(settings.mapper.colorByArrayName, settings.mapper.colorByArrayName);
       sceneItem.source.loadData();
     }
-
     sceneItem.mapper.set(settings.mapper);
-
     if (settings.mapper.colorByArrayName && settings.luts[settings.mapper.colorByArrayName]) {
       sceneItem.mapper.setLookupTable(settings.luts[settings.mapper.colorByArrayName]);
       sceneItem.mapper.setUseLookupTableScalarRange(true);
     }
   }
-
   if (settings.lookupTable) {
     sceneItem.mapper.getLookupTable().set(settings.lookupTable);
     sceneItem.mapper.getLookupTable().build();
   }
-
   if (settings.textureLODs) {
     sceneItem.textureLODs = settings.textureLODs;
   }
-
   if (settings.sourceLODs) {
     sceneItem.sourceLODs = settings.sourceLODs;
   }
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
 
-
 function isImage(str) {
-  var ext = str.split('.').pop().toLowerCase();
+  const ext = str.split('.').pop().toLowerCase();
   return ['jpg', 'png', 'jpeg'].indexOf(ext) !== -1;
 }
-
 function loadColorTransferFunction(item) {
-  var tf = vtkColorTransferFunction.newInstance(item);
-
+  const tf = vtkColorTransferFunction.newInstance(item);
   if (item.nodes) {
     tf.removeAllPoints();
-    item.nodes.forEach(function (_ref) {
-      var _ref2 = _slicedToArray(_ref, 6),
-          x = _ref2[0],
-          r = _ref2[1],
-          g = _ref2[2],
-          b = _ref2[3],
-          midpoint = _ref2[4],
-          sharpness = _ref2[5];
-
+    item.nodes.forEach(_ref => {
+      let [x, r, g, b, midpoint, sharpness] = _ref;
       tf.addRGBPointLong(x, r, g, b, midpoint, sharpness);
     });
   }
-
   return tf;
 }
-
 function loadPiecewiseFunction(item) {
-  var pwf = vtkPiecewiseFunction.newInstance(item);
-
+  const pwf = vtkPiecewiseFunction.newInstance(item);
   if (item.points) {
     pwf.removeAllPoints();
-    item.points.forEach(function (_ref3) {
-      var _ref4 = _slicedToArray(_ref3, 4),
-          x = _ref4[0],
-          y = _ref4[1],
-          midpoint = _ref4[2],
-          sharpness = _ref4[3];
-
+    item.points.forEach(_ref2 => {
+      let [x, y, midpoint, sharpness] = _ref2;
       return pwf.addPointLong(x, y, midpoint, sharpness);
     });
   }
-
   return pwf;
 }
-
 function initializeVolumeComponents(components) {
-  return components.map(function (component) {
-    var ret = {};
-
+  return components.map(component => {
+    const ret = {};
     if (component.rgbTransferFunction) {
       ret.rgbTransferFunction = loadColorTransferFunction(component.rgbTransferFunction);
     } else if (component.grayTransferFunction) {
       ret.grayTransferFunction = loadPiecewiseFunction(component.grayTransferFunction);
     }
-
     if (component.scalarOpacity) {
       ret.scalarOpacity = loadPiecewiseFunction(component.scalarOpacity);
     }
-
     return ret;
   });
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
 function defineLoadFuctionForReader(type) {
-  return function (item, model, publicAPI) {
-    var source = type.newInstance({
+  return (item, model, publicAPI) => {
+    const source = type.newInstance({
       fetchGzip: model.fetchGzip,
       dataAccessHelper: model.dataAccessHelper
     });
-    var mapper;
-
+    let mapper;
     if (item.volume) {
       mapper = vtkVolumeMapper.newInstance();
     } else {
       mapper = vtkMapper.newInstance();
     }
-
-    var sceneItem = {
-      name: item.name || "Item ".concat(itemCount++),
-      source: source,
-      mapper: mapper,
+    const sceneItem = {
+      name: item.name || `Item ${itemCount++}`,
+      source,
+      mapper,
       defaultSettings: item
     };
-
     if (item.volume) {
-      var volume = vtkVolume.newInstance();
+      const volume = vtkVolume.newInstance();
       sceneItem.volume = volume;
-
       if (model.renderer) {
         model.renderer.addVolume(volume);
       }
-
       if (item.property && item.property.components) {
         // initialize transfer functions
         sceneItem.volumeComponents = initializeVolumeComponents(item.property.components);
       }
-
       volume.setMapper(mapper);
     } else {
-      var actor = vtkActor.newInstance();
+      const actor = vtkActor.newInstance();
       sceneItem.actor = actor;
-
       if (item.texture && item.texture in model.usedTextures) {
         // If this texture has already been used, re-use it
         actor.addTexture(model.usedTextures[item.texture]);
       } else if (item.texture) {
-        var url = [model.baseURL, item.texture].join('/');
-        var texture = vtkTexture.newInstance();
+        const url = [model.baseURL, item.texture].join('/');
+        const texture = vtkTexture.newInstance();
         texture.setInterpolate(true);
         texture.setRepeat(true);
         actor.addTexture(texture);
         sceneItem.texture = texture;
         model.usedTextures[item.texture] = texture;
-
         if (isImage(item.texture)) {
           // It's an image file
           model.dataAccessHelper.fetchImage({}, url, {
             crossOrigin: 'anonymous'
-          }).then(function (img) {
+          }).then(img => {
             texture.setImage(img);
           });
         } else {
           // Assume it's a dataset file
-          var textureSource = type.newInstance({
+          const textureSource = type.newInstance({
             fetchGzip: model.fetchGzip,
             dataAccessHelper: model.dataAccessHelper
           });
           textureSource.setUrl(url, {
             loadData: true
-          }).then(function () {
+          }).then(() => {
             texture.setInputData(textureSource.getOutputData());
           });
         }
       }
-
-      var textureLODs = item.textureLODs;
-
+      const {
+        textureLODs
+      } = item;
       if (textureLODs && textureLODs.files && textureLODs.files.length !== 0) {
         // If this texture LOD has already been used, re-use it
-        var textureLODsStr = JSON.stringify(textureLODs);
-
+        const textureLODsStr = JSON.stringify(textureLODs);
         if (textureLODsStr in model.usedTextureLODs) {
           actor.addTexture(model.usedTextureLODs[textureLODsStr]);
         } else {
           // Set it on the scene item so it can be accessed later, for
           // doing things like setting a callback function.
           sceneItem.textureLODsDownloader = vtkTextureLODsDownloader.newInstance();
-          var textureDownloader = sceneItem.textureLODsDownloader;
-
-          var _texture = vtkTexture.newInstance();
-
-          _texture.setInterpolate(true);
-
-          actor.addTexture(_texture);
-          model.usedTextureLODs[textureLODsStr] = _texture;
-          textureDownloader.setTexture(_texture);
+          const textureDownloader = sceneItem.textureLODsDownloader;
+          const texture = vtkTexture.newInstance();
+          texture.setInterpolate(true);
+          actor.addTexture(texture);
+          model.usedTextureLODs[textureLODsStr] = texture;
+          textureDownloader.setTexture(texture);
           textureDownloader.setCrossOrigin('anonymous');
           textureDownloader.setBaseUrl(textureLODs.baseUrl);
           textureDownloader.setFiles(textureLODs.files);
-
           if (model.startLODLoaders) {
             textureDownloader.startDownloads();
           }
         }
       }
-
       if (model.renderer) {
         model.renderer.addActor(actor);
       }
-
       actor.setMapper(mapper);
     }
-
     mapper.setInputConnection(source.getOutputPort());
     source.setUrl([model.baseURL, item[item.type].url].join('/'), {
       loadData: true
-    }).then(function () {
-      return publicAPI.invokeReady();
-    });
+    }).then(() => publicAPI.invokeReady());
     applySettings(sceneItem, item);
     model.scene.push(sceneItem);
-    var sourceLODs = item.sourceLODs;
-
+    const {
+      sourceLODs
+    } = item;
     if (sourceLODs && sourceLODs.files && sourceLODs.files.length !== 0) {
       // Set it on the scene item so it can be accessed later, for
       // doing things like setting a callback function.
       sceneItem.dataSetLODsLoader = vtkHttpDataSetLODsLoader.newInstance();
-      var dataSetLODsLoader = sceneItem.dataSetLODsLoader;
+      const {
+        dataSetLODsLoader
+      } = sceneItem;
       dataSetLODsLoader.setMapper(mapper);
       dataSetLODsLoader.setSceneItem(sceneItem);
       dataSetLODsLoader.setBaseUrl(sourceLODs.baseUrl);
       dataSetLODsLoader.setFiles(sourceLODs.files);
-
       if (model.startLODLoaders) {
         dataSetLODsLoader.startDownloads();
       }
     }
-
     return sceneItem;
   };
 }
-
 function loadTimeStepBasedAnimationHandler(data, model) {
   model.animationHandler = vtkTimeStepBasedAnimationHandler.newInstance({
     scene: model.scene,
     originalMetadata: model.metadata,
-    applySettings: applySettings
+    applySettings
   });
-
   if (model.animationHandler && model.renderer) {
     model.animationHandler.addRenderer(model.renderer);
   }
-
   model.animationHandler.setData(data);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Note: keeping both types (with and without 'vtk' prefix) for backwards compatibility
 // see https://gitlab.kitware.com/paraview/paraview/-/merge_requests/4628#note_876772
 
-
-var TYPE_MAPPING = {
+const TYPE_MAPPING = {
   httpDataSetReader: defineLoadFuctionForReader(vtkHttpDataSetReader),
   vtkHttpDataSetReader: defineLoadFuctionForReader(vtkHttpDataSetReader),
   httpDataSetSeriesReader: defineLoadFuctionForReader(vtkHttpDataSetSeriesReader),
   vtkHttpDataSetSeriesReader: defineLoadFuctionForReader(vtkHttpDataSetSeriesReader)
 };
-var ANIMATION_TYPE_MAPPING = {
+const ANIMATION_TYPE_MAPPING = {
   timeStepBasedAnimationHandler: loadTimeStepBasedAnimationHandler,
   vtkTimeStepBasedAnimationHandler: loadTimeStepBasedAnimationHandler
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function updateDatasetTypeMapping(typeName, handler) {
   TYPE_MAPPING[typeName] = handler;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // vtkHttpSceneLoader methods
 // ----------------------------------------------------------------------------
 
-
 function vtkHttpSceneLoader(publicAPI, model) {
-  var originalSceneParameters = {}; // These are here to re-use the same textures when possible
+  const originalSceneParameters = {};
 
+  // These are here to re-use the same textures when possible
   if (!model.usedTextures) {
     model.usedTextures = {};
   }
-
   if (!model.usedTextureLODs) {
     model.usedTextureLODs = {};
-  } // Set our className
-
+  }
 
-  model.classHierarchy.push('vtkHttpSceneLoader'); // Create scene container
+  // Set our className
+  model.classHierarchy.push('vtkHttpSceneLoader');
 
+  // Create scene container
   if (!model.scene) {
     model.scene = [];
   }
-
   function setCameraParameters(params) {
     if (model.renderer) {
-      var camera = model.renderer.getActiveCamera();
-
+      const camera = model.renderer.getActiveCamera();
       if (camera) {
         camera.set(params);
       } else {
@@ -367,99 +314,95 @@ function vtkHttpSceneLoader(publicAPI, model) {
       }
     }
   }
-
   function setBackground(color) {
     if (model.renderer) {
       model.renderer.setBackground(color);
     }
-  } // Create default dataAccessHelper if not available
-
+  }
 
+  // Create default dataAccessHelper if not available
   if (!model.dataAccessHelper) {
     model.dataAccessHelper = DataAccessHelper.get('http');
   }
-
-  publicAPI.update = function () {
-    model.dataAccessHelper.fetchJSON(publicAPI, model.url).then(function (data) {
+  publicAPI.update = () => {
+    model.dataAccessHelper.fetchJSON(publicAPI, model.url).then(data => {
       if (data.fetchGzip !== undefined) {
         model.fetchGzip = data.fetchGzip;
       }
-
       if (data.background && model.renderer) {
         setBackground(data.background);
       }
-
       if (data.camera) {
         originalSceneParameters.camera = data.camera;
         setCameraParameters(data.camera);
       }
-
-      var luts = {};
-
+      const luts = {};
       if (data.lookupTables) {
-        Object.keys(data.lookupTables).forEach(function (fieldName) {
-          var config = data.lookupTables[fieldName];
-          var lookupTable = loadColorTransferFunction(config);
+        Object.keys(data.lookupTables).forEach(fieldName => {
+          const config = data.lookupTables[fieldName];
+          const lookupTable = loadColorTransferFunction(config);
           luts[fieldName] = lookupTable;
         });
       }
-
       if (data.scene) {
-        data.scene.forEach(function (item) {
-          var builder = TYPE_MAPPING[item.type];
-
+        data.scene.forEach(item => {
+          const builder = TYPE_MAPPING[item.type];
           if (builder) {
-            builder(_objectSpread({
-              luts: luts
-            }, item), model, publicAPI);
+            builder({
+              luts,
+              ...item
+            }, model, publicAPI);
           }
         });
-        global.scene = model.scene; // Clear these
+        global.scene = model.scene;
 
+        // Clear these
         model.usedTextures = {};
         model.usedTextureLODs = {};
-      } // Capture index.json into meta
-
+      }
 
+      // Capture index.json into meta
       model.metadata = data;
-
       if (data.animation) {
-        var animationLoader = ANIMATION_TYPE_MAPPING[data.animation.type];
-        animationLoader(_objectSpread({}, data.animation), model, publicAPI, setCameraParameters, setBackground);
+        const animationLoader = ANIMATION_TYPE_MAPPING[data.animation.type];
+        animationLoader({
+          ...data.animation
+        }, model, publicAPI, setCameraParameters, setBackground);
       }
-    }, function (error) {
-      vtkErrorMacro("Error fetching scene ".concat(error));
+    }, error => {
+      vtkErrorMacro(`Error fetching scene ${error}`);
     });
   };
-
-  publicAPI.resetScene = function () {
+  publicAPI.resetScene = () => {
     if (originalSceneParameters.camera) {
       setCameraParameters(originalSceneParameters.camera);
     }
-  }; // Set DataSet url
-
+  };
 
-  publicAPI.setUrl = function (url) {
+  // Set DataSet url
+  publicAPI.setUrl = url => {
     if (url.indexOf('index.json') === -1) {
       model.baseURL = url;
-      model.url = "".concat(url, "/index.json");
+      model.url = `${url}/index.json`;
     } else {
-      model.url = url; // Remove the file in the URL
+      model.url = url;
 
-      var path = url.split('/');
+      // Remove the file in the URL
+      const path = url.split('/');
       path.pop();
       model.baseURL = path.join('/');
-    } // Fetch data
-
+    }
 
+    // Fetch data
     return publicAPI.update();
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   fetchGzip: false,
   url: null,
   baseURL: null,
@@ -467,27 +410,35 @@ var DEFAULT_VALUES = {
   // Whether or not to automatically start texture LOD and poly LOD
   // downloads when they are read.
   startLODLoaders: true
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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);
   macro.get(publicAPI, model, ['fetchGzip', 'url', 'baseURL', 'scene', 'metadata', 'animationHandler']);
   macro.setGet(publicAPI, model, ['renderer']);
-  macro.event(publicAPI, model, 'ready'); // Object methods
+  macro.event(publicAPI, model, 'ready');
 
+  // Object methods
   vtkHttpSceneLoader(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkHttpSceneLoader');
 
-var newInstance = macro.newInstance(extend, 'vtkHttpSceneLoader'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkHttpSceneLoader$1 = {
-  newInstance: newInstance,
-  extend: extend,
-  applySettings: applySettings,
-  updateDatasetTypeMapping: updateDatasetTypeMapping
+  newInstance,
+  extend,
+  applySettings,
+  updateDatasetTypeMapping
 };
 
 export { vtkHttpSceneLoader$1 as default, extend, newInstance };