@kitware/vtk.js 28.10.2 → 28.11.1

package/IO/XML/XMLWriter/Constants.js

@@ -1,9 +1,9 @@
-var FormatTypes = {
+const FormatTypes = {
   ASCII: 'ascii',
   BINARY: 'binary',
   APPENDED: 'appended'
 };
-var TYPED_ARRAY = {
+const TYPED_ARRAY = {
   Int8Array: 'Int8',
   Uint8Array: 'UInt8',
   Int16Array: 'Int16',
@@ -14,7 +14,7 @@ var TYPED_ARRAY = {
   Float64Array: 'Float64'
 };
 var Constants = {
-  FormatTypes: FormatTypes
+  FormatTypes
 };
 
 export { FormatTypes, TYPED_ARRAY, Constants as default };

package/IO/XML/XMLWriter.js

@@ -1,23 +1,21 @@
 import { create } from 'xmlbuilder2';
 import { zlibSync } from 'fflate';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import { fromArrayBuffer } from '../../Common/Core/Base64.js';
 import { FormatTypes, TYPED_ARRAY } from './XMLWriter/Constants.js';
 
+// ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
 
 function compressBlock(uncompressed) {
   return zlibSync(uncompressed);
 }
-
 function processDataArray(dataArray, format, blockSize) {
-  var compressor = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'vtkZLibDataCompressor';
-
+  let compressor = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'vtkZLibDataCompressor';
   if (format === FormatTypes.ASCII) {
     return dataArray.getData().join(' ');
   }
-
   if (format === FormatTypes.BINARY) {
     if (compressor === 'vtkZLibDataCompressor') {
       // ----------------------------------------------------------------------
@@ -28,134 +26,122 @@ function processDataArray(dataArray, format, blockSize) {
       // [header] s2: uncompress size of the last blocks
       // [header] blockSize: size of the block in compressed space that represent to bloc to inflate in zlib. (This also give the offset to the next block)
       // ----------------------------------------------------------------------
-      var componentUint8Size = dataArray.getElementComponentSize();
-      var uncompressedUint8Size = dataArray.getNumberOfValues() * componentUint8Size;
-      var blockUint8Size = blockSize;
-      var nbFullBlocks = Math.trunc(uncompressedUint8Size / blockUint8Size);
-      var lastBlockUint8Size = uncompressedUint8Size % blockUint8Size;
-      var nbBlocks = nbFullBlocks + (lastBlockUint8Size ? 1 : 0);
-      var header = new Uint32Array(3 + nbBlocks);
-      header[0] = nbBlocks; // N
 
+      const componentUint8Size = dataArray.getElementComponentSize();
+      const uncompressedUint8Size = dataArray.getNumberOfValues() * componentUint8Size;
+      const blockUint8Size = blockSize;
+      const nbFullBlocks = Math.trunc(uncompressedUint8Size / blockUint8Size);
+      const lastBlockUint8Size = uncompressedUint8Size % blockUint8Size;
+      const nbBlocks = nbFullBlocks + (lastBlockUint8Size ? 1 : 0);
+      const header = new Uint32Array(3 + nbBlocks);
+      header[0] = nbBlocks; // N
       header[1] = blockUint8Size; // s1
-
       header[2] = lastBlockUint8Size; // s2
 
-      var totalUint8Length = 0;
-      var blocks = [];
-      var dataOffset = 0;
-      var lastBlockId = nbBlocks - 1;
-
-      for (var blockId = 0; blockId < nbBlocks; ++blockId) {
-        var currentBlockUint8Size = lastBlockUint8Size === 0 || blockId < lastBlockId ? blockUint8Size : header[2];
-        var uncompressedBlock = new Uint8Array(dataArray.getData().buffer, dataOffset, currentBlockUint8Size);
+      let totalUint8Length = 0;
+      const blocks = [];
+      let dataOffset = 0;
+      const lastBlockId = nbBlocks - 1;
+      for (let blockId = 0; blockId < nbBlocks; ++blockId) {
+        const currentBlockUint8Size = lastBlockUint8Size === 0 || blockId < lastBlockId ? blockUint8Size : header[2];
+        const uncompressedBlock = new Uint8Array(dataArray.getData().buffer, dataOffset, currentBlockUint8Size);
         dataOffset += blockUint8Size;
-        var compressedUint8Block = compressBlock(uncompressedBlock);
+        const compressedUint8Block = compressBlock(uncompressedBlock);
         blocks.push(compressedUint8Block);
         header[3 + blockId] = compressedUint8Block.length;
         totalUint8Length += compressedUint8Block.length;
       }
-
-      var uint8 = new Uint8Array(totalUint8Length);
-      var uint8Offset = 0;
-      var headerUint8 = new Uint8Array(header.buffer);
-
-      for (var _blockId = 0; _blockId < nbBlocks; ++_blockId) {
-        uint8.set(blocks[_blockId], uint8Offset);
-        uint8Offset += header[3 + _blockId];
+      const uint8 = new Uint8Array(totalUint8Length);
+      let uint8Offset = 0;
+      const headerUint8 = new Uint8Array(header.buffer);
+      for (let blockId = 0; blockId < nbBlocks; ++blockId) {
+        uint8.set(blocks[blockId], uint8Offset);
+        uint8Offset += header[3 + blockId];
       }
-
       return fromArrayBuffer(headerUint8.buffer) + fromArrayBuffer(uint8.buffer);
     }
-
     throw new Error('Only vtkZLibDataCompressor is supported');
   }
-
   if (format === FormatTypes.APPENDED) {
     throw new Error('Appended format is not supported');
   }
-
   throw new Error('Format is not supported');
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // vtkXMLWriter methods
 // ----------------------------------------------------------------------------
 
-
 function vtkXMLWriter(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkXMLWriter'); // Can be overridden in subclass
-
-  publicAPI.create = function (dataObject) {
-    return create().ele('VTKFile').att('type', model.dataType).att('version', '0.1').att('byte_order', 'LittleEndian').att('header_type', 'UInt32').att('compressor', model.format === FormatTypes.ASCII ? '' : 'vtkZLibDataCompressor');
-  };
-
-  publicAPI.write = function (object) {
-    return publicAPI.create(object).end({
-      pretty: true
-    });
-  };
-
-  publicAPI.processDataSetAttributes = function (parentElement, name, datasetAttributes) {
-    var activeAttributes = {};
-    var attrTypes = ['Scalars', 'Vectors', 'Normals', 'TCoords', 'Tensors', 'GlobalIds', 'PedigreeIds'];
-    attrTypes.forEach(function (attrType) {
-      var activeAttribute = datasetAttributes.getActiveAttribute(attrType);
-
+  model.classHierarchy.push('vtkXMLWriter');
+
+  // Can be overridden in subclass
+  publicAPI.create = dataObject => create().ele('VTKFile').att('type', model.dataType).att('version', '0.1').att('byte_order', 'LittleEndian').att('header_type', 'UInt32').att('compressor', model.format === FormatTypes.ASCII ? '' : 'vtkZLibDataCompressor');
+  publicAPI.write = object => publicAPI.create(object).end({
+    pretty: true
+  });
+  publicAPI.processDataSetAttributes = (parentElement, name, datasetAttributes) => {
+    const activeAttributes = {};
+    const attrTypes = ['Scalars', 'Vectors', 'Normals', 'TCoords', 'Tensors', 'GlobalIds', 'PedigreeIds'];
+    attrTypes.forEach(attrType => {
+      const activeAttribute = datasetAttributes.getActiveAttribute(attrType);
       if (activeAttribute) {
         activeAttributes[attrType] = activeAttribute.getName();
       }
     });
-    var datasetAttributesEle = parentElement.ele(name, activeAttributes);
-
-    for (var i = 0; i < datasetAttributes.getNumberOfArrays(); ++i) {
+    const datasetAttributesEle = parentElement.ele(name, activeAttributes);
+    for (let i = 0; i < datasetAttributes.getNumberOfArrays(); ++i) {
       publicAPI.processDataArray(datasetAttributesEle, datasetAttributes.getArrayByIndex(i));
     }
-
     return datasetAttributesEle;
   };
-
-  publicAPI.processDataArray = function (parentEle, scalars) {
-    return parentEle.ele('DataArray', {
-      type: TYPED_ARRAY[scalars.getDataType()],
-      Name: scalars.getName(),
-      format: publicAPI.getFormat(),
-      RangeMin: scalars.getRange()[0],
-      RangeMax: scalars.getRange()[1],
-      NumberOfComponents: scalars.getNumberOfComponents()
-    }).txt(processDataArray(scalars, publicAPI.getFormat(), publicAPI.getBlockSize()));
-  };
-
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.processDataArray = (parentEle, scalars) => parentEle.ele('DataArray', {
+    type: TYPED_ARRAY[scalars.getDataType()],
+    Name: scalars.getName(),
+    format: publicAPI.getFormat(),
+    RangeMin: scalars.getRange()[0],
+    RangeMax: scalars.getRange()[1],
+    NumberOfComponents: scalars.getNumberOfComponents()
+  }).txt(processDataArray(scalars, publicAPI.getFormat(), publicAPI.getBlockSize()));
+  publicAPI.requestData = (inData, outData) => {
     model.file = publicAPI.write(inData);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   blockSize: 1024,
   // file: null,
   format: FormatTypes.BINARY
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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.setGet(publicAPI, model, ['blockSize', 'format']);
   macro.get(publicAPI, model, ['file']);
-  macro.algo(publicAPI, model, 1, 0); // vtkXMLWriter methods
+  macro.algo(publicAPI, model, 1, 0);
 
+  // vtkXMLWriter methods
   vtkXMLWriter(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
 var vtkXMLWriter$1 = {
-  extend: extend,
-  compressBlock: compressBlock,
-  processDataArray: processDataArray,
-  FormatTypes: FormatTypes
+  extend,
+  compressBlock,
+  processDataArray,
+  FormatTypes
 };
 
 export { vtkXMLWriter$1 as default, extend };

package/IO/XML.js

@@ -6,12 +6,12 @@ import vtkXMLReader from './XML/XMLReader.js';
 import vtkXMLWriter from './XML/XMLWriter.js';
 
 var XML = {
-  vtkXMLImageDataReader: vtkXMLImageDataReader,
-  vtkXMLImageDataWriter: vtkXMLImageDataWriter,
-  vtkXMLPolyDataReader: vtkXMLPolyDataReader,
-  vtkXMLPolyDataWriter: vtkXMLPolyDataWriter,
-  vtkXMLReader: vtkXMLReader,
-  vtkXMLWriter: vtkXMLWriter
+  vtkXMLImageDataReader,
+  vtkXMLImageDataWriter,
+  vtkXMLPolyDataReader,
+  vtkXMLPolyDataWriter,
+  vtkXMLReader,
+  vtkXMLWriter
 };
 
 export { XML as default };

package/IO/index.js

@@ -5,11 +5,11 @@ import Misc from './Misc.js';
 import XML from './XML.js';
 
 var IO = {
-  Core: Core,
-  Geometry: Geometry,
-  Legacy: Legacy,
-  Misc: Misc,
-  XML: XML
+  Core,
+  Geometry,
+  Legacy,
+  Misc,
+  XML
 };
 
 export { IO as default };

package/Imaging/Core/AbstractImageInterpolator/Constants.js

@@ -1,16 +1,16 @@
-var ImageBorderMode = {
+const ImageBorderMode = {
   CLAMP: 0,
   REPEAT: 1,
   MIRROR: 2
 };
-var InterpolationMode = {
+const InterpolationMode = {
   NEAREST: 0,
   LINEAR: 1,
   CUBIC: 2
 };
 var Constants = {
-  ImageBorderMode: ImageBorderMode,
-  InterpolationMode: InterpolationMode
+  ImageBorderMode,
+  InterpolationMode
 };
 
 export { ImageBorderMode, InterpolationMode, Constants as default };

package/Imaging/Core/AbstractImageInterpolator/InterpolationInfo.js

@@ -1,10 +1,6 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { ImageBorderMode, InterpolationMode } from './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; }
-
-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 vtkInterpolationInfo = {
+const vtkInterpolationInfo = {
   pointer: null,
   extent: [0, -1, 0, -1, 0, -1],
   increments: [0, 0, 0],
@@ -17,7 +13,8 @@ var vtkInterpolationInfo = {
   interpolationMode: InterpolationMode.LINEAR,
   extraInfo: null
 };
-var vtkInterpolationWeights = _objectSpread(_objectSpread({}, vtkInterpolationInfo), {}, {
+const vtkInterpolationWeights = {
+  ...vtkInterpolationInfo,
   positions: [0, 0, 0],
   weights: null,
   weightExtent: [0, -1, 0, -1, 0, -1],
@@ -25,9 +22,9 @@ var vtkInterpolationWeights = _objectSpread(_objectSpread({}, vtkInterpolationIn
   workspace: null,
   lastY: null,
   lastZ: null
-});
+};
 function vtkInterpolationMathFloor(x) {
-  var integer = Math.floor(x);
+  const integer = Math.floor(x);
   return {
     floored: integer,
     error: x - integer
@@ -35,45 +32,51 @@ function vtkInterpolationMathFloor(x) {
 }
 function vtkInterpolationMathRound(x) {
   return Math.round(x);
-} //----------------------------------------------------------------------------
+}
+
+//----------------------------------------------------------------------------
 // Perform a clamp to limit an index to [b, c] and subtract b.
 
 function vtkInterpolationMathClamp(a, b, c) {
-  var clamp = a <= c ? a : c;
+  let clamp = a <= c ? a : c;
   clamp -= b;
   clamp = clamp >= 0 ? clamp : 0;
   return clamp;
-} //----------------------------------------------------------------------------
+}
+
+//----------------------------------------------------------------------------
 // Perform a wrap to limit an index to [b, c] and subtract b.
 
 function vtkInterpolationMathWrap(a, b, c) {
-  var range = c - b + 1;
-  var wrap = a - b;
-  wrap %= range; // required for some % implementations
-
+  const range = c - b + 1;
+  let wrap = a - b;
+  wrap %= range;
+  // required for some % implementations
   wrap = wrap >= 0 ? wrap : wrap + range;
   return wrap;
-} //----------------------------------------------------------------------------
+}
+
+//----------------------------------------------------------------------------
 // Perform a mirror to limit an index to [b, c] and subtract b.
 
 function vtkInterpolationMathMirror(a, b, c) {
-  var range = c - b;
-  var ifzero = range === 0 ? 1 : 0;
-  var range2 = 2 * range + ifzero;
-  var mirror = a - b;
+  const range = c - b;
+  const ifzero = range === 0 ? 1 : 0;
+  const range2 = 2 * range + ifzero;
+  let mirror = a - b;
   mirror = mirror >= 0 ? mirror : -mirror;
   mirror %= range2;
   mirror = mirror <= range ? mirror : range2 - mirror;
   return mirror;
 }
 var InterpolationInfo = {
-  vtkInterpolationInfo: vtkInterpolationInfo,
-  vtkInterpolationWeights: vtkInterpolationWeights,
-  vtkInterpolationMathFloor: vtkInterpolationMathFloor,
-  vtkInterpolationMathRound: vtkInterpolationMathRound,
-  vtkInterpolationMathClamp: vtkInterpolationMathClamp,
-  vtkInterpolationMathWrap: vtkInterpolationMathWrap,
-  vtkInterpolationMathMirror: vtkInterpolationMathMirror
+  vtkInterpolationInfo,
+  vtkInterpolationWeights,
+  vtkInterpolationMathFloor,
+  vtkInterpolationMathRound,
+  vtkInterpolationMathClamp,
+  vtkInterpolationMathWrap,
+  vtkInterpolationMathMirror
 };
 
 export { InterpolationInfo as default, vtkInterpolationInfo, vtkInterpolationMathClamp, vtkInterpolationMathFloor, vtkInterpolationMathMirror, vtkInterpolationMathRound, vtkInterpolationMathWrap, vtkInterpolationWeights };