@kitware/vtk.js 28.10.1 → 28.11.0

package/IO/Misc/PDBReader.js

@@ -1,5 +1,4 @@
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkMolecule from '../../Common/DataModel/Molecule.js';
 import DataAccessHelper from '../Core/DataAccessHelper.js';
 import { A as ATOMS } from '../../Utilities/XMLConverter/chemistry-mapper/elements.json.js';
@@ -8,101 +7,101 @@ import '../Core/DataAccessHelper/LiteHttpDataAccessHelper.js';
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/HttpDataAccessHelper'; // HTTP + gz
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/HtmlDataAccessHelper'; // html + base64 + zip
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/JSZipDataAccessHelper'; // zip
+
 // ----------------------------------------------------------------------------
 // vtkPDBReader methods
 // ----------------------------------------------------------------------------
 
 function vtkPDBReader(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkPDBReader'); // Create default dataAccessHelper if not available
+  model.classHierarchy.push('vtkPDBReader');
 
+  // Create default dataAccessHelper if not available
   if (!model.dataAccessHelper) {
     model.dataAccessHelper = DataAccessHelper.get('http');
-  } // Internal method to fetch Array
-
+  }
 
+  // Internal method to fetch Array
   function fetchPDB(url, option) {
     return model.dataAccessHelper.fetchText(publicAPI, url, option);
-  } // Set DataSet url
+  }
 
-
-  publicAPI.setUrl = function (url, option) {
+  // Set DataSet url
+  publicAPI.setUrl = (url, option) => {
     if (url.indexOf('.pdb') === -1) {
       model.baseURL = url;
-      model.url = "".concat(url); // `${url}/index.pdb`;
+      model.url = `${url}`; // `${url}/index.pdb`;
     } 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 metadata
-
+    }
 
+    // Fetch metadata
     return publicAPI.loadData(option);
-  }; // Fetch the actual data arrays
-
-
-  publicAPI.loadData = function (option) {
-    return fetchPDB(model.url, option).then(publicAPI.parseAsText);
   };
 
