@cornerstonejs/adapters 3.0.0-beta.5 → 3.0.0

package/dist/esm/adapters/Cornerstone/Segmentation_4X.js

@@ -1,24 +1,31 @@
-import { asyncToGenerator as _asyncToGenerator, regeneratorRuntime as _regeneratorRuntime, toConsumableArray as _toConsumableArray, createForOfIteratorHelper as _createForOfIteratorHelper, slicedToArray as _slicedToArray } from '../../_virtual/_rollupPluginBabelHelpers.js';
-import { utilities, data, normalizers, derivations, log } from 'dcmjs';
+import { utilities, log, data, normalizers, derivations } from 'dcmjs';
 import ndarray from 'ndarray';
 import getDatasetsFromImages from '../helpers/getDatasetsFromImages.js';
 import checkOrientation from '../helpers/checkOrientation.js';
 import compareArrays from '../helpers/compareArrays.js';
 import Events from '../enums/Events.js';
 
-var _utilities$orientatio = utilities.orientation,
-  rotateDirectionCosinesInPlane = _utilities$orientatio.rotateDirectionCosinesInPlane,
-  flipIOP = _utilities$orientatio.flipImageOrientationPatient,
-  flipMatrix2D = _utilities$orientatio.flipMatrix2D,
-  rotateMatrix902D = _utilities$orientatio.rotateMatrix902D;
-var BitArray = data.BitArray,
-  DicomMessage = data.DicomMessage,
-  DicomMetaDictionary = data.DicomMetaDictionary;
-var Normalizer = normalizers.Normalizer;
-var SegmentationDerivation = derivations.Segmentation;
-var _utilities$compressio = utilities.compression,
-  encode = _utilities$compressio.encode,
-  decode = _utilities$compressio.decode;
+const {
+  rotateDirectionCosinesInPlane,
+  flipImageOrientationPatient: flipIOP,
+  flipMatrix2D,
+  rotateMatrix902D
+} = utilities.orientation;
+const {
+  BitArray,
+  DicomMessage,
+  DicomMetaDictionary
+} = data;
+const {
+  Normalizer
+} = normalizers;
+const {
+  Segmentation: SegmentationDerivation
+} = derivations;
+const {
+  encode,
+  decode
+} = utilities.compression;
 
 /**
  *
@@ -27,7 +34,7 @@ var _utilities$compressio = utilities.compression,
  * @property {Object[]} segments - The cornerstoneTools segment metadata that corresponds to the
  *                                 seriesInstanceUid.
  */