-  publicAPI.parseAsText = function (txt) {
+  // Fetch the actual data arrays
+  publicAPI.loadData = option => fetchPDB(model.url, option).then(publicAPI.parseAsText);
+  publicAPI.parseAsText = txt => {
     model.pdb = txt;
     model.molecule = [];
     model.molecule = model.pdb.split('\n');
     publicAPI.modified();
     return true;
   };
-
-  publicAPI.requestData = function (inData, outData) {
-    var moleculedata = vtkMolecule.newInstance();
-
+  publicAPI.requestData = (inData, outData) => {
+    const moleculedata = vtkMolecule.newInstance();
     if (model.molecule) {
-      var jSize = model.molecule.length; // atom position
+      const jSize = model.molecule.length;
 
-      var pointValues = []; // atomicNumber
+      // atom position
+      const pointValues = [];
 
-      var atomicNumber = [];
+      // atomicNumber
+      const atomicNumber = [];
       model.numberOfAtoms = 0;
-      var j = 0;
-
+      let j = 0;
       while (j < jSize && model.molecule[j] !== 'END') {
-        var iSize = model.molecule[j].length;
-        var linebuf = model.molecule[j];
-        var command = linebuf.substr(0, 6).replace(/\s+/g, '');
-        command.toUpperCase(); // Parse lines
+        const iSize = model.molecule[j].length;
+        const linebuf = model.molecule[j];
+        const command = linebuf.substr(0, 6).replace(/\s+/g, '');
+        command.toUpperCase();
 
+        // Parse lines
         if (command === 'ATOM' || command === 'HETATM') {
-          var dum1 = linebuf.substr(12, 4).replace(/\s+/g, ''); // const dum2 = (linebuf.substr(17, 3)).replace(/\s+/g, '');
+          const dum1 = linebuf.substr(12, 4).replace(/\s+/g, '');
+          // const dum2 = (linebuf.substr(17, 3)).replace(/\s+/g, '');
           // const chain = (linebuf.substr(21, 1)).replace(/\s+/g, '');
           // const resi = ((linebuf.substr(22, 8)).replace(/\s+/g, '')).replace(/\D/g, '');
-
-          var x = linebuf.substr(30, 8).replace(/\s+/g, '');
-          var y = linebuf.substr(38, 8).replace(/\s+/g, '');
-          var z = linebuf.substr(46, 8).replace(/\s+/g, '');
-          var elem = '';
-
+          const x = linebuf.substr(30, 8).replace(/\s+/g, '');
+          const y = linebuf.substr(38, 8).replace(/\s+/g, '');
+          const z = linebuf.substr(46, 8).replace(/\s+/g, '');
+          let elem = '';
           if (iSize >= 78) {
             elem = linebuf.substr(76, 2).replace(/\s+/g, '');
           }
-
           if (elem === '') {
             // if element symbol was not specified, just use the "Atom name".
             elem = dum1.substr(0, 2).replace(/\d/g, '');
-          } // fill polydata
-          // atoms position
-
+          }
 
+          // fill polydata
+          // atoms position
           pointValues.push(x);
           pointValues.push(y);
-          pointValues.push(z); // fetch data from the element database elements.json
+          pointValues.push(z);
 
-          var _ATOMS$elem = _slicedToArray(ATOMS[elem], 1),
-              atomicNumberData = _ATOMS$elem[0]; // atoms atomicNumber
+          // fetch data from the element database elements.json
+          const [atomicNumberData] = ATOMS[elem];
 
+          // atoms atomicNumber
+          atomicNumber.push(atomicNumberData);
 
-          atomicNumber.push(atomicNumberData); // residue.push(resi);
+          // residue.push(resi);
           // chain.push(chain);
           // atomType.push(elem);
           // atomTypeStrings.push(dum1);
@@ -129,58 +128,61 @@ function vtkPDBReader(publicAPI, model) {
           helix.push(tuple);
         }
         */
-
-
         j++;
       } // lines loop (j)
-      // fill molecule class
-
 
+      // fill molecule class
       moleculedata.getAtoms().elements = {};
       moleculedata.getAtoms().elements.number = Int8Array.from(atomicNumber);
       moleculedata.getAtoms().coords = {};
       moleculedata.getAtoms().coords['3d'] = Float32Array.from(pointValues);
     } // if model.molecule
 
-
     model.output[0] = moleculedata;
-  }; // return Busy state
+  };
 
+  // return Busy state
+  publicAPI.isBusy = () => !!model.requestCount;
+}
 
-  publicAPI.isBusy = function () {
-    return !!model.requestCount;
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   numberOfAtoms: 0,
-  requestCount: 0 // baseURL: null,
+  requestCount: 0
+  // baseURL: null,
   // dataAccessHelper: null,
   // url: 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
   macro.obj(publicAPI, model);
   macro.get(publicAPI, model, ['url', 'baseURL', 'numberOfAtoms', 'requestCount']);
   macro.setGet(publicAPI, model, ['dataAccessHelper']);
   macro.algo(publicAPI, model, 0, 1);
-  macro.event(publicAPI, model, 'busy'); // Object methods
+  macro.event(publicAPI, model, 'busy');
 
+  // Object methods
   vtkPDBReader(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkPDBReader'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkPDBReader');
+
+// ----------------------------------------------------------------------------
 
 var vtkPDBReader$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkPDBReader$1 as default, extend, newInstance };

package/IO/Misc/SkyboxReader.js

@@ -1,122 +1,114 @@
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import ImageHelper from '../../Common/Core/ImageHelper.js';
 import vtkTexture from '../../Rendering/Core/Texture.js';
 import { unzipSync, strFromU8 } from 'fflate';
 
+// ----------------------------------------------------------------------------
 // vtkSkyboxReader methods
 // ----------------------------------------------------------------------------
 
 function vtkSkyboxReader(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkSkyboxReader'); // Internal method to fetch Array
+  model.classHierarchy.push('vtkSkyboxReader');
 
+  // Internal method to fetch Array
   function fetchData(url) {
-    var compression = model.compression,
-        progressCallback = model.progressCallback;
+    const {
+      compression,
+      progressCallback
+    } = model;
     return model.dataAccessHelper.fetchBinary(url, {
-      compression: compression,
-      progressCallback: progressCallback
+      compression,
+      progressCallback
     });
-  } // Set DataSet url
-
+  }
 
+  // Set DataSet url
   publicAPI.setUrl = function (url) {
-    var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    model.url = url; // Fetch metadata
+    let option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    model.url = url;
 
+    // Fetch metadata
     return publicAPI.loadData(option);
-  }; // Fetch the actual data arrays
-
+  };
 
+  // Fetch the actual data arrays
   publicAPI.loadData = function () {
     return fetchData(model.url).then(publicAPI.parseAsArrayBuffer);
   };
-
-  publicAPI.parseAsArrayBuffer = function (content) {
+  publicAPI.parseAsArrayBuffer = content => {
     if (!content) {
       return false;
     }
-
     model.textures = {};
     model.busy = true;
     publicAPI.invokeBusy(model.busy);
     model.dataMapping = {};
-    var imageReady = []; // Finish data processing
+    const imageReady = [];
 
+    // Finish data processing
     function workDone() {
-      for (var i = 0; i < model.positions.length; i++) {
-        var key = model.positions[i];
-        var images = model.dataMapping[key];
-
+      for (let i = 0; i < model.positions.length; i++) {
+        const key = model.positions[i];
+        const images = model.dataMapping[key];
         if (!model.textures[key]) {
           model.textures[key] = vtkTexture.newInstance({
             interpolate: true
           });
         }
-
         if (images) {
-          var texture = model.textures[key];
-
-          for (var idx = 0; idx < 6; idx++) {
-            var _model$faceMapping$id = model.faceMapping[idx],
-                fileName = _model$faceMapping$id.fileName,
-                transform = _model$faceMapping$id.transform;
-            var readyIndex = imageReady.indexOf("".concat(key, "/").concat(fileName));
-
+          const texture = model.textures[key];
+          for (let idx = 0; idx < 6; idx++) {
+            const {
+              fileName,
+              transform
+            } = model.faceMapping[idx];
+            const readyIndex = imageReady.indexOf(`${key}/${fileName}`);
             if (readyIndex !== -1) {
-              texture.setInputData(ImageHelper.imageToImageData(images[fileName], transform), idx); // Free image
+              texture.setInputData(ImageHelper.imageToImageData(images[fileName], transform), idx);
 
+              // Free image
               URL.revokeObjectURL(images[fileName].src);
-              delete images[fileName]; // Don't process again
+              delete images[fileName];
 
+              // Don't process again
               imageReady.splice(readyIndex, 1);
             }
           }
         }
       }
-
       model.busy = false;
       publicAPI.modified();
       publicAPI.invokeBusy(model.busy);
     }
-
-    var decompressedFiles = unzipSync(new Uint8Array(content));
-    var pending = []; // Find root index.json
-
-    Object.entries(decompressedFiles).forEach(function (_ref) {
-      var _ref2 = _slicedToArray(_ref, 2),
-          relativePath = _ref2[0],
-          fileData = _ref2[1];
-
+    const decompressedFiles = unzipSync(new Uint8Array(content));
+    const pending = [];
+    // Find root index.json
+    Object.entries(decompressedFiles).forEach(_ref => {
+      let [relativePath, fileData] = _ref;
       if (relativePath.match(/index.json$/)) {
-        var txt = strFromU8(fileData);
-        var config = JSON.parse(txt);
-
+        const txt = strFromU8(fileData);
+        const config = JSON.parse(txt);
         if (config.skybox && config.skybox.faceMapping) {
           model.faceMapping = config.skybox.faceMapping;
         }
-
         if (config.metadata && config.metadata.skybox && config.metadata.skybox.faceMapping) {
           model.faceMapping = config.metadata.skybox.faceMapping;
         }
       }
-
       if (relativePath.match(/\.jpg$/)) {
-        var pathTokens = relativePath.split('/');
-        var fileName = pathTokens.pop();
-        var key = pathTokens.pop();
-
+        const pathTokens = relativePath.split('/');
+        const fileName = pathTokens.pop();
+        const key = pathTokens.pop();
         if (!model.dataMapping[key]) {
           model.dataMapping[key] = {};
         }
-
-        var blob = new Blob([fileData.buffer]);
-        var img = new Image();
-        var readyKey = "".concat(key, "/").concat(fileName);
+        const blob = new Blob([fileData.buffer]);
+        const img = new Image();
+        const readyKey = `${key}/${fileName}`;
         model.dataMapping[key][fileName] = img;
-        pending.push(new Promise(function (resolve) {
-          img.onload = function () {
+        pending.push(new Promise(resolve => {
+          img.onload = () => {
             imageReady.push(readyKey);
             resolve();
           };
@@ -126,48 +118,43 @@ function vtkSkyboxReader(publicAPI, model) {
     });
     model.positions = Object.keys(model.dataMapping);
     model.position = model.positions[0];
-    Promise.all(pending).then(function () {
+    Promise.all(pending).then(() => {
       workDone();
     });
     return publicAPI.getReadyPromise();
   };
-
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     outData[0] = model.textures[model.position];
   };
-
-  publicAPI.setPosition = function (name) {
+  publicAPI.setPosition = name => {
     if (model.positions.indexOf(name) !== -1 && name !== model.position) {
       model.position = name;
       publicAPI.modified();
     }
   };
-
-  publicAPI.getReadyPromise = function () {
+  publicAPI.getReadyPromise = () => {
     if (!model.busy) {
       return Promise.resolve(publicAPI);
     }
-
-    return new Promise(function (resolve, reject) {
-      var subscription = publicAPI.onBusy(function (isBusy) {
+    return new Promise((resolve, reject) => {
+      const subscription = publicAPI.onBusy(isBusy => {
         if (!isBusy) {
           subscription.unsubscribe();
           resolve(publicAPI);
         }
       });
     });
-  }; // return Busy state
+  };
 
+  // return Busy state
+  publicAPI.isBusy = () => model.busy;
+}
 
-  publicAPI.isBusy = function () {
-    return model.busy;
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   // url: null,
   busy: false,
   // everything must be flipped in Y due to canvas
@@ -203,26 +190,34 @@ var DEFAULT_VALUES = {
       flipY: 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, ['url', 'positions', 'position']);
   macro.setGet(publicAPI, model, ['faceMapping']);
   macro.event(publicAPI, model, 'busy');
-  macro.algo(publicAPI, model, 0, 6); // Object methods
+  macro.algo(publicAPI, model, 0, 6);
 
+  // Object methods
   vtkSkyboxReader(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkSkyboxReader'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkSkyboxReader');
+
+// ----------------------------------------------------------------------------
 
 var vtkSkyboxReader$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkSkyboxReader$1 as default, extend, newInstance };

package/IO/Misc.js

@@ -9,15 +9,15 @@ import vtkPDBReader from './Misc/PDBReader.js';
 import vtkSkyboxReader from './Misc/SkyboxReader.js';
 
 var Misc = {
-  vtkElevationReader: vtkElevationReader,
-  vtkITKImageReader: vtkITKImageReader,
-  vtkITKPolyDataReader: vtkITKPolyDataReader,
-  vtkJSONNucleoReader: vtkJSONNucleoReader,
-  vtkJSONReader: vtkJSONReader,
-  vtkMTLReader: vtkMTLReader,
-  vtkOBJReader: vtkOBJReader,
-  vtkPDBReader: vtkPDBReader,
-  vtkSkyboxReader: vtkSkyboxReader
+  vtkElevationReader,
+  vtkITKImageReader,
+  vtkITKPolyDataReader,
+  vtkJSONNucleoReader,
+  vtkJSONReader,
+  vtkMTLReader,
+  vtkOBJReader,
+  vtkPDBReader,
+  vtkSkyboxReader
 };
 
 export { Misc as default };

package/IO/XML/XMLImageDataReader.js

@@ -1,70 +1,68 @@
 import vtkXMLReader from './XMLReader.js';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkImageData from '../../Common/DataModel/ImageData.js';
 
+// ----------------------------------------------------------------------------
 // vtkXMLImageDataReader methods
 // ----------------------------------------------------------------------------
 
 function vtkXMLImageDataReader(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkXMLImageDataReader');
-
-  publicAPI.parseXML = function (rootElem, type, compressor, byteOrder, headerType) {
-    var _imageDataElem$getAtt;
-
-    var imageDataElem = rootElem.getElementsByTagName(model.dataType)[0];
-    var origin = imageDataElem.getAttribute('Origin').split(' ').map(function (t) {
-      return Number(t);
-    });
-    var spacing = imageDataElem.getAttribute('Spacing').split(' ').map(function (t) {
-      return Number(t);
-    });
-    var direction = (_imageDataElem$getAtt = imageDataElem.getAttribute('Direction')) === null || _imageDataElem$getAtt === void 0 ? void 0 : _imageDataElem$getAtt.split(' ').map(function (t) {
-      return Number(t);
-    });
-    var pieces = imageDataElem.getElementsByTagName('Piece');
-    var nbPieces = pieces.length;
-
-    for (var outputIndex = 0; outputIndex < nbPieces; outputIndex++) {
+  publicAPI.parseXML = (rootElem, type, compressor, byteOrder, headerType) => {
+    const imageDataElem = rootElem.getElementsByTagName(model.dataType)[0];
+    const origin = imageDataElem.getAttribute('Origin').split(' ').map(t => Number(t));
+    const spacing = imageDataElem.getAttribute('Spacing').split(' ').map(t => Number(t));
+    const direction = imageDataElem.getAttribute('Direction')?.split(' ').map(t => Number(t));
+    const pieces = imageDataElem.getElementsByTagName('Piece');
+    const nbPieces = pieces.length;
+    for (let outputIndex = 0; outputIndex < nbPieces; outputIndex++) {
       // Create image data
-      var piece = pieces[outputIndex];
-      var extent = piece.getAttribute('Extent').split(' ').map(function (t) {
-        return Number(t);
+      const piece = pieces[outputIndex];
+      const extent = piece.getAttribute('Extent').split(' ').map(t => Number(t));
+      const imageData = vtkImageData.newInstance({
+        origin,
+        spacing,
+        direction,
+        extent
       });
-      var imageData = vtkImageData.newInstance({
-        origin: origin,
-        spacing: spacing,
-        direction: direction,
-        extent: extent
-      }); // Fill data
 
+      // Fill data
       vtkXMLReader.processFieldData(imageData.getNumberOfPoints(), piece.getElementsByTagName('PointData')[0], imageData.getPointData(), compressor, byteOrder, headerType, model.binaryBuffer);
-      vtkXMLReader.processFieldData(imageData.getNumberOfCells(), piece.getElementsByTagName('CellData')[0], imageData.getCellData(), compressor, byteOrder, headerType, model.binaryBuffer); // Add new output
+      vtkXMLReader.processFieldData(imageData.getNumberOfCells(), piece.getElementsByTagName('CellData')[0], imageData.getCellData(), compressor, byteOrder, headerType, model.binaryBuffer);
 
+      // Add new output
       model.output[outputIndex] = imageData;
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   dataType: 'ImageData'
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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);
   vtkXMLReader.extend(publicAPI, model, initialValues);
   vtkXMLImageDataReader(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkXMLImageDataReader'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkXMLImageDataReader');
+
+// ----------------------------------------------------------------------------
 
 var vtkXMLImageDataReader$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkXMLImageDataReader$1 as default, extend, newInstance };