-var generateSegmentationDefaultOptions = {
+const generateSegmentationDefaultOptions = {
   includeSliceSpacing: true,
   rleEncode: false
 };
@@ -43,9 +50,9 @@ var generateSegmentationDefaultOptions = {
  * @returns {Blob}
  */
 function generateSegmentation(images, inputLabelmaps3D) {
-  var userOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  var isMultiframe = images[0].imageId.includes("?frame");
-  var segmentation = _createSegFromImages(images, isMultiframe, userOptions);
+  let userOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const isMultiframe = images[0].imageId.includes("?frame");
+  const segmentation = _createSegFromImages(images, isMultiframe, userOptions);
   return fillSegmentation(segmentation, inputLabelmaps3D, userOptions);
 }
 
@@ -59,63 +66,63 @@ function generateSegmentation(images, inputLabelmaps3D) {
  * @returns {object} The filled segmentation object.
  */
 function fillSegmentation(segmentation, inputLabelmaps3D) {
-  var userOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  var options = Object.assign({}, generateSegmentationDefaultOptions, userOptions);
+  let userOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const options = Object.assign({}, generateSegmentationDefaultOptions, userOptions);
 
   // Use another variable so we don't redefine labelmaps3D.
-  var labelmaps3D = Array.isArray(inputLabelmaps3D) ? inputLabelmaps3D : [inputLabelmaps3D];
-  var numberOfFrames = 0;
-  var referencedFramesPerLabelmap = [];
-  var _loop = function _loop() {
-    var labelmap3D = labelmaps3D[labelmapIndex];
-    var labelmaps2D = labelmap3D.labelmaps2D,
-      metadata = labelmap3D.metadata;
-    var referencedFramesPerSegment = [];
-    for (var i = 1; i < metadata.length; i++) {
+  const labelmaps3D = Array.isArray(inputLabelmaps3D) ? inputLabelmaps3D : [inputLabelmaps3D];
+  let numberOfFrames = 0;
+  const referencedFramesPerLabelmap = [];
+  for (let labelmapIndex = 0; labelmapIndex < labelmaps3D.length; labelmapIndex++) {
+    const labelmap3D = labelmaps3D[labelmapIndex];
+    const {
+      labelmaps2D,
+      metadata
+    } = labelmap3D;
+    const referencedFramesPerSegment = [];
+    for (let i = 1; i < metadata.length; i++) {
       if (metadata[i]) {
         referencedFramesPerSegment[i] = [];
       }
     }
-    var _loop2 = function _loop2(_i) {
-      var labelmap2D = labelmaps2D[_i];
-      if (labelmaps2D[_i]) {
-        var segmentsOnLabelmap = labelmap2D.segmentsOnLabelmap;
-        segmentsOnLabelmap.forEach(function (segmentIndex) {
+    for (let i = 0; i < labelmaps2D.length; i++) {
+      const labelmap2D = labelmaps2D[i];
+      if (labelmaps2D[i]) {
+        const {
+          segmentsOnLabelmap
+        } = labelmap2D;
+        segmentsOnLabelmap.forEach(segmentIndex => {
           if (segmentIndex !== 0) {
-            referencedFramesPerSegment[segmentIndex].push(_i);
+            referencedFramesPerSegment[segmentIndex].push(i);
             numberOfFrames++;
           }
         });
       }
-    };
-    for (var _i = 0; _i < labelmaps2D.length; _i++) {
-      _loop2(_i);
     }
     referencedFramesPerLabelmap[labelmapIndex] = referencedFramesPerSegment;
-  };
-  for (var labelmapIndex = 0; labelmapIndex < labelmaps3D.length; labelmapIndex++) {
-    _loop();
   }
   segmentation.setNumberOfFrames(numberOfFrames);
-  for (var _labelmapIndex = 0; _labelmapIndex < labelmaps3D.length; _labelmapIndex++) {
-    var referencedFramesPerSegment = referencedFramesPerLabelmap[_labelmapIndex];
-    var labelmap3D = labelmaps3D[_labelmapIndex];
-    var metadata = labelmap3D.metadata;
-    for (var segmentIndex = 1; segmentIndex < referencedFramesPerSegment.length; segmentIndex++) {
-      var referencedFrameIndicies = referencedFramesPerSegment[segmentIndex];
+  for (let labelmapIndex = 0; labelmapIndex < labelmaps3D.length; labelmapIndex++) {
+    const referencedFramesPerSegment = referencedFramesPerLabelmap[labelmapIndex];
+    const labelmap3D = labelmaps3D[labelmapIndex];
+    const {
+      metadata
+    } = labelmap3D;
+    for (let segmentIndex = 1; segmentIndex < referencedFramesPerSegment.length; segmentIndex++) {
+      const referencedFrameIndicies = referencedFramesPerSegment[segmentIndex];
       if (referencedFrameIndicies) {
         // Frame numbers start from 1.
-        var referencedFrameNumbers = referencedFrameIndicies.map(function (element) {
+        const referencedFrameNumbers = referencedFrameIndicies.map(element => {
           return element + 1;
         });
-        var segmentMetadata = metadata[segmentIndex];
-        var labelmaps = _getLabelmapsFromReferencedFrameIndicies(labelmap3D, referencedFrameIndicies);
+        const segmentMetadata = metadata[segmentIndex];
+        const labelmaps = _getLabelmapsFromReferencedFrameIndicies(labelmap3D, referencedFrameIndicies);
         segmentation.addSegmentFromLabelmap(segmentMetadata, labelmaps, segmentIndex, referencedFrameNumbers);
       }
     }
   }
   if (options.rleEncode) {
-    var rleEncodedFrames = encode(segmentation.dataset.PixelData, numberOfFrames, segmentation.dataset.Rows, segmentation.dataset.Columns);
+    const rleEncodedFrames = encode(segmentation.dataset.PixelData, numberOfFrames, segmentation.dataset.Rows, segmentation.dataset.Columns);
 
     // Must use fractional now to RLE encode, as the DICOM standard only allows BitStored && BitsAllocated
     // to be 1 for BINARY. This is not ideal and there should be a better format for compression in this manner
@@ -142,10 +149,12 @@ function fillSegmentation(segmentation, inputLabelmaps3D) {
   return segmentation;
 }
 function _getLabelmapsFromReferencedFrameIndicies(labelmap3D, referencedFrameIndicies) {
-  var labelmaps2D = labelmap3D.labelmaps2D;
-  var labelmaps = [];
-  for (var i = 0; i < referencedFrameIndicies.length; i++) {
-    var frame = referencedFrameIndicies[i];
+  const {
+    labelmaps2D
+  } = labelmap3D;
+  const labelmaps = [];
+  for (let i = 0; i < referencedFrameIndicies.length; i++) {
+    const frame = referencedFrameIndicies[i];
     labelmaps.push(labelmaps2D[frame].pixelData);
   }
   return labelmaps;
@@ -159,7 +168,7 @@ function _getLabelmapsFromReferencedFrameIndicies(labelmap3D, referencedFrameInd
  * @returns {Object}              The Seg derived dataSet.
  */
 function _createSegFromImages(images, isMultiframe, options) {
-  var multiframe = getDatasetsFromImages(images, isMultiframe);
+  const multiframe = getDatasetsFromImages(images, isMultiframe);
   return new SegmentationDerivation([multiframe], options);
 }
 
@@ -178,8 +187,129 @@ function _createSegFromImages(images, isMultiframe, options) {
  * @return {[][][]} 3D list containing the track of segments per frame for each labelMap
  *                  (available only for the overlapping case).
  */
-function generateToolState(_x, _x2, _x3, _x4) {
-  return _generateToolState.apply(this, arguments);
+async function generateToolState(referencedImageIds, arrayBuffer, metadataProvider, options) {
+  const {
+    skipOverlapping = false,
+    tolerance = 1e-3,
+    TypedArrayConstructor = Uint8Array,
+    maxBytesPerChunk = 199000000,
+    eventTarget = null,
+    triggerEvent = null
+  } = options;
+  const dicomData = DicomMessage.readFile(arrayBuffer);
+  const dataset = DicomMetaDictionary.naturalizeDataset(dicomData.dict);
+  dataset._meta = DicomMetaDictionary.namifyDataset(dicomData.meta);
+  const multiframe = Normalizer.normalizeToDataset([dataset]);
+  const imagePlaneModule = metadataProvider.get("imagePlaneModule", referencedImageIds[0]);
+  const generalSeriesModule = metadataProvider.get("generalSeriesModule", referencedImageIds[0]);
+  const SeriesInstanceUID = generalSeriesModule.seriesInstanceUID;
+  if (!imagePlaneModule) {
+    console.warn("Insufficient metadata, imagePlaneModule missing.");
+  }
+  const ImageOrientationPatient = Array.isArray(imagePlaneModule.rowCosines) ? [...imagePlaneModule.rowCosines, ...imagePlaneModule.columnCosines] : [imagePlaneModule.rowCosines.x, imagePlaneModule.rowCosines.y, imagePlaneModule.rowCosines.z, imagePlaneModule.columnCosines.x, imagePlaneModule.columnCosines.y, imagePlaneModule.columnCosines.z];
+
+  // Get IOP from ref series, compute supported orientations:
+  const validOrientations = getValidOrientations(ImageOrientationPatient);
+  const sliceLength = multiframe.Columns * multiframe.Rows;
+  const segMetadata = getSegmentMetadata(multiframe, SeriesInstanceUID);
+  const TransferSyntaxUID = multiframe._meta.TransferSyntaxUID.Value[0];
+  let pixelData;
+  let pixelDataChunks;
+  if (TransferSyntaxUID === "1.2.840.10008.1.2.5") {
+    const rleEncodedFrames = Array.isArray(multiframe.PixelData) ? multiframe.PixelData : [multiframe.PixelData];
+    pixelData = decode(rleEncodedFrames, multiframe.Rows, multiframe.Columns);
+    if (multiframe.BitsStored === 1) {
+      console.warn("No implementation for rle + bitbacking.");
+      return;
+    }
+
+    // Todo: need to test this with rle data
+    pixelDataChunks = [pixelData];
+  } else {
+    pixelDataChunks = unpackPixelData(multiframe, {
+      maxBytesPerChunk
+    });
+    if (!pixelDataChunks) {
+      throw new Error("Fractional segmentations are not yet supported");
+    }
+  }
+  const orientation = checkOrientation(multiframe, validOrientations, [imagePlaneModule.rows, imagePlaneModule.columns, referencedImageIds.length], tolerance);
+
+  // Pre-compute the sop UID to imageId index map so that in the for loop
+  // we don't have to call metadataProvider.get() for each imageId over
+  // and over again.
+  const sopUIDImageIdIndexMap = referencedImageIds.reduce((acc, imageId) => {
+    const {
+      sopInstanceUID
+    } = metadataProvider.get("generalImageModule", imageId);
+    acc[sopInstanceUID] = imageId;
+    return acc;
+  }, {});
+  let overlapping = false;
+  if (!skipOverlapping) {
+    overlapping = checkSEGsOverlapping(pixelDataChunks, multiframe, referencedImageIds, validOrientations, metadataProvider, tolerance, TypedArrayConstructor, sopUIDImageIdIndexMap);
+  }
+  let insertFunction;
+  switch (orientation) {
+    case "Planar":
+      if (overlapping) {
+        insertFunction = insertOverlappingPixelDataPlanar;
+      } else {
+        insertFunction = insertPixelDataPlanar;
+      }
+      break;
+    case "Perpendicular":
+      //insertFunction = insertPixelDataPerpendicular;
+      throw new Error("Segmentations orthogonal to the acquisition plane of the source data are not yet supported.");
+    case "Oblique":
+      throw new Error("Segmentations oblique to the acquisition plane of the source data are not yet supported.");
+  }
+
+  /* if SEGs are overlapping:
+  1) the labelmapBuffer will contain M volumes which have non-overlapping segments;
+  2) segmentsOnFrame will have M * numberOfFrames values to track in which labelMap are the segments;
+  3) insertFunction will return the number of LabelMaps
+  4) generateToolState return is an array*/
+
+  const segmentsOnFrameArray = [];
+  segmentsOnFrameArray[0] = [];
+  const segmentsOnFrame = [];
+  const arrayBufferLength = sliceLength * referencedImageIds.length * TypedArrayConstructor.BYTES_PER_ELEMENT;
+  const labelmapBufferArray = [];
+  labelmapBufferArray[0] = new ArrayBuffer(arrayBufferLength);
+
+  // Pre-compute the indices and metadata so that we don't have to call
+  // a function for each imageId in the for loop.
+  const imageIdMaps = referencedImageIds.reduce((acc, curr, index) => {
+    acc.indices[curr] = index;
+    acc.metadata[curr] = metadataProvider.get("instance", curr);
+    return acc;
+  }, {
+    indices: {},
+    metadata: {}
+  });
+
+  // This is the centroid calculation for each segment Index, the data structure
+  // is a Map with key = segmentIndex and value = {imageIdIndex: centroid, ...}
+  // later on we will use this data structure to calculate the centroid of the
+  // segment in the labelmapBuffer
+  const segmentsPixelIndices = new Map();
+  const overlappingSegments = await insertFunction(segmentsOnFrame, segmentsOnFrameArray, labelmapBufferArray, pixelDataChunks, multiframe, referencedImageIds, validOrientations, metadataProvider, tolerance, TypedArrayConstructor, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps, eventTarget, triggerEvent);
+
+  // calculate the centroid of each segment
+  const centroidXYZ = new Map();
+  segmentsPixelIndices.forEach((imageIdIndexBufferIndex, segmentIndex) => {
+    const centroids = calculateCentroid(imageIdIndexBufferIndex, multiframe, metadataProvider, referencedImageIds);
+    centroidXYZ.set(segmentIndex, centroids);
+  });
+  return {
+    labelmapBufferArray,
+    segMetadata,
+    segmentsOnFrame,
+    segmentsOnFrameArray,
+    centroids: centroidXYZ,
+    overlappingSegments
+  };
 }
 
 // function insertPixelDataPerpendicular(
@@ -364,154 +494,27 @@ function generateToolState(_x, _x2, _x3, _x4) {
  *
  * @returns {String}     Returns the imageId
  */
-function _generateToolState() {
-  _generateToolState = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(referencedImageIds, arrayBuffer, metadataProvider, options) {
-    var _options$skipOverlapp, skipOverlapping, _options$tolerance, tolerance, _options$TypedArrayCo, TypedArrayConstructor, _options$maxBytesPerC, maxBytesPerChunk, _options$eventTarget, eventTarget, _options$triggerEvent, triggerEvent, dicomData, dataset, multiframe, imagePlaneModule, generalSeriesModule, SeriesInstanceUID, ImageOrientationPatient, validOrientations, sliceLength, segMetadata, TransferSyntaxUID, pixelData, pixelDataChunks, rleEncodedFrames, orientation, sopUIDImageIdIndexMap, overlapping, insertFunction, segmentsOnFrameArray, segmentsOnFrame, arrayBufferLength, labelmapBufferArray, imageIdMaps, segmentsPixelIndices, overlappingSegments, centroidXYZ;
-    return _regeneratorRuntime().wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          _options$skipOverlapp = options.skipOverlapping, skipOverlapping = _options$skipOverlapp === void 0 ? false : _options$skipOverlapp, _options$tolerance = options.tolerance, tolerance = _options$tolerance === void 0 ? 1e-3 : _options$tolerance, _options$TypedArrayCo = options.TypedArrayConstructor, TypedArrayConstructor = _options$TypedArrayCo === void 0 ? Uint8Array : _options$TypedArrayCo, _options$maxBytesPerC = options.maxBytesPerChunk, maxBytesPerChunk = _options$maxBytesPerC === void 0 ? 199000000 : _options$maxBytesPerC, _options$eventTarget = options.eventTarget, eventTarget = _options$eventTarget === void 0 ? null : _options$eventTarget, _options$triggerEvent = options.triggerEvent, triggerEvent = _options$triggerEvent === void 0 ? null : _options$triggerEvent;
-          dicomData = DicomMessage.readFile(arrayBuffer);
-          dataset = DicomMetaDictionary.naturalizeDataset(dicomData.dict);
-          dataset._meta = DicomMetaDictionary.namifyDataset(dicomData.meta);
-          multiframe = Normalizer.normalizeToDataset([dataset]);
-          imagePlaneModule = metadataProvider.get("imagePlaneModule", referencedImageIds[0]);
-          generalSeriesModule = metadataProvider.get("generalSeriesModule", referencedImageIds[0]);
-          SeriesInstanceUID = generalSeriesModule.seriesInstanceUID;
-          if (!imagePlaneModule) {
-            console.warn("Insufficient metadata, imagePlaneModule missing.");
-          }
-          ImageOrientationPatient = Array.isArray(imagePlaneModule.rowCosines) ? [].concat(_toConsumableArray(imagePlaneModule.rowCosines), _toConsumableArray(imagePlaneModule.columnCosines)) : [imagePlaneModule.rowCosines.x, imagePlaneModule.rowCosines.y, imagePlaneModule.rowCosines.z, imagePlaneModule.columnCosines.x, imagePlaneModule.columnCosines.y, imagePlaneModule.columnCosines.z]; // Get IOP from ref series, compute supported orientations:
-          validOrientations = getValidOrientations(ImageOrientationPatient);
-          sliceLength = multiframe.Columns * multiframe.Rows;
-          segMetadata = getSegmentMetadata(multiframe, SeriesInstanceUID);
-          TransferSyntaxUID = multiframe._meta.TransferSyntaxUID.Value[0];
-          if (!(TransferSyntaxUID === "1.2.840.10008.1.2.5")) {
-            _context.next = 23;
-            break;
-          }
-          rleEncodedFrames = Array.isArray(multiframe.PixelData) ? multiframe.PixelData : [multiframe.PixelData];
-          pixelData = decode(rleEncodedFrames, multiframe.Rows, multiframe.Columns);
-          if (!(multiframe.BitsStored === 1)) {
-            _context.next = 20;
-            break;
-          }
-          console.warn("No implementation for rle + bitbacking.");
-          return _context.abrupt("return");
-        case 20:
-          // Todo: need to test this with rle data
-          pixelDataChunks = [pixelData];
-          _context.next = 26;
-          break;
-        case 23:
-          pixelDataChunks = unpackPixelData(multiframe, {
-            maxBytesPerChunk: maxBytesPerChunk
-          });
-          if (pixelDataChunks) {
-            _context.next = 26;
-            break;
-          }
-          throw new Error("Fractional segmentations are not yet supported");
-        case 26:
-          orientation = checkOrientation(multiframe, validOrientations, [imagePlaneModule.rows, imagePlaneModule.columns, referencedImageIds.length], tolerance); // Pre-compute the sop UID to imageId index map so that in the for loop
-          // we don't have to call metadataProvider.get() for each imageId over
-          // and over again.
-          sopUIDImageIdIndexMap = referencedImageIds.reduce(function (acc, imageId) {
-            var _metadataProvider$get = metadataProvider.get("generalImageModule", imageId),
-              sopInstanceUID = _metadataProvider$get.sopInstanceUID;
-            acc[sopInstanceUID] = imageId;
-            return acc;
-          }, {});
-          overlapping = false;
-          if (!skipOverlapping) {
-            overlapping = checkSEGsOverlapping(pixelDataChunks, multiframe, referencedImageIds, validOrientations, metadataProvider, tolerance, TypedArrayConstructor, sopUIDImageIdIndexMap);
-          }
-          _context.t0 = orientation;
-          _context.next = _context.t0 === "Planar" ? 33 : _context.t0 === "Perpendicular" ? 35 : _context.t0 === "Oblique" ? 36 : 37;
-          break;
-        case 33:
-          if (overlapping) {
-            insertFunction = insertOverlappingPixelDataPlanar;
-          } else {
-            insertFunction = insertPixelDataPlanar;
-          }
-          return _context.abrupt("break", 37);
-        case 35:
-          throw new Error("Segmentations orthogonal to the acquisition plane of the source data are not yet supported.");
-        case 36:
-          throw new Error("Segmentations oblique to the acquisition plane of the source data are not yet supported.");
-        case 37:
-          /* if SEGs are overlapping:
-          1) the labelmapBuffer will contain M volumes which have non-overlapping segments;
-          2) segmentsOnFrame will have M * numberOfFrames values to track in which labelMap are the segments;
-          3) insertFunction will return the number of LabelMaps
-          4) generateToolState return is an array*/
-          segmentsOnFrameArray = [];
-          segmentsOnFrameArray[0] = [];
-          segmentsOnFrame = [];
-          arrayBufferLength = sliceLength * referencedImageIds.length * TypedArrayConstructor.BYTES_PER_ELEMENT;
-          labelmapBufferArray = [];
-          labelmapBufferArray[0] = new ArrayBuffer(arrayBufferLength);
-
-          // Pre-compute the indices and metadata so that we don't have to call
-          // a function for each imageId in the for loop.
-          imageIdMaps = referencedImageIds.reduce(function (acc, curr, index) {
-            acc.indices[curr] = index;
-            acc.metadata[curr] = metadataProvider.get("instance", curr);
-            return acc;
-          }, {
-            indices: {},
-            metadata: {}
-          }); // This is the centroid calculation for each segment Index, the data structure
-          // is a Map with key = segmentIndex and value = {imageIdIndex: centroid, ...}
-          // later on we will use this data structure to calculate the centroid of the
-          // segment in the labelmapBuffer
-          segmentsPixelIndices = new Map();
-          _context.next = 47;
-          return insertFunction(segmentsOnFrame, segmentsOnFrameArray, labelmapBufferArray, pixelDataChunks, multiframe, referencedImageIds, validOrientations, metadataProvider, tolerance, TypedArrayConstructor, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps, eventTarget, triggerEvent);
-        case 47:
-          overlappingSegments = _context.sent;
-          // calculate the centroid of each segment
-          centroidXYZ = new Map();
-          segmentsPixelIndices.forEach(function (imageIdIndexBufferIndex, segmentIndex) {
-            var centroids = calculateCentroid(imageIdIndexBufferIndex, multiframe, metadataProvider, referencedImageIds);
-            centroidXYZ.set(segmentIndex, centroids);
-          });
-          return _context.abrupt("return", {
-            labelmapBufferArray: labelmapBufferArray,
-            segMetadata: segMetadata,
-            segmentsOnFrame: segmentsOnFrame,
-            segmentsOnFrameArray: segmentsOnFrameArray,
-            centroids: centroidXYZ,
-            overlappingSegments: overlappingSegments
-          });
-        case 51:
-        case "end":
-          return _context.stop();
-      }
-    }, _callee);
-  }));
-  return _generateToolState.apply(this, arguments);
-}
 function findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap) {
-  var imageId = undefined;
+  let imageId = undefined;
   if (!multiframe) {
     return imageId;
   }
-  var FrameOfReferenceUID = multiframe.FrameOfReferenceUID,
-    PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
-    SourceImageSequence = multiframe.SourceImageSequence,
-    ReferencedSeriesSequence = multiframe.ReferencedSeriesSequence;
+  const {
+    FrameOfReferenceUID,
+    PerFrameFunctionalGroupsSequence,
+    SourceImageSequence,
+    ReferencedSeriesSequence
+  } = multiframe;
   if (!PerFrameFunctionalGroupsSequence || PerFrameFunctionalGroupsSequence.length === 0) {
     return imageId;
   }
-  var PerFrameFunctionalGroup = PerFrameFunctionalGroupsSequence[frameSegment];
+  const PerFrameFunctionalGroup = PerFrameFunctionalGroupsSequence[frameSegment];
   if (!PerFrameFunctionalGroup) {
     return imageId;
   }
-  var frameSourceImageSequence = undefined;
+  let frameSourceImageSequence = undefined;
   if (PerFrameFunctionalGroup.DerivationImageSequence) {
-    var DerivationImageSequence = PerFrameFunctionalGroup.DerivationImageSequence;
+    let DerivationImageSequence = PerFrameFunctionalGroup.DerivationImageSequence;
     if (Array.isArray(DerivationImageSequence)) {
       if (DerivationImageSequence.length !== 0) {
         DerivationImageSequence = DerivationImageSequence[0];
@@ -537,8 +540,8 @@ function findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadata
     imageId = getImageIdOfSourceImageBySourceImageSequence(frameSourceImageSequence, sopUIDImageIdIndexMap);
   }
   if (imageId === undefined && ReferencedSeriesSequence) {
-    var referencedSeriesSequence = Array.isArray(ReferencedSeriesSequence) ? ReferencedSeriesSequence[0] : ReferencedSeriesSequence;
-    var ReferencedSeriesInstanceUID = referencedSeriesSequence.SeriesInstanceUID;
+    const referencedSeriesSequence = Array.isArray(ReferencedSeriesSequence) ? ReferencedSeriesSequence[0] : ReferencedSeriesSequence;
+    const ReferencedSeriesInstanceUID = referencedSeriesSequence.SeriesInstanceUID;
     imageId = getImageIdOfSourceImagebyGeometry(ReferencedSeriesInstanceUID, FrameOfReferenceUID, PerFrameFunctionalGroup, imageIds, metadataProvider, tolerance);
   }
   return imageId;
@@ -550,18 +553,20 @@ function findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadata
  */
 
 function checkSEGsOverlapping(pixelData, multiframe, imageIds, validOrientations, metadataProvider, tolerance, TypedArrayConstructor, sopUIDImageIdIndexMap) {
-  var SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence,
-    PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
-    SegmentSequence = multiframe.SegmentSequence,
-    Rows = multiframe.Rows,
-    Columns = multiframe.Columns;
-  var numberOfSegs = SegmentSequence.length;
+  const {
+    SharedFunctionalGroupsSequence,
+    PerFrameFunctionalGroupsSequence,
+    SegmentSequence,
+    Rows,
+    Columns
+  } = multiframe;
+  let numberOfSegs = SegmentSequence.length;
   if (numberOfSegs < 2) {
     return false;
   }
-  var sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence ? SharedFunctionalGroupsSequence.PlaneOrientationSequence.ImageOrientationPatient : undefined;
-  var sliceLength = Columns * Rows;
-  var groupsLen = PerFrameFunctionalGroupsSequence.length;
+  const sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence ? SharedFunctionalGroupsSequence.PlaneOrientationSequence.ImageOrientationPatient : undefined;
+  const sliceLength = Columns * Rows;
+  const groupsLen = PerFrameFunctionalGroupsSequence.length;
 
   /** sort groupsLen to have all the segments for each frame in an array
    * frame 2 : 1, 2
@@ -569,91 +574,76 @@ function checkSEGsOverlapping(pixelData, multiframe, imageIds, validOrientations
    * frame 5 : 4
    */
 
-  var frameSegmentsMapping = new Map();
-  var _loop3 = function _loop3() {
-      var segmentIndex = getSegmentIndex(multiframe, frameSegment);
-      if (segmentIndex === undefined) {
-        console.warn("Could not retrieve the segment index for frame segment " + frameSegment + ", skipping this frame.");
-        return 0; // continue
-      }
-      var imageId = findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
-      if (!imageId) {
-        console.warn("Image not present in stack, can't import frame : " + frameSegment + ".");
-        return 0; // continue
-      }
-      var imageIdIndex = imageIds.findIndex(function (element) {
-        return element === imageId;
-      });
-      if (frameSegmentsMapping.has(imageIdIndex)) {
-        var segmentArray = frameSegmentsMapping.get(imageIdIndex);
-        if (!segmentArray.includes(frameSegment)) {
-          segmentArray.push(frameSegment);
-          frameSegmentsMapping.set(imageIdIndex, segmentArray);
-        }
-      } else {
-        frameSegmentsMapping.set(imageIdIndex, [frameSegment]);
+  let frameSegmentsMapping = new Map();
+  for (let frameSegment = 0; frameSegment < groupsLen; ++frameSegment) {
+    const segmentIndex = getSegmentIndex(multiframe, frameSegment);
+    if (segmentIndex === undefined) {
+      console.warn("Could not retrieve the segment index for frame segment " + frameSegment + ", skipping this frame.");
+      continue;
+    }
+    const imageId = findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
+    if (!imageId) {
+      console.warn("Image not present in stack, can't import frame : " + frameSegment + ".");
+      continue;
+    }
+    const imageIdIndex = imageIds.findIndex(element => element === imageId);
+    if (frameSegmentsMapping.has(imageIdIndex)) {
+      let segmentArray = frameSegmentsMapping.get(imageIdIndex);
+      if (!segmentArray.includes(frameSegment)) {
+        segmentArray.push(frameSegment);
+        frameSegmentsMapping.set(imageIdIndex, segmentArray);
       }
-    },
-    _ret;
-  for (var frameSegment = 0; frameSegment < groupsLen; ++frameSegment) {
-    _ret = _loop3();
-    if (_ret === 0) continue;
+    } else {
+      frameSegmentsMapping.set(imageIdIndex, [frameSegment]);
+    }
   }
-  var _iterator = _createForOfIteratorHelper(frameSegmentsMapping.entries()),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var _step$value = _slicedToArray(_step.value, 2),
-        role = _step$value[1];
-      var temp2DArray = new TypedArrayConstructor(sliceLength).fill(0);
-      for (var i = 0; i < role.length; ++i) {
-        var _frameSegment = role[i];
-        var PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[_frameSegment];
-        var ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
-        var view = readFromUnpackedChunks(pixelData, _frameSegment * sliceLength, sliceLength);
-        var pixelDataI2D = ndarray(view, [Rows, Columns]);
-        var alignedPixelDataI = alignPixelDataWithSourceData(pixelDataI2D, ImageOrientationPatientI, validOrientations, tolerance);
-        if (!alignedPixelDataI) {
-          console.warn("Individual SEG frames are out of plane with respect to the first SEG frame, this is not yet supported, skipping this frame.");
-          continue;
-        }
-        var data = alignedPixelDataI.data;
-        for (var j = 0, len = data.length; j < len; ++j) {
-          if (data[j] !== 0) {
-            temp2DArray[j]++;
-            if (temp2DArray[j] > 1) {
-              return true;
-            }
+  for (let [, role] of frameSegmentsMapping.entries()) {
+    let temp2DArray = new TypedArrayConstructor(sliceLength).fill(0);
+    for (let i = 0; i < role.length; ++i) {
+      const frameSegment = role[i];
+      const PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[frameSegment];
+      const ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
+      const view = readFromUnpackedChunks(pixelData, frameSegment * sliceLength, sliceLength);
+      const pixelDataI2D = ndarray(view, [Rows, Columns]);
+      const alignedPixelDataI = alignPixelDataWithSourceData(pixelDataI2D, ImageOrientationPatientI, validOrientations, tolerance);
+      if (!alignedPixelDataI) {
+        console.warn("Individual SEG frames are out of plane with respect to the first SEG frame, this is not yet supported, skipping this frame.");
+        continue;
+      }
+      const data = alignedPixelDataI.data;
+      for (let j = 0, len = data.length; j < len; ++j) {
+        if (data[j] !== 0) {
+          temp2DArray[j]++;
+          if (temp2DArray[j] > 1) {
+            return true;
           }
         }
       }
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
   }
   return false;
 }
 function insertOverlappingPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray, labelmapBufferArray, pixelData, multiframe, imageIds, validOrientations, metadataProvider, tolerance, TypedArrayConstructor, segmentsPixelIndices, sopUIDImageIdIndexMap) {
-  var SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence,
-    PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
-    Rows = multiframe.Rows,
-    Columns = multiframe.Columns;
-  var sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence ? SharedFunctionalGroupsSequence.PlaneOrientationSequence.ImageOrientationPatient : undefined;
-  var sliceLength = Columns * Rows;
-  var arrayBufferLength = sliceLength * imageIds.length * TypedArrayConstructor.BYTES_PER_ELEMENT;
+  const {
+    SharedFunctionalGroupsSequence,
+    PerFrameFunctionalGroupsSequence,
+    Rows,
+    Columns
+  } = multiframe;
+  const sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence ? SharedFunctionalGroupsSequence.PlaneOrientationSequence.ImageOrientationPatient : undefined;
+  const sliceLength = Columns * Rows;
+  const arrayBufferLength = sliceLength * imageIds.length * TypedArrayConstructor.BYTES_PER_ELEMENT;
   // indicate the number of labelMaps
-  var M = 1;
+  let M = 1;
 
   // indicate the current labelMap array index;
-  var m = 0;
+  let m = 0;
 
   // temp array for checking overlaps
-  var tempBuffer = labelmapBufferArray[m].slice(0);
+  let tempBuffer = labelmapBufferArray[m].slice(0);
 
   // temp list for checking overlaps
-  var tempSegmentsOnFrame = structuredClone(segmentsOnFrameArray[m]);
+  let tempSegmentsOnFrame = structuredClone(segmentsOnFrameArray[m]);
 
   /** split overlapping SEGs algorithm for each segment:
    *  A) copy the labelmapBuffer in the array with index 0
@@ -662,81 +652,71 @@ function insertOverlappingPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray,
    *  D) if overlap, repeat increasing the index m up to M (if out of memory, add new buffer in the array and M++);
    */
 
-  var numberOfSegs = multiframe.SegmentSequence.length;
-  for (var segmentIndexToProcess = 1; segmentIndexToProcess <= numberOfSegs; ++segmentIndexToProcess) {
-    var _loop4 = function _loop4(_i2) {
-        var PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[_i2];
-        var segmentIndex = getSegmentIndex(multiframe, _i2);
-        if (segmentIndex === undefined) {
-          throw new Error("Could not retrieve the segment index. Aborting segmentation loading.");
-        }
-        if (segmentIndex !== segmentIndexToProcess) {
-          i = _i2;
-          return 0; // continue
-        }
-        var ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
-
-        // Since we moved to the chunks approach, we need to read the data
-        // and handle scenarios where the portion of data is in one chunk
-        // and the other portion is in another chunk
-        var view = readFromUnpackedChunks(pixelData, _i2 * sliceLength, sliceLength);
-        var pixelDataI2D = ndarray(view, [Rows, Columns]);
-        var alignedPixelDataI = alignPixelDataWithSourceData(pixelDataI2D, ImageOrientationPatientI, validOrientations, tolerance);
-        if (!alignedPixelDataI) {
-          throw new Error("Individual SEG frames are out of plane with respect to the first SEG frame. " + "This is not yet supported. Aborting segmentation loading.");
-        }
-        var imageId = findReferenceSourceImageId(multiframe, _i2, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
-        if (!imageId) {
-          console.warn("Image not present in stack, can't import frame : " + _i2 + ".");
-          i = _i2;
-          return 0; // continue
-        }
-        var sourceImageMetadata = metadataProvider.get("instance", imageId);
-        if (Rows !== sourceImageMetadata.Rows || Columns !== sourceImageMetadata.Columns) {
-          throw new Error("Individual SEG frames have different geometry dimensions (Rows and Columns) " + "respect to the source image reference frame. This is not yet supported. " + "Aborting segmentation loading. ");
-        }
-        var imageIdIndex = imageIds.findIndex(function (element) {
-          return element === imageId;
-        });
-        var byteOffset = sliceLength * imageIdIndex * TypedArrayConstructor.BYTES_PER_ELEMENT;
-        var labelmap2DView = new TypedArrayConstructor(tempBuffer, byteOffset, sliceLength);
-        var data = alignedPixelDataI.data;
-        var segmentOnFrame = false;
-        for (var j = 0, len = alignedPixelDataI.data.length; j < len; ++j) {
-          if (data[j]) {
-            if (labelmap2DView[j] !== 0) {
-              m++;
-              if (m >= M) {
-                labelmapBufferArray[m] = new ArrayBuffer(arrayBufferLength);
-                segmentsOnFrameArray[m] = [];
-                M++;
-              }
-              tempBuffer = labelmapBufferArray[m].slice(0);
-              tempSegmentsOnFrame = structuredClone(segmentsOnFrameArray[m]);
-              _i2 = 0;
-              break;
-            } else {
-              labelmap2DView[j] = segmentIndex;
-              segmentOnFrame = true;
+  let numberOfSegs = multiframe.SegmentSequence.length;
+  for (let segmentIndexToProcess = 1; segmentIndexToProcess <= numberOfSegs; ++segmentIndexToProcess) {
+    for (let i = 0, groupsLen = PerFrameFunctionalGroupsSequence.length; i < groupsLen; ++i) {
+      const PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[i];
+      const segmentIndex = getSegmentIndex(multiframe, i);
+      if (segmentIndex === undefined) {
+        throw new Error("Could not retrieve the segment index. Aborting segmentation loading.");
+      }
+      if (segmentIndex !== segmentIndexToProcess) {
+        continue;
+      }
+      const ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
+
+      // Since we moved to the chunks approach, we need to read the data
+      // and handle scenarios where the portion of data is in one chunk
+      // and the other portion is in another chunk
+      const view = readFromUnpackedChunks(pixelData, i * sliceLength, sliceLength);
+      const pixelDataI2D = ndarray(view, [Rows, Columns]);
+      const alignedPixelDataI = alignPixelDataWithSourceData(pixelDataI2D, ImageOrientationPatientI, validOrientations, tolerance);
+      if (!alignedPixelDataI) {
+        throw new Error("Individual SEG frames are out of plane with respect to the first SEG frame. " + "This is not yet supported. Aborting segmentation loading.");
+      }
+      const imageId = findReferenceSourceImageId(multiframe, i, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
+      if (!imageId) {
+        console.warn("Image not present in stack, can't import frame : " + i + ".");
+        continue;
+      }
+      const sourceImageMetadata = metadataProvider.get("instance", imageId);
+      if (Rows !== sourceImageMetadata.Rows || Columns !== sourceImageMetadata.Columns) {
+        throw new Error("Individual SEG frames have different geometry dimensions (Rows and Columns) " + "respect to the source image reference frame. This is not yet supported. " + "Aborting segmentation loading. ");
+      }
+      const imageIdIndex = imageIds.findIndex(element => element === imageId);
+      const byteOffset = sliceLength * imageIdIndex * TypedArrayConstructor.BYTES_PER_ELEMENT;
+      const labelmap2DView = new TypedArrayConstructor(tempBuffer, byteOffset, sliceLength);
+      const data = alignedPixelDataI.data;
+      let segmentOnFrame = false;
+      for (let j = 0, len = alignedPixelDataI.data.length; j < len; ++j) {
+        if (data[j]) {
+          if (labelmap2DView[j] !== 0) {
+            m++;
+            if (m >= M) {
+              labelmapBufferArray[m] = new ArrayBuffer(arrayBufferLength);
+              segmentsOnFrameArray[m] = [];
+              M++;
             }
+            tempBuffer = labelmapBufferArray[m].slice(0);
+            tempSegmentsOnFrame = structuredClone(segmentsOnFrameArray[m]);
+            i = 0;
+            break;
+          } else {
+            labelmap2DView[j] = segmentIndex;
+            segmentOnFrame = true;
           }
         }
-        if (segmentOnFrame) {
-          if (!tempSegmentsOnFrame[imageIdIndex]) {
-            tempSegmentsOnFrame[imageIdIndex] = [];
-          }
-          tempSegmentsOnFrame[imageIdIndex].push(segmentIndex);
-          if (!segmentsOnFrame[imageIdIndex]) {
-            segmentsOnFrame[imageIdIndex] = [];
-          }
-          segmentsOnFrame[imageIdIndex].push(segmentIndex);
+      }
+      if (segmentOnFrame) {
+        if (!tempSegmentsOnFrame[imageIdIndex]) {
+          tempSegmentsOnFrame[imageIdIndex] = [];
+        }
+        tempSegmentsOnFrame[imageIdIndex].push(segmentIndex);
+        if (!segmentsOnFrame[imageIdIndex]) {
+          segmentsOnFrame[imageIdIndex] = [];
         }
-        i = _i2;
-      },
-      _ret2;
-    for (var i = 0, groupsLen = PerFrameFunctionalGroupsSequence.length; i < groupsLen; ++i) {
-      _ret2 = _loop4(i);
-      if (_ret2 === 0) continue;
+        segmentsOnFrame[imageIdIndex].push(segmentIndex);
+      }
     }
     labelmapBufferArray[m] = tempBuffer.slice(0);
     segmentsOnFrameArray[m] = structuredClone(tempSegmentsOnFrame);
@@ -747,64 +727,68 @@ function insertOverlappingPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray,
     tempSegmentsOnFrame = structuredClone(segmentsOnFrameArray[m]);
   }
 }
-var getSegmentIndex = function getSegmentIndex(multiframe, frame) {
-  var PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
-    SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence;
-  var PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[frame];
+const getSegmentIndex = (multiframe, frame) => {
+  const {
+    PerFrameFunctionalGroupsSequence,
+    SharedFunctionalGroupsSequence
+  } = multiframe;
+  const PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[frame];
   return PerFrameFunctionalGroups && PerFrameFunctionalGroups.SegmentIdentificationSequence ? PerFrameFunctionalGroups.SegmentIdentificationSequence.ReferencedSegmentNumber : SharedFunctionalGroupsSequence.SegmentIdentificationSequence ? SharedFunctionalGroupsSequence.SegmentIdentificationSequence.ReferencedSegmentNumber : undefined;
 };
 function insertPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray, labelmapBufferArray, pixelData, multiframe, imageIds, validOrientations, metadataProvider, tolerance, TypedArrayConstructor, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps, eventTarget, triggerEvent) {
-  var SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence,
-    PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
-    Rows = multiframe.Rows,
-    Columns = multiframe.Columns;
-  var sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence ? SharedFunctionalGroupsSequence.PlaneOrientationSequence.ImageOrientationPatient : undefined;
-  var sliceLength = Columns * Rows;
-  var i = 0;
-  var groupsLen = PerFrameFunctionalGroupsSequence.length;
-  var chunkSize = Math.ceil(groupsLen / 10); // 10% of total length
-
-  var shouldTriggerEvent = triggerEvent && eventTarget;
-  var overlapping = false;
+  const {
+    SharedFunctionalGroupsSequence,
+    PerFrameFunctionalGroupsSequence,
+    Rows,
+    Columns
+  } = multiframe;
+  const sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence ? SharedFunctionalGroupsSequence.PlaneOrientationSequence.ImageOrientationPatient : undefined;
+  const sliceLength = Columns * Rows;
+  let i = 0;
+  const groupsLen = PerFrameFunctionalGroupsSequence.length;
+  const chunkSize = Math.ceil(groupsLen / 10); // 10% of total length
+
+  const shouldTriggerEvent = triggerEvent && eventTarget;
+  let overlapping = false;
   // Below, we chunk the processing of the frames to avoid blocking the main thread
   // if the segmentation is large. We also use a promise to allow the caller to
   // wait for the processing to finish.
-  return new Promise(function (resolve) {
+  return new Promise(resolve => {
     function processInChunks() {
       // process one chunk
-      for (var end = Math.min(i + chunkSize, groupsLen); i < end; ++i) {
-        var PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[i];
-        var ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
-        var view = readFromUnpackedChunks(pixelData, i * sliceLength, sliceLength);
-        var pixelDataI2D = ndarray(view, [Rows, Columns]);
-        var alignedPixelDataI = alignPixelDataWithSourceData(pixelDataI2D, ImageOrientationPatientI, validOrientations, tolerance);
+      for (let end = Math.min(i + chunkSize, groupsLen); i < end; ++i) {
+        const PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[i];
+        const ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
+        const view = readFromUnpackedChunks(pixelData, i * sliceLength, sliceLength);
+        const pixelDataI2D = ndarray(view, [Rows, Columns]);
+        const alignedPixelDataI = alignPixelDataWithSourceData(pixelDataI2D, ImageOrientationPatientI, validOrientations, tolerance);
         if (!alignedPixelDataI) {
           throw new Error("Individual SEG frames are out of plane with respect to the first SEG frame. " + "This is not yet supported. Aborting segmentation loading.");
         }
-        var segmentIndex = getSegmentIndex(multiframe, i);
+        const segmentIndex = getSegmentIndex(multiframe, i);
         if (segmentIndex === undefined) {
           throw new Error("Could not retrieve the segment index. Aborting segmentation loading.");
         }
         if (!segmentsPixelIndices.has(segmentIndex)) {
           segmentsPixelIndices.set(segmentIndex, {});
         }
-        var imageId = findReferenceSourceImageId(multiframe, i, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
+        const imageId = findReferenceSourceImageId(multiframe, i, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
         if (!imageId) {
           console.warn("Image not present in stack, can't import frame : " + i + ".");
           continue;
         }
-        var sourceImageMetadata = imageIdMaps.metadata[imageId];
+        const sourceImageMetadata = imageIdMaps.metadata[imageId];
         if (Rows !== sourceImageMetadata.Rows || Columns !== sourceImageMetadata.Columns) {
           throw new Error("Individual SEG frames have different geometry dimensions (Rows and Columns) " + "respect to the source image reference frame. This is not yet supported. " + "Aborting segmentation loading. ");
         }
-        var imageIdIndex = imageIdMaps.indices[imageId];
-        var byteOffset = sliceLength * imageIdIndex * TypedArrayConstructor.BYTES_PER_ELEMENT;
-        var labelmap2DView = new TypedArrayConstructor(labelmapBufferArray[0], byteOffset, sliceLength);
-        var data = alignedPixelDataI.data;
-        var indexCache = [];
-        for (var j = 0, len = alignedPixelDataI.data.length; j < len; ++j) {
+        const imageIdIndex = imageIdMaps.indices[imageId];
+        const byteOffset = sliceLength * imageIdIndex * TypedArrayConstructor.BYTES_PER_ELEMENT;
+        const labelmap2DView = new TypedArrayConstructor(labelmapBufferArray[0], byteOffset, sliceLength);
+        const data = alignedPixelDataI.data;
+        const indexCache = [];
+        for (let j = 0, len = alignedPixelDataI.data.length; j < len; ++j) {
           if (data[j]) {
-            for (var x = j; x < len; ++x) {
+            for (let x = j; x < len; ++x) {
               if (data[x]) {
                 if (!overlapping && labelmap2DView[x] !== 0) {
                   overlapping = true;
@@ -820,16 +804,16 @@ function insertPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray, labelmapBu
             break;
           }
         }
-        var segmentIndexObject = segmentsPixelIndices.get(segmentIndex);
+        const segmentIndexObject = segmentsPixelIndices.get(segmentIndex);
         segmentIndexObject[imageIdIndex] = indexCache;
         segmentsPixelIndices.set(segmentIndex, segmentIndexObject);
       }
 
       // trigger an event after each chunk
       if (shouldTriggerEvent) {
-        var percentComplete = Math.round(i / groupsLen * 100);
+        const percentComplete = Math.round(i / groupsLen * 100);
         triggerEvent(eventTarget, Events.SEGMENTATION_LOAD_PROGRESS, {
-          percentComplete: percentComplete
+          percentComplete
         });
       }
 
@@ -853,8 +837,8 @@ function insertPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray, labelmapBu
  * @return {Uint8Array}      The unpacked pixelData.
  */
 function unpackPixelData(multiframe, options) {
-  var segType = multiframe.SegmentationType;
-  var data;
+  const segType = multiframe.SegmentationType;
+  let data;
   if (Array.isArray(multiframe.PixelData)) {
     data = multiframe.PixelData[0];
   } else {
@@ -869,11 +853,9 @@ function unpackPixelData(multiframe, options) {
     // MAX 2GB is the limit right now to allocate a buffer
     return getUnpackedChunks(data, options.maxBytesPerChunk);
   }
-  var pixelData = new Uint8Array(data);
-  var max = multiframe.MaximumFractionalValue;
-  var onlyMaxAndZero = pixelData.find(function (element) {
-    return element !== 0 && element !== max;
-  }) === undefined;
+  const pixelData = new Uint8Array(data);
+  const max = multiframe.MaximumFractionalValue;
+  const onlyMaxAndZero = pixelData.find(element => element !== 0 && element !== max) === undefined;
   if (!onlyMaxAndZero) {
     // This is a fractional segmentation, which is not currently supported.
     return;
@@ -907,8 +889,10 @@ function getUnpackedChunks(data, maxBytesPerChunk) {
  * @return {String}                        The corresponding imageId.
  */
 function getImageIdOfSourceImageBySourceImageSequence(SourceImageSequence, sopUIDImageIdIndexMap) {
-  var ReferencedSOPInstanceUID = SourceImageSequence.ReferencedSOPInstanceUID,
-    ReferencedFrameNumber = SourceImageSequence.ReferencedFrameNumber;
+  const {
+    ReferencedSOPInstanceUID,
+    ReferencedFrameNumber
+  } = SourceImageSequence;
   return ReferencedFrameNumber ? getImageIdOfReferencedFrame(ReferencedSOPInstanceUID, ReferencedFrameNumber, sopUIDImageIdIndexMap) : sopUIDImageIdIndexMap[ReferencedSOPInstanceUID];
 }
 
@@ -928,8 +912,8 @@ function getImageIdOfSourceImagebyGeometry(ReferencedSeriesInstanceUID, FrameOfR
   if (ReferencedSeriesInstanceUID === undefined || PerFrameFunctionalGroup.PlanePositionSequence === undefined || PerFrameFunctionalGroup.PlanePositionSequence[0] === undefined || PerFrameFunctionalGroup.PlanePositionSequence[0].ImagePositionPatient === undefined) {
     return undefined;
   }
-  for (var imageIdsIndexc = 0; imageIdsIndexc < imageIds.length; ++imageIdsIndexc) {
-    var sourceImageMetadata = metadataProvider.get("instance", imageIds[imageIdsIndexc]);
+  for (let imageIdsIndexc = 0; imageIdsIndexc < imageIds.length; ++imageIdsIndexc) {
+    const sourceImageMetadata = metadataProvider.get("instance", imageIds[imageIdsIndexc]);
     if (sourceImageMetadata === undefined || sourceImageMetadata.ImagePositionPatient === undefined || sourceImageMetadata.FrameOfReferenceUID !== FrameOfReferenceUID || sourceImageMetadata.SeriesInstanceUID !== ReferencedSeriesInstanceUID) {
       continue;
     }
@@ -950,11 +934,11 @@ function getImageIdOfSourceImagebyGeometry(ReferencedSeriesInstanceUID, FrameOfR
  * @return {String}                  The imageId that corresponds to the sopInstanceUid.
  */
 function getImageIdOfReferencedFrame(sopInstanceUid, frameNumber, sopUIDImageIdIndexMap) {
-  var imageId = sopUIDImageIdIndexMap[sopInstanceUid];
+  const imageId = sopUIDImageIdIndexMap[sopInstanceUid];
   if (!imageId) {
     return;
   }
-  var imageIdFrameNumber = Number(imageId.split("frame=")[1]);
+  const imageIdFrameNumber = Number(imageId.split("frame=")[1]);
   return imageIdFrameNumber === frameNumber - 1 ? imageId : undefined;
 }
 
@@ -965,7 +949,7 @@ function getImageIdOfReferencedFrame(sopInstanceUid, frameNumber, sopUIDImageIdI
  * @return {Number[8][6]} An array of valid orientations.
  */
 function getValidOrientations(iop) {
-  var orientations = [];
+  const orientations = [];
 
   // [0,  1,  2]: 0,   0hf,   0vf
   // [3,  4,  5]: 90,  90hf,  90vf
@@ -974,7 +958,7 @@ function getValidOrientations(iop) {
   orientations[0] = iop;
   orientations[1] = flipIOP.h(iop);
   orientations[2] = flipIOP.v(iop);
-  var iop90 = rotateDirectionCosinesInPlane(iop, Math.PI / 2);
+  const iop90 = rotateDirectionCosinesInPlane(iop, Math.PI / 2);
   orientations[3] = iop90;
   orientations[4] = flipIOP.h(iop90);
   orientations[5] = flipIOP.v(iop90);
@@ -1032,17 +1016,17 @@ function alignPixelDataWithSourceData(pixelData2D, iop, orientations, tolerance)
   }
 }
 function getSegmentMetadata(multiframe, seriesInstanceUid) {
-  var segmentSequence = multiframe.SegmentSequence;
-  var data = [];
+  const segmentSequence = multiframe.SegmentSequence;
+  let data = [];
   if (Array.isArray(segmentSequence)) {
-    data = [undefined].concat(_toConsumableArray(segmentSequence));
+    data = [undefined, ...segmentSequence];
   } else {
     // Only one segment, will be stored as an object.
     data = [undefined, segmentSequence];
   }
   return {
-    seriesInstanceUid: seriesInstanceUid,
-    data: data
+    seriesInstanceUid,
+    data
   };
 }
 
@@ -1056,18 +1040,18 @@ function getSegmentMetadata(multiframe, seriesInstanceUid) {
  * @returns {Uint8Array} A new Uint8Array containing the requested bytes.
  */
 function readFromUnpackedChunks(chunks, offset, length) {
-  var mapping = getUnpackedOffsetAndLength(chunks, offset, length);
+  const mapping = getUnpackedOffsetAndLength(chunks, offset, length);
 
   // If all the data is in one chunk, we can just slice that chunk
   if (mapping.start.chunkIndex === mapping.end.chunkIndex) {
     return new Uint8Array(chunks[mapping.start.chunkIndex].buffer, mapping.start.offset, length);
   } else {
     // If the data spans multiple chunks, we need to create a new Uint8Array and copy the data from each chunk
-    var result = new Uint8Array(length);
-    var resultOffset = 0;
-    for (var i = mapping.start.chunkIndex; i <= mapping.end.chunkIndex; i++) {
-      var start = i === mapping.start.chunkIndex ? mapping.start.offset : 0;
-      var end = i === mapping.end.chunkIndex ? mapping.end.offset : chunks[i].length;
+    let result = new Uint8Array(length);
+    let resultOffset = 0;
+    for (let i = mapping.start.chunkIndex; i <= mapping.end.chunkIndex; i++) {
+      let start = i === mapping.start.chunkIndex ? mapping.start.offset : 0;
+      let end = i === mapping.end.chunkIndex ? mapping.end.offset : chunks[i].length;
       result.set(new Uint8Array(chunks[i].buffer, start, end - start), resultOffset);
       resultOffset += end - start;
     }
@@ -1075,9 +1059,7 @@ function readFromUnpackedChunks(chunks, offset, length) {
   }
 }
 function getUnpackedOffsetAndLength(chunks, offset, length) {
-  var totalBytes = chunks.reduce(function (total, chunk) {
-    return total + chunk.length;
-  }, 0);
+  var totalBytes = chunks.reduce((total, chunk) => total + chunk.length, 0);
   if (offset < 0 || offset + length > totalBytes) {
     throw new Error("Offset and length out of bounds");
   }
@@ -1105,61 +1087,51 @@ function getUnpackedOffsetAndLength(chunks, offset, length) {
   };
 }
 function calculateCentroid(imageIdIndexBufferIndex, multiframe, metadataProvider, imageIds) {
-  var xAcc = 0;
-  var yAcc = 0;
-  var zAcc = 0;
-  var worldXAcc = 0;
-  var worldYAcc = 0;
-  var worldZAcc = 0;
-  var count = 0;
-  for (var _i3 = 0, _Object$entries = Object.entries(imageIdIndexBufferIndex); _i3 < _Object$entries.length; _i3++) {
-    var _Object$entries$_i = _slicedToArray(_Object$entries[_i3], 2),
-      imageIdIndex = _Object$entries$_i[0],
-      bufferIndices = _Object$entries$_i[1];
-    var z = Number(imageIdIndex);
+  let xAcc = 0;
+  let yAcc = 0;
+  let zAcc = 0;
+  let worldXAcc = 0;
+  let worldYAcc = 0;
+  let worldZAcc = 0;
+  let count = 0;
+  for (const [imageIdIndex, bufferIndices] of Object.entries(imageIdIndexBufferIndex)) {
+    const z = Number(imageIdIndex);
     if (!bufferIndices || bufferIndices.length === 0) {
       continue;
     }
 
     // Get metadata for this slice
-    var imageId = imageIds[z];
-    var imagePlaneModule = metadataProvider.get("imagePlaneModule", imageId);
+    const imageId = imageIds[z];
+    const imagePlaneModule = metadataProvider.get("imagePlaneModule", imageId);
     if (!imagePlaneModule) {
       console.debug("Missing imagePlaneModule metadata for centroid calculation");
       continue;
     }
-    var imagePositionPatient = imagePlaneModule.imagePositionPatient,
-      rowCosines = imagePlaneModule.rowCosines,
-      columnCosines = imagePlaneModule.columnCosines,
-      rowPixelSpacing = imagePlaneModule.rowPixelSpacing,
-      columnPixelSpacing = imagePlaneModule.columnPixelSpacing;
-    var _iterator2 = _createForOfIteratorHelper(bufferIndices),
-      _step2;
-    try {
-      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-        var bufferIndex = _step2.value;
-        var y = Math.floor(bufferIndex / multiframe.Rows);
-        var x = bufferIndex % multiframe.Rows;
-
-        // Image coordinates
-        xAcc += x;
-        yAcc += y;
-        zAcc += z;
-
-        // Calculate world coordinates
-        // P(world) = P(image) * IOP * spacing + IPP
-        var worldX = imagePositionPatient[0] + x * rowCosines[0] * columnPixelSpacing + y * columnCosines[0] * rowPixelSpacing;
-        var worldY = imagePositionPatient[1] + x * rowCosines[1] * columnPixelSpacing + y * columnCosines[1] * rowPixelSpacing;
-        var worldZ = imagePositionPatient[2] + x * rowCosines[2] * columnPixelSpacing + y * columnCosines[2] * rowPixelSpacing;
-        worldXAcc += worldX;
-        worldYAcc += worldY;
-        worldZAcc += worldZ;
-        count++;
-      }
-    } catch (err) {
-      _iterator2.e(err);
-    } finally {
-      _iterator2.f();
+    const {
+      imagePositionPatient,
+      rowCosines,
+      columnCosines,
+      rowPixelSpacing,
+      columnPixelSpacing
+    } = imagePlaneModule;
+    for (const bufferIndex of bufferIndices) {
+      const y = Math.floor(bufferIndex / multiframe.Rows);
+      const x = bufferIndex % multiframe.Rows;
+
+      // Image coordinates
+      xAcc += x;
+      yAcc += y;
+      zAcc += z;
+
+      // Calculate world coordinates
+      // P(world) = P(image) * IOP * spacing + IPP
+      const worldX = imagePositionPatient[0] + x * rowCosines[0] * columnPixelSpacing + y * columnCosines[0] * rowPixelSpacing;
+      const worldY = imagePositionPatient[1] + x * rowCosines[1] * columnPixelSpacing + y * columnCosines[1] * rowPixelSpacing;
+      const worldZ = imagePositionPatient[2] + x * rowCosines[2] * columnPixelSpacing + y * columnCosines[2] * rowPixelSpacing;
+      worldXAcc += worldX;
+      worldYAcc += worldY;
+      worldZAcc += worldZ;
+      count++;
     }
   }
   return {
@@ -1173,13 +1145,13 @@ function calculateCentroid(imageIdIndexBufferIndex, multiframe, metadataProvider
       y: worldYAcc / count,
       z: worldZAcc / count
     },
-    count: count
+    count
   };
 }
-var Segmentation = {
-  generateSegmentation: generateSegmentation,
-  generateToolState: generateToolState,
-  fillSegmentation: fillSegmentation
+const Segmentation = {
+  generateSegmentation,
+  generateToolState,
+  fillSegmentation
 };
 
 export { _createSegFromImages, _getLabelmapsFromReferencedFrameIndicies, alignPixelDataWithSourceData, calculateCentroid, checkSEGsOverlapping, Segmentation as default, fillSegmentation, findReferenceSourceImageId, generateSegmentation, generateToolState, getImageIdOfReferencedFrame, getImageIdOfSourceImageBySourceImageSequence, getImageIdOfSourceImagebyGeometry, getSegmentIndex, getSegmentMetadata, getUnpackedChunks, getUnpackedOffsetAndLength, getValidOrientations, insertOverlappingPixelDataPlanar, insertPixelDataPlanar, readFromUnpackedChunks, unpackPixelData };