@ohif/app 3.7.0-beta.7 → 3.7.0-beta.71

package/dist/{606.bundle.5d876f5f3dd8287f0a28.js → 202.bundle.591726b6144882ba0ee0.js}

@@ -1,19 +1,23 @@
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[606],{
+(self["webpackChunk"] = self["webpackChunk"] || []).push([[202],{
 
-/***/ 4606:
+/***/ 91202:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   adaptersSR: () => (/* binding */ adapters)
+/* harmony export */   Yb: () => (/* binding */ index),
+/* harmony export */   adaptersSR: () => (/* binding */ adaptersSR),
+/* harmony export */   ok: () => (/* binding */ adaptersSEG)
 /* harmony export */ });
-/* unused harmony export default */
-/* harmony import */ var dcmjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(22737);
-/* harmony import */ var ndarray__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(73373);
+/* unused harmony export helpers */
+/* harmony import */ var dcmjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(67540);
+/* harmony import */ var ndarray__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(87513);
 /* harmony import */ var ndarray__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(ndarray__WEBPACK_IMPORTED_MODULE_1__);
-/* harmony import */ var lodash_clonedeep__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(71975);
+/* harmony import */ var lodash_clonedeep__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(11677);
 /* harmony import */ var lodash_clonedeep__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(lodash_clonedeep__WEBPACK_IMPORTED_MODULE_2__);
-/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(88256);
+/* harmony import */ var buffer__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(58955);
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(45451);
+
 
 
 
@@ -67,6 +71,337 @@ function _objectSpread2(target) {
   }
   return target;
 }
+function _regeneratorRuntime() {
+  _regeneratorRuntime = function () {
+    return exports;
+  };
+  var exports = {},
+    Op = Object.prototype,
+    hasOwn = Op.hasOwnProperty,
+    defineProperty = Object.defineProperty || function (obj, key, desc) {
+      obj[key] = desc.value;
+    },
+    $Symbol = "function" == typeof Symbol ? Symbol : {},
+    iteratorSymbol = $Symbol.iterator || "@@iterator",
+    asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
+    toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+  function define(obj, key, value) {
+    return Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }), obj[key];
+  }
+  try {
+    define({}, "");
+  } catch (err) {
+    define = function (obj, key, value) {
+      return obj[key] = value;
+    };
+  }
+  function wrap(innerFn, outerFn, self, tryLocsList) {
+    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
+      generator = Object.create(protoGenerator.prototype),
+      context = new Context(tryLocsList || []);
+    return defineProperty(generator, "_invoke", {
+      value: makeInvokeMethod(innerFn, self, context)
+    }), generator;
+  }
+  function tryCatch(fn, obj, arg) {
+    try {
+      return {
+        type: "normal",
+        arg: fn.call(obj, arg)
+      };
+    } catch (err) {
+      return {
+        type: "throw",
+        arg: err
+      };
+    }
+  }
+  exports.wrap = wrap;
+  var ContinueSentinel = {};
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+  var IteratorPrototype = {};
+  define(IteratorPrototype, iteratorSymbol, function () {
+    return this;
+  });
+  var getProto = Object.getPrototypeOf,
+    NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+  NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
+  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
+  function defineIteratorMethods(prototype) {
+    ["next", "throw", "return"].forEach(function (method) {
+      define(prototype, method, function (arg) {
+        return this._invoke(method, arg);
+      });
+    });
+  }
+  function AsyncIterator(generator, PromiseImpl) {
+    function invoke(method, arg, resolve, reject) {
+      var record = tryCatch(generator[method], generator, arg);
+      if ("throw" !== record.type) {
+        var result = record.arg,
+          value = result.value;
+        return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
+          invoke("next", value, resolve, reject);
+        }, function (err) {
+          invoke("throw", err, resolve, reject);
+        }) : PromiseImpl.resolve(value).then(function (unwrapped) {
+          result.value = unwrapped, resolve(result);
+        }, function (error) {
+          return invoke("throw", error, resolve, reject);
+        });
+      }
+      reject(record.arg);
+    }
+    var previousPromise;
+    defineProperty(this, "_invoke", {
+      value: function (method, arg) {
+        function callInvokeWithMethodAndArg() {
+          return new PromiseImpl(function (resolve, reject) {
+            invoke(method, arg, resolve, reject);
+          });
+        }
+        return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+      }
+    });
+  }
+  function makeInvokeMethod(innerFn, self, context) {
+    var state = "suspendedStart";
+    return function (method, arg) {
+      if ("executing" === state) throw new Error("Generator is already running");
+      if ("completed" === state) {
+        if ("throw" === method) throw arg;
+        return doneResult();
+      }
+      for (context.method = method, context.arg = arg;;) {
+        var delegate = context.delegate;
+        if (delegate) {
+          var delegateResult = maybeInvokeDelegate(delegate, context);
+          if (delegateResult) {
+            if (delegateResult === ContinueSentinel) continue;
+            return delegateResult;
+          }
+        }
+        if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
+          if ("suspendedStart" === state) throw state = "completed", context.arg;
+          context.dispatchException(context.arg);
+        } else "return" === context.method && context.abrupt("return", context.arg);
+        state = "executing";
+        var record = tryCatch(innerFn, self, context);
+        if ("normal" === record.type) {
+          if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
+          return {
+            value: record.arg,
+            done: context.done
+          };
+        }
+        "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
+      }
+    };
+  }
+  function maybeInvokeDelegate(delegate, context) {
+    var methodName = context.method,
+      method = delegate.iterator[methodName];
+    if (undefined === method) return context.delegate = null, "throw" === methodName && delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method) || "return" !== methodName && (context.method = "throw", context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method")), ContinueSentinel;
+    var record = tryCatch(method, delegate.iterator, context.arg);
+    if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
+    var info = record.arg;
+    return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
+  }
+  function pushTryEntry(locs) {
+    var entry = {
+      tryLoc: locs[0]
+    };
+    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
+  }
+  function resetTryEntry(entry) {
+    var record = entry.completion || {};
+    record.type = "normal", delete record.arg, entry.completion = record;
+  }
+  function Context(tryLocsList) {
+    this.tryEntries = [{
+      tryLoc: "root"
+    }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
+  }
+  function values(iterable) {
+    if (iterable) {
+      var iteratorMethod = iterable[iteratorSymbol];
+      if (iteratorMethod) return iteratorMethod.call(iterable);
+      if ("function" == typeof iterable.next) return iterable;
+      if (!isNaN(iterable.length)) {
+        var i = -1,
+          next = function next() {
+            for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
+            return next.value = undefined, next.done = !0, next;
+          };
+        return next.next = next;
+      }
+    }
+    return {
+      next: doneResult
+    };
+  }
+  function doneResult() {
+    return {
+      value: undefined,
+      done: !0
+    };
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", {
+    value: GeneratorFunctionPrototype,
+    configurable: !0
+  }), defineProperty(GeneratorFunctionPrototype, "constructor", {
+    value: GeneratorFunction,
+    configurable: !0
+  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
+    var ctor = "function" == typeof genFun && genFun.constructor;
+    return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
+  }, exports.mark = function (genFun) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
+  }, exports.awrap = function (arg) {
+    return {
+      __await: arg
+    };
+  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
+    return this;
+  }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+    void 0 === PromiseImpl && (PromiseImpl = Promise);
+    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
+    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
+      return result.done ? result.value : iter.next();
+    });
+  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
+    return this;
+  }), define(Gp, "toString", function () {
+    return "[object Generator]";
+  }), exports.keys = function (val) {
+    var object = Object(val),
+      keys = [];
+    for (var key in object) keys.push(key);
+    return keys.reverse(), function next() {
+      for (; keys.length;) {
+        var key = keys.pop();
+        if (key in object) return next.value = key, next.done = !1, next;
+      }
+      return next.done = !0, next;
+    };
+  }, exports.values = values, Context.prototype = {
+    constructor: Context,
+    reset: function (skipTempReset) {
+      if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
+    },
+    stop: function () {
+      this.done = !0;
+      var rootRecord = this.tryEntries[0].completion;
+      if ("throw" === rootRecord.type) throw rootRecord.arg;
+      return this.rval;
+    },
+    dispatchException: function (exception) {
+      if (this.done) throw exception;
+      var context = this;
+      function handle(loc, caught) {
+        return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
+      }
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i],
+          record = entry.completion;
+        if ("root" === entry.tryLoc) return handle("end");
+        if (entry.tryLoc <= this.prev) {
+          var hasCatch = hasOwn.call(entry, "catchLoc"),
+            hasFinally = hasOwn.call(entry, "finallyLoc");
+          if (hasCatch && hasFinally) {
+            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+          } else if (hasCatch) {
+            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+          } else {
+            if (!hasFinally) throw new Error("try statement without catch or finally");
+            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+          }
+        }
+      }
+    },
+    abrupt: function (type, arg) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+          var finallyEntry = entry;
+          break;
+        }
+      }
+      finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
+      var record = finallyEntry ? finallyEntry.completion : {};
+      return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
+    },
+    complete: function (record, afterLoc) {
+      if ("throw" === record.type) throw record.arg;
+      return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
+    },
+    finish: function (finallyLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
+      }
+    },
+    catch: function (tryLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.tryLoc === tryLoc) {
+          var record = entry.completion;
+          if ("throw" === record.type) {
+            var thrown = record.arg;
+            resetTryEntry(entry);
+          }
+          return thrown;
+        }
+      }
+      throw new Error("illegal catch attempt");
+    },
+    delegateYield: function (iterable, resultName, nextLoc) {
+      return this.delegate = {
+        iterator: values(iterable),
+        resultName: resultName,
+        nextLoc: nextLoc
+      }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
+    }
+  }, exports;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}
+function _asyncToGenerator(fn) {
+  return function () {
+    var self = this,
+      args = arguments;
+    return new Promise(function (resolve, reject) {
+      var gen = fn.apply(self, args);
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+      _next(undefined);
+    });
+  };
+}
 function _classCallCheck(instance, Constructor) {
   if (!(instance instanceof Constructor)) {
     throw new TypeError("Cannot call a class as a function");
@@ -203,19 +538,43 @@ function _toPropertyKey(arg) {
   return typeof key === "symbol" ? key : String(key);
 }
 
-var toArray = function toArray(x) {
-  return Array.isArray(x) ? x : [x];
+var toArray = function (x) { return (Array.isArray(x) ? x : [x]); };
+
+/**
+ * Returns a function that checks if a given content item's ConceptNameCodeSequence.CodeMeaning
+ * matches the provided codeMeaningName.
+ * @param codeMeaningName - The CodeMeaning to match against.
+ * @returns A function that takes a content item and returns a boolean indicating whether the
+ * content item's CodeMeaning matches the provided codeMeaningName.
+ */
+var codeMeaningEquals = function (codeMeaningName) {
+    return function (contentItem) {
+        return (contentItem.ConceptNameCodeSequence.CodeMeaning === codeMeaningName);
+    };
 };
-var codeMeaningEquals = function codeMeaningEquals(codeMeaningName) {
-  return function (contentItem) {
-    return contentItem.ConceptNameCodeSequence.CodeMeaning === codeMeaningName;
-  };
+
+/**
+ * Checks if a given content item's GraphicType property matches a specified value.
+ * @param {string} graphicType - The value to compare the content item's GraphicType property to.
+ * @returns {function} A function that takes a content item and returns a boolean indicating whether its GraphicType property matches the specified value.
+ */
+var graphicTypeEquals = function (graphicType) {
+    return function (contentItem) {
+        return contentItem && contentItem.GraphicType === graphicType;
+    };
 };
 
+var index$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  codeMeaningEquals: codeMeaningEquals,
+  graphicTypeEquals: graphicTypeEquals,
+  toArray: toArray
+});
+
 var TID1500$1 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.TID1500,
   addAccessors$1 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.addAccessors;
 var StructuredReport$1 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .derivations */ .U7.StructuredReport;
-var Normalizer$3 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .normalizers */ .oq.Normalizer;
+var Normalizer$4 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .normalizers */ .oq.Normalizer;
 var TID1500MeasurementReport$1 = TID1500$1.TID1500MeasurementReport,
   TID1501MeasurementGroup$1 = TID1500$1.TID1501MeasurementGroup;
 var DicomMetaDictionary$3 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .data */ .aT.DicomMetaDictionary;
@@ -347,7 +706,7 @@ var MeasurementReport$1 = /*#__PURE__*/function () {
           ReferencedSOPClassUID: sopCommonModule.sopClassUID,
           ReferencedSOPInstanceUID: sopCommonModule.sopInstanceUID
         };
-        if (Normalizer$3.isMultiframeSOPClassUID(sopCommonModule.sopClassUID)) {
+        if (Normalizer$4.isMultiframeSOPClassUID(sopCommonModule.sopClassUID)) {
           ReferencedSOPSequence.ReferencedFrameNumber = frameNumber;
         }
 
@@ -1181,176 +1540,449 @@ ArrowAnnotate$1.isValidCornerstoneTrackingIdentifier = function (TrackingIdentif
 };
 MeasurementReport$1.registerTool(ArrowAnnotate$1);
 
-var _utilities$orientatio$1 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.orientation,
-  rotateDirectionCosinesInPlane$1 = _utilities$orientatio$1.rotateDirectionCosinesInPlane,
-  flipIOP$1 = _utilities$orientatio$1.flipImageOrientationPatient,
-  flipMatrix2D$1 = _utilities$orientatio$1.flipMatrix2D,
-  rotateMatrix902D$1 = _utilities$orientatio$1.rotateMatrix902D;
-var datasetToBlob$1 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.datasetToBlob,
-  BitArray$2 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.BitArray,
-  DicomMessage$1 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.DicomMessage,
-  DicomMetaDictionary$2 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.DicomMetaDictionary;
-var Normalizer$2 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .normalizers */ .oq.Normalizer;
-var SegmentationDerivation$1 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .derivations */ .U7.Segmentation;
-var Segmentation$3 = {
-  generateSegmentation: generateSegmentation$2,
-  generateToolState: generateToolState$2
-};
-
-/**
- *
- * @typedef {Object} BrushData
- * @property {Object} toolState - The cornerstoneTools global toolState.
- * @property {Object[]} segments - The cornerstoneTools segment metadata that corresponds to the
- *                                 seriesInstanceUid.
- */
-
-/**
- * generateSegmentation - Generates cornerstoneTools brush data, given a stack of
- * imageIds, images and the cornerstoneTools brushData.
- *
- * @param  {object[]} images    An array of the cornerstone image objects.
- * @param  {BrushData} brushData and object containing the brushData.
- * @returns {type}           description
- */
-function generateSegmentation$2(images, brushData) {
-  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
-    includeSliceSpacing: true
-  };
-  var toolState = brushData.toolState,
-    segments = brushData.segments;
-
-  // Calculate the dimensions of the data cube.
-  var image0 = images[0];
-  var dims = {
-    x: image0.columns,
-    y: image0.rows,
-    z: images.length
-  };
-  dims.xy = dims.x * dims.y;
-  var numSegments = _getSegCount(seg, segments);
-  if (!numSegments) {
-    throw new Error("No segments to export!");
+var TID300CobbAngle$2 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.TID300.CobbAngle;
+var COBB_ANGLE = "CobbAngle";
+var CobbAngle$1 = /*#__PURE__*/function () {
+  function CobbAngle() {
+    _classCallCheck(this, CobbAngle);
   }
-  var isMultiframe = image0.imageId.includes("?frame");
-  var seg = _createSegFromImages$1(images, isMultiframe, options);
-  var _getNumberOfFramesPer = _getNumberOfFramesPerSegment(toolState, images, segments),
-    referencedFramesPerSegment = _getNumberOfFramesPer.referencedFramesPerSegment,
-    segmentIndicies = _getNumberOfFramesPer.segmentIndicies;
-  var NumberOfFrames = 0;
-  for (var i = 0; i < referencedFramesPerSegment.length; i++) {
-    NumberOfFrames += referencedFramesPerSegment[i].length;
+  _createClass(CobbAngle, null, [{
+    key: "getMeasurementData",
+    value:
+    // TODO: this function is required for all Cornerstone Tool Adapters, since it is called by MeasurementReport.
+    function getMeasurementData(MeasurementGroup) {
+      var _MeasurementReport$ge = MeasurementReport$1.getSetupMeasurementData(MeasurementGroup),
+        defaultState = _MeasurementReport$ge.defaultState,
+        NUMGroup = _MeasurementReport$ge.NUMGroup,
+        SCOORDGroup = _MeasurementReport$ge.SCOORDGroup;
+      var state = _objectSpread2(_objectSpread2({}, defaultState), {}, {
+        rAngle: NUMGroup.MeasuredValueSequence.NumericValue,
+        toolType: CobbAngle.toolType,
+        handles: {
+          start: {},
+          end: {},
+          start2: {
+            highlight: true,
+            drawnIndependently: true
+          },
+          end2: {
+            highlight: true,
+            drawnIndependently: true
+          },
+          textBox: {
+            hasMoved: false,
+            movesIndependently: false,
+            drawnIndependently: true,
+            allowedOutsideImage: true,
+            hasBoundingBox: true
+          }
+        }
+      });
+      var _SCOORDGroup$GraphicD = _slicedToArray(SCOORDGroup.GraphicData, 8);
+      state.handles.start.x = _SCOORDGroup$GraphicD[0];
+      state.handles.start.y = _SCOORDGroup$GraphicD[1];
+      state.handles.end.x = _SCOORDGroup$GraphicD[2];
+      state.handles.end.y = _SCOORDGroup$GraphicD[3];
+      state.handles.start2.x = _SCOORDGroup$GraphicD[4];
+      state.handles.start2.y = _SCOORDGroup$GraphicD[5];
+      state.handles.end2.x = _SCOORDGroup$GraphicD[6];
+      state.handles.end2.y = _SCOORDGroup$GraphicD[7];
+      return state;
+    }
+  }, {
+    key: "getTID300RepresentationArguments",
+    value: function getTID300RepresentationArguments(tool) {
+      var handles = tool.handles,
+        finding = tool.finding,
+        findingSites = tool.findingSites;
+      var point1 = handles.start;
+      var point2 = handles.end;
+      var point3 = handles.start2;
+      var point4 = handles.end2;
+      var rAngle = tool.rAngle;
+      var trackingIdentifierTextValue = "cornerstoneTools@^4.0.0:CobbAngle";
+      return {
+        point1: point1,
+        point2: point2,
+        point3: point3,
+        point4: point4,
+        rAngle: rAngle,
+        trackingIdentifierTextValue: trackingIdentifierTextValue,
+        finding: finding,
+        findingSites: findingSites || []
+      };
+    }
+  }]);
+  return CobbAngle;
+}();
+CobbAngle$1.toolType = COBB_ANGLE;
+CobbAngle$1.utilityToolType = COBB_ANGLE;
+CobbAngle$1.TID300Representation = TID300CobbAngle$2;
+CobbAngle$1.isValidCornerstoneTrackingIdentifier = function (TrackingIdentifier) {
+  if (!TrackingIdentifier.includes(":")) {
+    return false;
   }
-  seg.setNumberOfFrames(NumberOfFrames);
-  for (var _i = 0; _i < segmentIndicies.length; _i++) {
-    var segmentIndex = segmentIndicies[_i];
-    var referencedFrameIndicies = referencedFramesPerSegment[_i];
-
-    // Frame numbers start from 1.
-    var referencedFrameNumbers = referencedFrameIndicies.map(function (element) {
-      return element + 1;
-    });
-    var segment = segments[segmentIndex];
-    seg.addSegment(segment, _extractCornerstoneToolsPixelData(segmentIndex, referencedFrameIndicies, toolState, images, dims), referencedFrameNumbers);
+  var _TrackingIdentifier$s = TrackingIdentifier.split(":"),
+    _TrackingIdentifier$s2 = _slicedToArray(_TrackingIdentifier$s, 2),
+    cornerstone4Tag = _TrackingIdentifier$s2[0],
+    toolType = _TrackingIdentifier$s2[1];
+  if (cornerstone4Tag !== CORNERSTONE_4_TAG) {
+    return false;
   }
-  seg.bitPackPixelData();
-  var segBlob = datasetToBlob$1(seg.dataset);
-  return segBlob;
-}
-function _extractCornerstoneToolsPixelData(segmentIndex, referencedFrames, toolState, images, dims) {
-  var pixelData = new Uint8Array(dims.xy * referencedFrames.length);
-  var pixelDataIndex = 0;
-  for (var i = 0; i < referencedFrames.length; i++) {
-    var frame = referencedFrames[i];
-    var imageId = images[frame].imageId;
-    var imageIdSpecificToolState = toolState[imageId];
-    var brushPixelData = imageIdSpecificToolState.brush.data[segmentIndex].pixelData;
-    for (var p = 0; p < brushPixelData.length; p++) {
-      pixelData[pixelDataIndex] = brushPixelData[p];
-      pixelDataIndex++;
-    }
+  return toolType === COBB_ANGLE;
+};
+MeasurementReport$1.registerTool(CobbAngle$1);
+
+var TID300Angle = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.TID300.Angle;
+var ANGLE = "Angle";
+var Angle$1 = /*#__PURE__*/function () {
+  function Angle() {
+    _classCallCheck(this, Angle);
   }
-  return pixelData;
-}
-function _getNumberOfFramesPerSegment(toolState, images, segments) {
-  var segmentIndicies = [];
-  var referencedFramesPerSegment = [];
-  for (var i = 0; i < segments.length; i++) {
-    if (segments[i]) {
-      segmentIndicies.push(i);
-      referencedFramesPerSegment.push([]);
+  _createClass(Angle, null, [{
+    key: "getMeasurementData",
+    value:
+    /**
+     * Generate TID300 measurement data for a plane angle measurement - use a Angle, but label it as Angle
+     */
+    function getMeasurementData(MeasurementGroup) {
+      var _MeasurementReport$ge = MeasurementReport$1.getSetupMeasurementData(MeasurementGroup),
+        defaultState = _MeasurementReport$ge.defaultState,
+        NUMGroup = _MeasurementReport$ge.NUMGroup,
+        SCOORDGroup = _MeasurementReport$ge.SCOORDGroup;
+      var state = _objectSpread2(_objectSpread2({}, defaultState), {}, {
+        rAngle: NUMGroup.MeasuredValueSequence.NumericValue,
+        toolType: Angle.toolType,
+        handles: {
+          start: {},
+          middle: {},
+          end: {},
+          textBox: {
+            hasMoved: false,
+            movesIndependently: false,
+            drawnIndependently: true,
+            allowedOutsideImage: true,
+            hasBoundingBox: true
+          }
+        }
+      });
+      var _SCOORDGroup$GraphicD = _slicedToArray(SCOORDGroup.GraphicData, 8);
+      state.handles.start.x = _SCOORDGroup$GraphicD[0];
+      state.handles.start.y = _SCOORDGroup$GraphicD[1];
+      state.handles.middle.x = _SCOORDGroup$GraphicD[2];
+      state.handles.middle.y = _SCOORDGroup$GraphicD[3];
+      state.handles.middle.x = _SCOORDGroup$GraphicD[4];
+      state.handles.middle.y = _SCOORDGroup$GraphicD[5];
+      state.handles.end.x = _SCOORDGroup$GraphicD[6];
+      state.handles.end.y = _SCOORDGroup$GraphicD[7];
+      return state;
     }
-  }
-  for (var z = 0; z < images.length; z++) {
-    var imageId = images[z].imageId;
-    var imageIdSpecificToolState = toolState[imageId];
-    for (var _i2 = 0; _i2 < segmentIndicies.length; _i2++) {
-      var segIdx = segmentIndicies[_i2];
-      if (imageIdSpecificToolState && imageIdSpecificToolState.brush && imageIdSpecificToolState.brush.data && imageIdSpecificToolState.brush.data[segIdx] && imageIdSpecificToolState.brush.data[segIdx].pixelData) {
-        referencedFramesPerSegment[_i2].push(z);
-      }
+  }, {
+    key: "getTID300RepresentationArguments",
+    value: function getTID300RepresentationArguments(tool) {
+      var handles = tool.handles,
+        finding = tool.finding,
+        findingSites = tool.findingSites;
+      var point1 = handles.start;
+      var point2 = handles.middle;
+      var point3 = handles.middle;
+      var point4 = handles.end;
+      var rAngle = tool.rAngle;
+      var trackingIdentifierTextValue = "cornerstoneTools@^4.0.0:Angle";
+      return {
+        point1: point1,
+        point2: point2,
+        point3: point3,
+        point4: point4,
+        rAngle: rAngle,
+        trackingIdentifierTextValue: trackingIdentifierTextValue,
+        finding: finding,
+        findingSites: findingSites || []
+      };
     }
+  }]);
+  return Angle;
+}();
+Angle$1.toolType = ANGLE;
+Angle$1.utilityToolType = ANGLE;
+Angle$1.TID300Representation = TID300Angle;
+Angle$1.isValidCornerstoneTrackingIdentifier = function (TrackingIdentifier) {
+  if (!TrackingIdentifier.includes(":")) {
+    return false;
   }
-  return {
-    referencedFramesPerSegment: referencedFramesPerSegment,
-    segmentIndicies: segmentIndicies
-  };
-}
-function _getSegCount(seg, segments) {
-  var numSegments = 0;
-  for (var i = 0; i < segments.length; i++) {
-    if (segments[i]) {
-      numSegments++;
-    }
+  var _TrackingIdentifier$s = TrackingIdentifier.split(":"),
+    _TrackingIdentifier$s2 = _slicedToArray(_TrackingIdentifier$s, 2),
+    cornerstone4Tag = _TrackingIdentifier$s2[0],
+    toolType = _TrackingIdentifier$s2[1];
+  if (cornerstone4Tag !== CORNERSTONE_4_TAG) {
+    return false;
   }
-  return numSegments;
-}
+  return toolType === ANGLE;
+};
+MeasurementReport$1.registerTool(Angle$1);
 
-/**
- * _createSegFromImages - description
- *
- * @param  {Object[]} images    An array of the cornerstone image objects.
- * @param  {Boolean} isMultiframe Whether the images are multiframe.
- * @returns {Object}              The Seg derived dataSet.
- */
-function _createSegFromImages$1(images, isMultiframe, options) {
-  var datasets = [];
-  if (isMultiframe) {
-    var image = images[0];
-    var arrayBuffer = image.data.byteArray.buffer;
-    var dicomData = DicomMessage$1.readFile(arrayBuffer);
-    var dataset = DicomMetaDictionary$2.naturalizeDataset(dicomData.dict);
-    dataset._meta = DicomMetaDictionary$2.namifyDataset(dicomData.meta);
-    datasets.push(dataset);
-  } else {
-    for (var i = 0; i < images.length; i++) {
-      var _image = images[i];
-      var _arrayBuffer = _image.data.byteArray.buffer;
-      var _dicomData = DicomMessage$1.readFile(_arrayBuffer);
-      var _dataset = DicomMetaDictionary$2.naturalizeDataset(_dicomData.dict);
-      _dataset._meta = DicomMetaDictionary$2.namifyDataset(_dicomData.meta);
-      datasets.push(_dataset);
+var TID300Polyline$2 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.TID300.Polyline;
+var RectangleRoi = /*#__PURE__*/function () {
+  function RectangleRoi() {
+    _classCallCheck(this, RectangleRoi);
+  }
+  _createClass(RectangleRoi, null, [{
+    key: "getMeasurementData",
+    value: function getMeasurementData(MeasurementGroup) {
+      var _MeasurementReport$ge = MeasurementReport$1.getSetupMeasurementData(MeasurementGroup),
+        defaultState = _MeasurementReport$ge.defaultState,
+        SCOORDGroup = _MeasurementReport$ge.SCOORDGroup,
+        NUMGroup = _MeasurementReport$ge.NUMGroup;
+      var state = _objectSpread2(_objectSpread2({}, defaultState), {}, {
+        toolType: RectangleRoi.toolType,
+        handles: {
+          start: {},
+          end: {},
+          textBox: {
+            active: false,
+            hasMoved: false,
+            movesIndependently: false,
+            drawnIndependently: true,
+            allowedOutsideImage: true,
+            hasBoundingBox: true
+          },
+          initialRotation: 0
+        },
+        cachedStats: {
+          area: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : 0
+        },
+        color: undefined,
+        invalidated: true
+      });
+      var _SCOORDGroup$GraphicD = _slicedToArray(SCOORDGroup.GraphicData, 6);
+      state.handles.start.x = _SCOORDGroup$GraphicD[0];
+      state.handles.start.y = _SCOORDGroup$GraphicD[1];
+      _SCOORDGroup$GraphicD[2];
+      _SCOORDGroup$GraphicD[3];
+      state.handles.end.x = _SCOORDGroup$GraphicD[4];
+      state.handles.end.y = _SCOORDGroup$GraphicD[5];
+      return state;
+    }
+  }, {
+    key: "getTID300RepresentationArguments",
+    value: function getTID300RepresentationArguments(tool) {
+      var finding = tool.finding,
+        findingSites = tool.findingSites,
+        _tool$cachedStats = tool.cachedStats,
+        cachedStats = _tool$cachedStats === void 0 ? {} : _tool$cachedStats,
+        handles = tool.handles;
+      var start = handles.start,
+        end = handles.end;
+      var points = [start, {
+        x: start.x,
+        y: end.y
+      }, end, {
+        x: end.x,
+        y: start.y
+      }];
+      var area = cachedStats.area,
+        perimeter = cachedStats.perimeter;
+      var trackingIdentifierTextValue = "cornerstoneTools@^4.0.0:RectangleRoi";
+      return {
+        points: points,
+        area: area,
+        perimeter: perimeter,
+        trackingIdentifierTextValue: trackingIdentifierTextValue,
+        finding: finding,
+        findingSites: findingSites || []
+      };
     }
+  }]);
+  return RectangleRoi;
+}();
+RectangleRoi.toolType = "RectangleRoi";
+RectangleRoi.utilityToolType = "RectangleRoi";
+RectangleRoi.TID300Representation = TID300Polyline$2;
+RectangleRoi.isValidCornerstoneTrackingIdentifier = function (TrackingIdentifier) {
+  if (!TrackingIdentifier.includes(":")) {
+    return false;
   }
-  var multiframe = Normalizer$2.normalizeToDataset(datasets);
-  return new SegmentationDerivation$1([multiframe], options);
-}
+  var _TrackingIdentifier$s = TrackingIdentifier.split(":"),
+    _TrackingIdentifier$s2 = _slicedToArray(_TrackingIdentifier$s, 2),
+    cornerstone4Tag = _TrackingIdentifier$s2[0],
+    toolType = _TrackingIdentifier$s2[1];
+  if (cornerstone4Tag !== CORNERSTONE_4_TAG) {
+    return false;
+  }
+  return toolType === RectangleRoi.toolType;
+};
+MeasurementReport$1.registerTool(RectangleRoi);
+
+var _utilities$orientatio$1 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.orientation,
+  rotateDirectionCosinesInPlane$1 = _utilities$orientatio$1.rotateDirectionCosinesInPlane,
+  flipIOP$1 = _utilities$orientatio$1.flipImageOrientationPatient,
+  flipMatrix2D$1 = _utilities$orientatio$1.flipMatrix2D,
+  rotateMatrix902D$1 = _utilities$orientatio$1.rotateMatrix902D;
+var datasetToBlob = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.datasetToBlob,
+  BitArray$2 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.BitArray,
+  DicomMessage$1 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.DicomMessage,
+  DicomMetaDictionary$2 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.DicomMetaDictionary;
+var Normalizer$3 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .normalizers */ .oq.Normalizer;
+var SegmentationDerivation$2 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .derivations */ .U7.Segmentation;
+var Segmentation$5 = {
+  generateSegmentation: generateSegmentation$3,
+  generateToolState: generateToolState$3
+};
 
 /**
- * generateToolState - Given a set of cornrstoneTools imageIds and a Segmentation buffer,
- * derive cornerstoneTools toolState and brush metadata.
  *
- * @param  {string[]} imageIds    An array of the imageIds.
+ * @typedef {Object} BrushData
+ * @property {Object} toolState - The cornerstoneTools global toolState.
+ * @property {Object[]} segments - The cornerstoneTools segment metadata that corresponds to the
+ *                                 seriesInstanceUid.
+ */
+
+/**
+ * generateSegmentation - Generates cornerstoneTools brush data, given a stack of
+ * imageIds, images and the cornerstoneTools brushData.
+ *
+ * @param  {object[]} images    An array of the cornerstone image objects.
+ * @param  {BrushData} brushData and object containing the brushData.
+ * @returns {type}           description
+ */
+function generateSegmentation$3(images, brushData) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+    includeSliceSpacing: true
+  };
+  var toolState = brushData.toolState,
+    segments = brushData.segments;
+
+  // Calculate the dimensions of the data cube.
+  var image0 = images[0];
+  var dims = {
+    x: image0.columns,
+    y: image0.rows,
+    z: images.length
+  };
+  dims.xy = dims.x * dims.y;
+  var numSegments = _getSegCount(seg, segments);
+  if (!numSegments) {
+    throw new Error("No segments to export!");
+  }
+  var isMultiframe = image0.imageId.includes("?frame");
+  var seg = _createSegFromImages$1(images, isMultiframe, options);
+  var _getNumberOfFramesPer = _getNumberOfFramesPerSegment(toolState, images, segments),
+    referencedFramesPerSegment = _getNumberOfFramesPer.referencedFramesPerSegment,
+    segmentIndicies = _getNumberOfFramesPer.segmentIndicies;
+  var NumberOfFrames = 0;
+  for (var i = 0; i < referencedFramesPerSegment.length; i++) {
+    NumberOfFrames += referencedFramesPerSegment[i].length;
+  }
+  seg.setNumberOfFrames(NumberOfFrames);
+  for (var _i = 0; _i < segmentIndicies.length; _i++) {
+    var segmentIndex = segmentIndicies[_i];
+    var referencedFrameIndicies = referencedFramesPerSegment[_i];
+
+    // Frame numbers start from 1.
+    var referencedFrameNumbers = referencedFrameIndicies.map(function (element) {
+      return element + 1;
+    });
+    var segment = segments[segmentIndex];
+    seg.addSegment(segment, _extractCornerstoneToolsPixelData(segmentIndex, referencedFrameIndicies, toolState, images, dims), referencedFrameNumbers);
+  }
+  seg.bitPackPixelData();
+  var segBlob = datasetToBlob(seg.dataset);
+  return segBlob;
+}
+function _extractCornerstoneToolsPixelData(segmentIndex, referencedFrames, toolState, images, dims) {
+  var pixelData = new Uint8Array(dims.xy * referencedFrames.length);
+  var pixelDataIndex = 0;
+  for (var i = 0; i < referencedFrames.length; i++) {
+    var frame = referencedFrames[i];
+    var imageId = images[frame].imageId;
+    var imageIdSpecificToolState = toolState[imageId];
+    var brushPixelData = imageIdSpecificToolState.brush.data[segmentIndex].pixelData;
+    for (var p = 0; p < brushPixelData.length; p++) {
+      pixelData[pixelDataIndex] = brushPixelData[p];
+      pixelDataIndex++;
+    }
+  }
+  return pixelData;
+}
+function _getNumberOfFramesPerSegment(toolState, images, segments) {
+  var segmentIndicies = [];
+  var referencedFramesPerSegment = [];
+  for (var i = 0; i < segments.length; i++) {
+    if (segments[i]) {
+      segmentIndicies.push(i);
+      referencedFramesPerSegment.push([]);
+    }
+  }
+  for (var z = 0; z < images.length; z++) {
+    var imageId = images[z].imageId;
+    var imageIdSpecificToolState = toolState[imageId];
+    for (var _i2 = 0; _i2 < segmentIndicies.length; _i2++) {
+      var segIdx = segmentIndicies[_i2];
+      if (imageIdSpecificToolState && imageIdSpecificToolState.brush && imageIdSpecificToolState.brush.data && imageIdSpecificToolState.brush.data[segIdx] && imageIdSpecificToolState.brush.data[segIdx].pixelData) {
+        referencedFramesPerSegment[_i2].push(z);
+      }
+    }
+  }
+  return {
+    referencedFramesPerSegment: referencedFramesPerSegment,
+    segmentIndicies: segmentIndicies
+  };
+}
+function _getSegCount(seg, segments) {
+  var numSegments = 0;
+  for (var i = 0; i < segments.length; i++) {
+    if (segments[i]) {
+      numSegments++;
+    }
+  }
+  return numSegments;
+}
+
+/**
+ * _createSegFromImages - description
+ *
+ * @param  {Object[]} images    An array of the cornerstone image objects.
+ * @param  {Boolean} isMultiframe Whether the images are multiframe.
+ * @returns {Object}              The Seg derived dataSet.
+ */
+function _createSegFromImages$1(images, isMultiframe, options) {
+  var datasets = [];
+  if (isMultiframe) {
+    var image = images[0];
+    var arrayBuffer = image.data.byteArray.buffer;
+    var dicomData = DicomMessage$1.readFile(arrayBuffer);
+    var dataset = DicomMetaDictionary$2.naturalizeDataset(dicomData.dict);
+    dataset._meta = DicomMetaDictionary$2.namifyDataset(dicomData.meta);
+    datasets.push(dataset);
+  } else {
+    for (var i = 0; i < images.length; i++) {
+      var _image = images[i];
+      var _arrayBuffer = _image.data.byteArray.buffer;
+      var _dicomData = DicomMessage$1.readFile(_arrayBuffer);
+      var _dataset = DicomMetaDictionary$2.naturalizeDataset(_dicomData.dict);
+      _dataset._meta = DicomMetaDictionary$2.namifyDataset(_dicomData.meta);
+      datasets.push(_dataset);
+    }
+  }
+  var multiframe = Normalizer$3.normalizeToDataset(datasets);
+  return new SegmentationDerivation$2([multiframe], options);
+}
+
+/**
+ * generateToolState - Given a set of cornrstoneTools imageIds and a Segmentation buffer,
+ * derive cornerstoneTools toolState and brush metadata.
+ *
+ * @param  {string[]} imageIds    An array of the imageIds.
  * @param  {ArrayBuffer} arrayBuffer The SEG arrayBuffer.
  * @param {*} metadataProvider
  * @returns {Object}  The toolState and an object from which the
  *                    segment metadata can be derived.
  */
-function generateToolState$2(imageIds, arrayBuffer, metadataProvider) {
+function generateToolState$3(imageIds, arrayBuffer, metadataProvider) {
   var dicomData = DicomMessage$1.readFile(arrayBuffer);
   var dataset = DicomMetaDictionary$2.naturalizeDataset(dicomData.dict);
   dataset._meta = DicomMetaDictionary$2.namifyDataset(dicomData.meta);
-  var multiframe = Normalizer$2.normalizeToDataset([dataset]);
+  var multiframe = Normalizer$3.normalizeToDataset([dataset]);
   var imagePlaneModule = metadataProvider.get("imagePlaneModule", imageIds[0]);
   if (!imagePlaneModule) {
     console.warn("Insufficient metadata, imagePlaneModule missing.");
@@ -1465,7 +2097,7 @@ function addImageIdSpecificBrushToolState(toolState, imageId, segmentIndex, pixe
 function getImageIdOfSourceImage(SourceImageSequence, imageIds, metadataProvider) {
   var ReferencedSOPInstanceUID = SourceImageSequence.ReferencedSOPInstanceUID,
     ReferencedFrameNumber = SourceImageSequence.ReferencedFrameNumber;
-  return ReferencedFrameNumber ? getImageIdOfReferencedFrame$1(ReferencedSOPInstanceUID, ReferencedFrameNumber, imageIds, metadataProvider) : getImageIdOfReferencedSingleFramedSOPInstance$1(ReferencedSOPInstanceUID, imageIds, metadataProvider);
+  return ReferencedFrameNumber ? getImageIdOfReferencedFrame$1(ReferencedSOPInstanceUID, ReferencedFrameNumber, imageIds, metadataProvider) : getImageIdOfReferencedSingleFramedSOPInstance(ReferencedSOPInstanceUID, imageIds, metadataProvider);
 }
 
 /**
@@ -1478,7 +2110,7 @@ function getImageIdOfSourceImage(SourceImageSequence, imageIds, metadataProvider
  *                                 from the cornerstone imageIds.
  * @return {String}                  The imageId that corresponds to the sopInstanceUid.
  */
-function getImageIdOfReferencedSingleFramedSOPInstance$1(sopInstanceUid, imageIds, metadataProvider) {
+function getImageIdOfReferencedSingleFramedSOPInstance(sopInstanceUid, imageIds, metadataProvider) {
   return imageIds.find(function (imageId) {
     var sopCommonModule = metadataProvider.get("sopCommonModule", imageId);
     if (!sopCommonModule) {
@@ -1604,26 +2236,38 @@ function getSegmentMetadata$1(multiframe) {
   };
 }
 
+/**
+ * Cornerstone adapters events
+ */
+var Events;
+(function (Events) {
+    /**
+     * Cornerstone segmentation load progress event
+     */
+    Events["SEGMENTATION_LOAD_PROGRESS"] = "CORNERSTONE_ADAPTER_SEGMENTATION_LOAD_PROGRESS";
+})(Events || (Events = {}));
+var Events$1 = Events;
+
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Events: Events$1
+});
+
 var _utilities$orientatio = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.orientation,
   rotateDirectionCosinesInPlane = _utilities$orientatio.rotateDirectionCosinesInPlane,
   flipIOP = _utilities$orientatio.flipImageOrientationPatient,
   flipMatrix2D = _utilities$orientatio.flipMatrix2D,
   rotateMatrix902D = _utilities$orientatio.rotateMatrix902D,
   nearlyEqual = _utilities$orientatio.nearlyEqual;
-var datasetToBlob = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.datasetToBlob,
-  BitArray$1 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.BitArray,
-  DicomMessage = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.DicomMessage,
-  DicomMetaDictionary$1 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.DicomMetaDictionary;
-var Normalizer$1 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .normalizers */ .oq.Normalizer;
-var SegmentationDerivation = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .derivations */ .U7.Segmentation;
+var datasetToDict = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .data */ .aT.datasetToDict,
+  BitArray$1 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .data */ .aT.BitArray,
+  DicomMessage = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .data */ .aT.DicomMessage,
+  DicomMetaDictionary$1 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .data */ .aT.DicomMetaDictionary;
+var Normalizer$2 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .normalizers */ .oq.Normalizer;
+var SegmentationDerivation$1 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .derivations */ .U7.Segmentation;
 var _utilities$compressio = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.compression,
   encode = _utilities$compressio.encode,
   decode = _utilities$compressio.decode;
-var Segmentation$2 = {
-  generateSegmentation: generateSegmentation$1,
-  generateToolState: generateToolState$1,
-  fillSegmentation: fillSegmentation$1
-};
 
 /**
  *
@@ -1632,10 +2276,9 @@ var Segmentation$2 = {
  * @property {Object[]} segments - The cornerstoneTools segment metadata that corresponds to the
  *                                 seriesInstanceUid.
  */
-
 var generateSegmentationDefaultOptions = {
   includeSliceSpacing: true,
-  rleEncode: true
+  rleEncode: false
 };
 
 /**
@@ -1648,7 +2291,7 @@ var generateSegmentationDefaultOptions = {
  * @param  {Object} userOptions Options to pass to the segmentation derivation and `fillSegmentation`.
  * @returns {Blob}
  */
-function generateSegmentation$1(images, inputLabelmaps3D) {
+function generateSegmentation$2(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);
@@ -1714,7 +2357,7 @@ function fillSegmentation$1(segmentation, inputLabelmaps3D) {
           return element + 1;
         });
         var segmentMetadata = metadata[segmentIndex];
-        var labelmaps = _getLabelmapsFromRefernecedFrameIndicies(labelmap3D, referencedFrameIndicies);
+        var labelmaps = _getLabelmapsFromReferencedFrameIndicies(labelmap3D, referencedFrameIndicies);
         segmentation.addSegmentFromLabelmap(segmentMetadata, labelmaps, segmentIndex, referencedFrameNumbers);
       }
     }
@@ -1743,10 +2386,13 @@ function fillSegmentation$1(segmentation, inputLabelmaps3D) {
     // If no rleEncoding, at least bitpack the data.
     segmentation.bitPackPixelData();
   }
-  var segBlob = datasetToBlob(segmentation.dataset);
+  var buffer = buffer__WEBPACK_IMPORTED_MODULE_3__/* .Buffer */ .lW.from(datasetToDict(segmentation.dataset).write());
+  var segBlob = new Blob([buffer], {
+    type: "application/dicom"
+  });
   return segBlob;
 }
-function _getLabelmapsFromRefernecedFrameIndicies(labelmap3D, referencedFrameIndicies) {
+function _getLabelmapsFromReferencedFrameIndicies(labelmap3D, referencedFrameIndicies) {
   var labelmaps2D = labelmap3D.labelmaps2D;
   var labelmaps = [];
   for (var i = 0; i < referencedFrameIndicies.length; i++) {
@@ -1782,8 +2428,8 @@ function _createSegFromImages(images, isMultiframe, options) {
       datasets.push(_dataset);
     }
   }
-  var multiframe = Normalizer$1.normalizeToDataset(datasets);
-  return new SegmentationDerivation([multiframe], options);
+  var multiframe = Normalizer$2.normalizeToDataset(datasets);
+  return new SegmentationDerivation$1([multiframe], options);
 }
 
 /**
@@ -1793,8 +2439,7 @@ function _createSegFromImages(images, isMultiframe, options) {
  * @param  {string[]} imageIds - An array of the imageIds.
  * @param  {ArrayBuffer} arrayBuffer - The SEG arrayBuffer.
  * @param  {*} metadataProvider.
- * @param  {bool} skipOverlapping - skip checks for overlapping segs, default value false.
- * @param  {number} tolerance - default value 1.e-3.
+ * @param  {obj} options - Options object.
  *
  * @return {[]ArrayBuffer}a list of array buffer for each labelMap
  * @return {Object} an object from which the segment metadata can be derived
@@ -1802,83 +2447,9 @@ 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$1(imageIds, arrayBuffer, metadataProvider) {
-  var skipOverlapping = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-  var tolerance = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1e-3;
-  var dicomData = DicomMessage.readFile(arrayBuffer);
-  var dataset = DicomMetaDictionary$1.naturalizeDataset(dicomData.dict);
-  dataset._meta = DicomMetaDictionary$1.namifyDataset(dicomData.meta);
-  var multiframe = Normalizer$1.normalizeToDataset([dataset]);
-  var imagePlaneModule = metadataProvider.get("imagePlaneModule", imageIds[0]);
-  var generalSeriesModule = metadataProvider.get("generalSeriesModule", imageIds[0]);
-  var SeriesInstanceUID = generalSeriesModule.seriesInstanceUID;
-  if (!imagePlaneModule) {
-    console.warn("Insufficient metadata, imagePlaneModule missing.");
-  }
-  var 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:
-  var validOrientations = getValidOrientations(ImageOrientationPatient);
-  var sliceLength = multiframe.Columns * multiframe.Rows;
-  var segMetadata = getSegmentMetadata(multiframe, SeriesInstanceUID);
-  var TransferSyntaxUID = multiframe._meta.TransferSyntaxUID.Value[0];
-  var pixelData;
-  if (TransferSyntaxUID === "1.2.840.10008.1.2.5") {
-    var 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;
-    }
-  } else {
-    pixelData = unpackPixelData(multiframe);
-    if (!pixelData) {
-      throw new Error("Fractional segmentations are not yet supported");
-    }
-  }
-  var orientation = checkOrientation(multiframe, validOrientations, [imagePlaneModule.rows, imagePlaneModule.columns, imageIds.length], tolerance);
-  var overlapping = false;
-  if (!skipOverlapping) {
-    overlapping = checkSEGsOverlapping(pixelData, multiframe, imageIds, validOrientations, metadataProvider, tolerance);
-  }
-  var 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*/
-
-  var segmentsOnFrameArray = [];
-  segmentsOnFrameArray[0] = [];
-  var segmentsOnFrame = [];
-  var arrayBufferLength = sliceLength * imageIds.length * 2; // 2 bytes per label voxel in cst4.
-  var labelmapBufferArray = [];
-  labelmapBufferArray[0] = new ArrayBuffer(arrayBufferLength);
-  insertFunction(segmentsOnFrame, segmentsOnFrameArray, labelmapBufferArray, pixelData, multiframe, imageIds, validOrientations, metadataProvider, tolerance);
-  return {
-    labelmapBufferArray: labelmapBufferArray,
-    segMetadata: segMetadata,
-    segmentsOnFrame: segmentsOnFrame,
-    segmentsOnFrameArray: segmentsOnFrameArray
-  };
-}
-
-// function insertPixelDataPerpendicular(
+function generateToolState$2(_x, _x2, _x3, _x4) {
+  return _generateToolState.apply(this, arguments);
+} // function insertPixelDataPerpendicular(
 //     segmentsOnFrame,
 //     labelmapBuffer,
 //     pixelData,
@@ -1893,30 +2464,23 @@ function generateToolState$1(imageIds, arrayBuffer, metadataProvider) {
 //         Rows,
 //         Columns
 //     } = multiframe;
-
 //     const firstImagePlaneModule = metadataProvider.get(
 //         "imagePlaneModule",
 //         imageIds[0]
 //     );
-
 //     const lastImagePlaneModule = metadataProvider.get(
 //         "imagePlaneModule",
 //         imageIds[imageIds.length - 1]
 //     );
-
 //     console.log(firstImagePlaneModule);
 //     console.log(lastImagePlaneModule);
-
 //     const corners = [
 //         ...getCorners(firstImagePlaneModule),
 //         ...getCorners(lastImagePlaneModule)
 //     ];
-
 //     console.log(`corners:`);
 //     console.log(corners);
-
 //     const indexToWorld = mat4.create();
-
 //     const ippFirstFrame = firstImagePlaneModule.imagePositionPatient;
 //     const rowCosines = Array.isArray(firstImagePlaneModule.rowCosines)
 //         ? [...firstImagePlaneModule.rowCosines]
@@ -1925,7 +2489,6 @@ function generateToolState$1(imageIds, arrayBuffer, metadataProvider) {
 //               firstImagePlaneModule.rowCosines.y,
 //               firstImagePlaneModule.rowCosines.z
 //           ];
-
 //     const columnCosines = Array.isArray(firstImagePlaneModule.columnCosines)
 //         ? [...firstImagePlaneModule.columnCosines]
 //         : [
@@ -1933,9 +2496,7 @@ function generateToolState$1(imageIds, arrayBuffer, metadataProvider) {
 //               firstImagePlaneModule.columnCosines.y,
 //               firstImagePlaneModule.columnCosines.z
 //           ];
-
 //     const { pixelSpacing } = firstImagePlaneModule;
-
 //     mat4.set(
 //         indexToWorld,
 //         // Column 1
@@ -1959,50 +2520,36 @@ function generateToolState$1(imageIds, arrayBuffer, metadataProvider) {
 //         0,
 //         1
 //     );
-
 //     // TODO -> Get origin and (x,y,z) increments to build a translation matrix:
 //     // TODO -> Equation C.7.6.2.1-1
-
 //     // | cx*di rx* Xx 0 |  |x|
 //     // | cy*di ry Xy 0 |  |y|
 //     // | cz*di rz Xz 0 |  |z|
 //     // | tx ty tz 1 |  |1|
-
 //     // const [
 //     //     0, 0 , 0 , 0,
 //     //     0, 0 , 0 , 0,
 //     //     0, 0 , 0 , 0,
 //     //     ipp[0], ipp[1] , ipp[2] , 1,
 //     // ]
-
 //     // Each frame:
-
 //     // Find which corner the first voxel lines up with (one of 8 corners.)
-
 //     // Find how i,j,k orient with respect to source volume.
 //     // Go through each frame, find location in source to start, and whether to increment +/ix,+/-y,+/-z
 //     //   through each voxel.
-
 //     // [1,0,0,0,1,0]
-
 //     // const [
-
 //     // ]
-
 //     // Invert transformation matrix to get worldToIndex
-
 //     // Apply world to index on each point to fill up the matrix.
-
 //     // const sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence
 //     //     ? SharedFunctionalGroupsSequence.PlaneOrientationSequence
 //     //           .ImageOrientationPatient
 //     //     : undefined;
 //     // const sliceLength = Columns * Rows;
 // }
-
 // function getCorners(imagePlaneModule) {
 //     // console.log(imagePlaneModule);
-
 //     const {
 //         rows,
 //         columns,
@@ -2012,22 +2559,18 @@ function generateToolState$1(imageIds, arrayBuffer, metadataProvider) {
 //         rowPixelSpacing,
 //         columnPixelSpacing
 //     } = imagePlaneModule;
-
 //     const rowLength = columns * columnPixelSpacing;
 //     const columnLength = rows * rowPixelSpacing;
-
 //     const entireRowVector = [
 //         rowLength * columnCosines[0],
 //         rowLength * columnCosines[1],
 //         rowLength * columnCosines[2]
 //     ];
-
 //     const entireColumnVector = [
 //         columnLength * rowCosines[0],
 //         columnLength * rowCosines[1],
 //         columnLength * rowCosines[2]
 //     ];
-
 //     const topLeft = [ipp[0], ipp[1], ipp[2]];
 //     const topRight = [
 //         topLeft[0] + entireRowVector[0],
@@ -2039,29 +2582,160 @@ function generateToolState$1(imageIds, arrayBuffer, metadataProvider) {
 //         topLeft[1] + entireColumnVector[1],
 //         topLeft[2] + entireColumnVector[2]
 //     ];
-
 //     const bottomRight = [
 //         bottomLeft[0] + entireRowVector[0],
 //         bottomLeft[1] + entireRowVector[1],
 //         bottomLeft[2] + entireRowVector[2]
 //     ];
-
 //     return [topLeft, topRight, bottomLeft, bottomRight];
 // }
-
 /**
  * Find the reference frame of the segmentation frame in the source data.
  *
  * @param  {Object}      multiframe        dicom metadata
  * @param  {Int}         frameSegment      frame dicom index
  * @param  {String[]}    imageIds          A list of imageIds.
- * @param  {Object}      metadataProvider  A Cornerstone metadataProvider to query
- *                                         metadata from imageIds.
+ * @param  {Object}      sopUIDImageIdIndexMap  A map of SOPInstanceUID to imageId
  * @param  {Float}       tolerance         The tolerance parameter
  *
  * @returns {String}     Returns the imageId
  */
-function findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadataProvider, tolerance) {
+function _generateToolState() {
+  _generateToolState = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(imageIds, arrayBuffer, metadataProvider, options) {
+    var _options$skipOverlapp, skipOverlapping, _options$tolerance, tolerance, _options$TypedArrayCo, TypedArrayConstructor, _options$maxBytesPerC, maxBytesPerChunk, eventTarget, 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, 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, eventTarget = options.eventTarget, triggerEvent = options.triggerEvent;
+          dicomData = DicomMessage.readFile(arrayBuffer);
+          dataset = DicomMetaDictionary$1.naturalizeDataset(dicomData.dict);
+          dataset._meta = DicomMetaDictionary$1.namifyDataset(dicomData.meta);
+          multiframe = Normalizer$2.normalizeToDataset([dataset]);
+          imagePlaneModule = metadataProvider.get("imagePlaneModule", imageIds[0]);
+          generalSeriesModule = metadataProvider.get("generalSeriesModule", imageIds[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, imageIds.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 = imageIds.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, imageIds, 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 * imageIds.length * TypedArrayConstructor.BYTES_PER_ELEMENT;
+          labelmapBufferArray = [];
+          labelmapBufferArray[0] = new ArrayBuffer(arrayBufferLength);
+
+          // Precompute the indices and metadata so that we don't have to call
+          // a function for each imageId in the for loop.
+          imageIdMaps = imageIds.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, imageIds, validOrientations, metadataProvider, tolerance, TypedArrayConstructor, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps, eventTarget, triggerEvent);
+        case 47:
+          // calculate the centroid of each segment
+          centroidXYZ = new Map();
+          segmentsPixelIndices.forEach(function (imageIdIndexBufferIndex, segmentIndex) {
+            var _calculateCentroid = calculateCentroid(imageIdIndexBufferIndex, multiframe),
+              xAcc = _calculateCentroid.xAcc,
+              yAcc = _calculateCentroid.yAcc,
+              zAcc = _calculateCentroid.zAcc,
+              count = _calculateCentroid.count;
+            centroidXYZ.set(segmentIndex, {
+              x: Math.floor(xAcc / count),
+              y: Math.floor(yAcc / count),
+              z: Math.floor(zAcc / count)
+            });
+          });
+          return _context.abrupt("return", {
+            labelmapBufferArray: labelmapBufferArray,
+            segMetadata: segMetadata,
+            segmentsOnFrame: segmentsOnFrame,
+            segmentsOnFrameArray: segmentsOnFrameArray,
+            centroids: centroidXYZ
+          });
+        case 50:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _generateToolState.apply(this, arguments);
+}
+function findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap) {
   var imageId = undefined;
   if (!multiframe) {
     return imageId;
@@ -2101,7 +2775,7 @@ function findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadata
     }
   }
   if (frameSourceImageSequence) {
-    imageId = getImageIdOfSourceImagebySourceImageSequence(frameSourceImageSequence, imageIds, metadataProvider);
+    imageId = getImageIdOfSourceImageBySourceImageSequence(frameSourceImageSequence, sopUIDImageIdIndexMap);
   }
   if (imageId === undefined && ReferencedSeriesSequence) {
     var referencedSeriesSequence = Array.isArray(ReferencedSeriesSequence) ? ReferencedSeriesSequence[0] : ReferencedSeriesSequence;
@@ -2116,7 +2790,7 @@ function findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadata
  *  @returns {boolean} Returns a flag if segmentations overlapping
  */
 
-function checkSEGsOverlapping(pixelData, multiframe, imageIds, validOrientations, metadataProvider, tolerance) {
+function checkSEGsOverlapping(pixelData, multiframe, imageIds, validOrientations, metadataProvider, tolerance, TypedArrayConstructor, sopUIDImageIdIndexMap) {
   var SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence,
     PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
     SegmentSequence = multiframe.SegmentSequence,
@@ -2143,7 +2817,7 @@ function checkSEGsOverlapping(pixelData, multiframe, imageIds, validOrientations
       console.warn("Could not retrieve the segment index for frame segment " + frameSegment + ", skipping this frame.");
       return "continue";
     }
-    var imageId = findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadataProvider, tolerance);
+    var imageId = findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
     if (!imageId) {
       console.warn("Image not present in stack, can't import frame : " + frameSegment + ".");
       return "continue";
@@ -2171,12 +2845,13 @@ function checkSEGsOverlapping(pixelData, multiframe, imageIds, validOrientations
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
       var _step$value = _slicedToArray(_step.value, 2),
         role = _step$value[1];
-      var temp2DArray = new Uint16Array(sliceLength).fill(0);
+      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 pixelDataI2D = ndarray__WEBPACK_IMPORTED_MODULE_1___default()(new Uint8Array(pixelData.buffer, _frameSegment * sliceLength, sliceLength), [Rows, Columns]);
+        var view = readFromUnpackedChunks(pixelData, _frameSegment * sliceLength, sliceLength);
+        var pixelDataI2D = ndarray__WEBPACK_IMPORTED_MODULE_1___default()(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.");
@@ -2200,15 +2875,14 @@ function checkSEGsOverlapping(pixelData, multiframe, imageIds, validOrientations
   }
   return false;
 }
-function insertOverlappingPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray, labelmapBufferArray, pixelData, multiframe, imageIds, validOrientations, metadataProvider, tolerance) {
+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 * 2; // 2 bytes per label voxel in cst4.
-
+  var arrayBufferLength = sliceLength * imageIds.length * TypedArrayConstructor.BYTES_PER_ELEMENT;
   // indicate the number of labelMaps
   var M = 1;
 
@@ -2241,12 +2915,17 @@ function insertOverlappingPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray,
         return "continue";
       }
       var ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
-      var pixelDataI2D = ndarray__WEBPACK_IMPORTED_MODULE_1___default()(new Uint8Array(pixelData.buffer, _i2 * sliceLength, sliceLength), [Rows, Columns]);
+
+      // 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__WEBPACK_IMPORTED_MODULE_1___default()(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);
+      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;
@@ -2259,9 +2938,8 @@ function insertOverlappingPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray,
       var imageIdIndex = imageIds.findIndex(function (element) {
         return element === imageId;
       });
-      var byteOffset = sliceLength * 2 * imageIdIndex; // 2 bytes/pixel
-
-      var labelmap2DView = new Uint16Array(tempBuffer, byteOffset, sliceLength);
+      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) {
@@ -2314,60 +2992,93 @@ var getSegmentIndex = function getSegmentIndex(multiframe, frame) {
   var 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) {
+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 _loop5 = function _loop5() {
-    var PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[i];
-    var ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
-    var pixelDataI2D = ndarray__WEBPACK_IMPORTED_MODULE_1___default()(new Uint8Array(pixelData.buffer, i * sliceLength, sliceLength), [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 segmentIndex = getSegmentIndex(multiframe, i);
-    if (segmentIndex === undefined) {
-      throw new Error("Could not retrieve the segment index. Aborting segmentation loading.");
-    }
-    var imageId = findReferenceSourceImageId(multiframe, i, imageIds, metadataProvider, tolerance);
-    if (!imageId) {
-      console.warn("Image not present in stack, can't import frame : " + i + ".");
-      return "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 * 2 * imageIdIndex; // 2 bytes/pixel
-
-    var labelmap2DView = new Uint16Array(labelmapBufferArray[0], byteOffset, sliceLength);
-    var data = alignedPixelDataI.data;
-    for (var j = 0, len = alignedPixelDataI.data.length; j < len; ++j) {
-      if (data[j]) {
-        for (var x = j; x < len; ++x) {
-          if (data[x]) {
-            labelmap2DView[x] = segmentIndex;
-          }
+  var i = 0;
+  var groupsLen = PerFrameFunctionalGroupsSequence.length;
+  var chunkSize = Math.ceil(groupsLen / 10); // 10% of total length
+
+  var shouldTriggerEvent = triggerEvent && eventTarget;
+
+  // 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) {
+    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__WEBPACK_IMPORTED_MODULE_1___default()(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.");
         }
-        if (!segmentsOnFrame[imageIdIndex]) {
-          segmentsOnFrame[imageIdIndex] = [];
+        var segmentIndex = getSegmentIndex(multiframe, i);
+        if (segmentIndex === undefined) {
+          throw new Error("Could not retrieve the segment index. Aborting segmentation loading.");
         }
-        segmentsOnFrame[imageIdIndex].push(segmentIndex);
-        break;
-      }
-    }
-  };
-  for (var i = 0, groupsLen = PerFrameFunctionalGroupsSequence.length; i < groupsLen; ++i) {
-    var _ret3 = _loop5();
-    if (_ret3 === "continue") continue;
-  }
+        if (!segmentsPixelIndices.has(segmentIndex)) {
+          segmentsPixelIndices.set(segmentIndex, {});
+        }
+        var 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];
+        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) {
+          if (data[j]) {
+            for (var x = j; x < len; ++x) {
+              if (data[x]) {
+                labelmap2DView[x] = segmentIndex;
+                indexCache.push(x);
+              }
+            }
+            if (!segmentsOnFrame[imageIdIndex]) {
+              segmentsOnFrame[imageIdIndex] = [];
+            }
+            segmentsOnFrame[imageIdIndex].push(segmentIndex);
+            break;
+          }
+        }
+        var 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);
+        triggerEvent(eventTarget, Events$1.SEGMENTATION_LOAD_PROGRESS, {
+          percentComplete: percentComplete
+        });
+      }
+
+      // schedule next chunk
+      if (i < groupsLen) {
+        setTimeout(processInChunks, 0);
+      } else {
+        // resolve the Promise when all chunks have been processed
+        resolve();
+      }
+    }
+    processInChunks();
+  });
 }
 function checkOrientation(multiframe, validOrientations, sourceDataDimensions, tolerance) {
   var SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence,
@@ -2406,12 +3117,13 @@ function checkIfPerpendicular(iop1, iop2, tolerance) {
 }
 
 /**
- * unpackPixelData - Unpacks bitpacked pixelData if the Segmentation is BINARY.
+ * unpackPixelData - Unpacks bit packed pixelData if the Segmentation is BINARY.
  *
  * @param  {Object} multiframe The multiframe dataset.
+ * @param  {Object} options    Options for the unpacking.
  * @return {Uint8Array}      The unpacked pixelData.
  */
-function unpackPixelData(multiframe) {
+function unpackPixelData(multiframe, options) {
   var segType = multiframe.SegmentationType;
   var data;
   if (Array.isArray(multiframe.PixelData)) {
@@ -2423,7 +3135,10 @@ function unpackPixelData(multiframe) {
     dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .log */ .cM.error("This segmentation pixeldata is undefined.");
   }
   if (segType === "BINARY") {
-    return BitArray$1.unpack(data);
+    // For extreme big data, we can't unpack the data at once and we need to
+    // chunk it and unpack each chunk separately.
+    // 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;
@@ -2437,20 +3152,35 @@ function unpackPixelData(multiframe) {
   dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .log */ .cM.warn("This segmentation object is actually binary... processing as such.");
   return pixelData;
 }
+function getUnpackedChunks(data, maxBytesPerChunk) {
+  var bitArray = new Uint8Array(data);
+  var chunks = [];
+  var maxBitsPerChunk = maxBytesPerChunk * 8;
+  var numberOfChunks = Math.ceil(bitArray.length * 8 / maxBitsPerChunk);
+  for (var i = 0; i < numberOfChunks; i++) {
+    var startBit = i * maxBitsPerChunk;
+    var endBit = Math.min(startBit + maxBitsPerChunk, bitArray.length * 8);
+    var startByte = Math.floor(startBit / 8);
+    var endByte = Math.ceil(endBit / 8);
+    var chunk = bitArray.slice(startByte, endByte);
+    var unpackedChunk = BitArray$1.unpack(chunk);
+    chunks.push(unpackedChunk);
+  }
+  return chunks;
+}
 
 /**
- * getImageIdOfSourceImagebySourceImageSequence - Returns the Cornerstone imageId of the source image.
+ * getImageIdOfSourceImageBySourceImageSequence - Returns the Cornerstone imageId of the source image.
  *
  * @param  {Object}   SourceImageSequence  Sequence describing the source image.
  * @param  {String[]} imageIds             A list of imageIds.
- * @param  {Object}   metadataProvider     A Cornerstone metadataProvider to query
- *                                         metadata from imageIds.
+ * @param  {Object}   sopUIDImageIdIndexMap A map of SOPInstanceUIDs to imageIds.
  * @return {String}                        The corresponding imageId.
  */
-function getImageIdOfSourceImagebySourceImageSequence(SourceImageSequence, imageIds, metadataProvider) {
+function getImageIdOfSourceImageBySourceImageSequence(SourceImageSequence, sopUIDImageIdIndexMap) {
   var ReferencedSOPInstanceUID = SourceImageSequence.ReferencedSOPInstanceUID,
     ReferencedFrameNumber = SourceImageSequence.ReferencedFrameNumber;
-  return ReferencedFrameNumber ? getImageIdOfReferencedFrame(ReferencedSOPInstanceUID, ReferencedFrameNumber, imageIds, metadataProvider) : getImageIdOfReferencedSingleFramedSOPInstance(ReferencedSOPInstanceUID, imageIds, metadataProvider);
+  return ReferencedFrameNumber ? getImageIdOfReferencedFrame(ReferencedSOPInstanceUID, ReferencedFrameNumber, sopUIDImageIdIndexMap) : sopUIDImageIdIndexMap[ReferencedSOPInstanceUID];
 }
 
 /**
@@ -2460,7 +3190,7 @@ function getImageIdOfSourceImagebySourceImageSequence(SourceImageSequence, image
  * @param  {String}    FrameOfReferenceUID            Frame of reference.
  * @param  {Object}    PerFrameFunctionalGroup        Sequence describing segmentation reference attributes per frame.
  * @param  {String[]}  imageIds                       A list of imageIds.
- * @param  {Object}    metadataProvider               A Cornerstone metadataProvider to query
+ * @param  {Object}    sopUIDImageIdIndexMap          A map of SOPInstanceUIDs to imageIds.
  * @param  {Float}     tolerance                      The tolerance parameter
  *
  * @return {String}                                   The corresponding imageId.
@@ -2480,26 +3210,6 @@ function getImageIdOfSourceImagebyGeometry(ReferencedSeriesInstanceUID, FrameOfR
   }
 }
 
-/**
- * getImageIdOfReferencedSingleFramedSOPInstance - Returns the imageId
- * corresponding to the specified sopInstanceUid for single-frame images.
- *
- * @param  {String} sopInstanceUid   The sopInstanceUid of the desired image.
- * @param  {String[]} imageIds         The list of imageIds.
- * @param  {Object} metadataProvider The metadataProvider to obtain sopInstanceUids
- *                                 from the cornerstone imageIds.
- * @return {String}                  The imageId that corresponds to the sopInstanceUid.
- */
-function getImageIdOfReferencedSingleFramedSOPInstance(sopInstanceUid, imageIds, metadataProvider) {
-  return imageIds.find(function (imageId) {
-    var sopCommonModule = metadataProvider.get("sopCommonModule", imageId);
-    if (!sopCommonModule) {
-      return;
-    }
-    return sopCommonModule.sopInstanceUID === sopInstanceUid;
-  });
-}
-
 /**
  * getImageIdOfReferencedFrame - Returns the imageId corresponding to the
  * specified sopInstanceUid and frameNumber for multi-frame images.
@@ -2507,23 +3217,16 @@ function getImageIdOfReferencedSingleFramedSOPInstance(sopInstanceUid, imageIds,
  * @param  {String} sopInstanceUid   The sopInstanceUid of the desired image.
  * @param  {Number} frameNumber      The frame number.
  * @param  {String} imageIds         The list of imageIds.
- * @param  {Object} metadataProvider The metadataProvider to obtain sopInstanceUids
- *                                   from the cornerstone imageIds.
+ * @param  {Object} sopUIDImageIdIndexMap A map of SOPInstanceUIDs to imageIds.
  * @return {String}                  The imageId that corresponds to the sopInstanceUid.
  */
-function getImageIdOfReferencedFrame(sopInstanceUid, frameNumber, imageIds, metadataProvider) {
-  var imageId = imageIds.find(function (imageId) {
-    var sopCommonModule = metadataProvider.get("sopCommonModule", imageId);
-    if (!sopCommonModule) {
-      return;
-    }
-    var imageIdFrameNumber = Number(imageId.split("frame=")[1]);
-    return (
-      //frameNumber is zero indexed for cornerstoneDICOMImageLoader image Ids.
-      sopCommonModule.sopInstanceUID === sopInstanceUid && imageIdFrameNumber === frameNumber - 1
-    );
-  });
-  return imageId;
+function getImageIdOfReferencedFrame(sopInstanceUid, frameNumber, sopUIDImageIdIndexMap) {
+  var imageId = sopUIDImageIdIndexMap[sopInstanceUid];
+  if (!imageId) {
+    return;
+  }
+  var imageIdFrameNumber = Number(imageId.split("frame=")[1]);
+  return imageIdFrameNumber === frameNumber - 1 ? imageId : undefined;
 }
 
 /**
@@ -2604,397 +3307,228 @@ function alignPixelDataWithSourceData(pixelData2D, iop, orientations, tolerance)
  * compareArrays - Returns true if array1 and array2 are equal
  * within a tolerance.
  *
- * @param  {Number[]} array1 - An array.
- * @param  {Number[]} array2 - An array.
- * @param {Number} tolerance.
- * @return {Boolean} True if array1 and array2 are equal.
- */
-function compareArrays(array1, array2, tolerance) {
-  if (array1.length != array2.length) {
-    return false;
-  }
-  for (var i = 0; i < array1.length; ++i) {
-    if (!nearlyEqual(array1[i], array2[i], tolerance)) {
-      return false;
-    }
-  }
-  return true;
-}
-function getSegmentMetadata(multiframe, seriesInstanceUid) {
-  var segmentSequence = multiframe.SegmentSequence;
-  var data = [];
-  if (Array.isArray(segmentSequence)) {
-    data = [undefined].concat(_toConsumableArray(segmentSequence));
-  } else {
-    // Only one segment, will be stored as an object.
-    data = [undefined, segmentSequence];
-  }
-  return {
-    seriesInstanceUid: seriesInstanceUid,
-    data: data
-  };
-}
-
-var Segmentation$1 = {
-  generateSegmentation: generateSegmentation,
-  generateToolState: generateToolState,
-  fillSegmentation: fillSegmentation
-};
-
-/**
- * generateSegmentation - Generates a DICOM Segmentation object given cornerstoneTools data.
- *
- * @param  {object[]} images    An array of the cornerstone image objects.
- * @param  {Object|Object[]} labelmaps3DorBrushData For 4.X: The cornerstone `Labelmap3D` object, or an array of objects.
- *                                                  For 3.X: the BrushData.
- * @param  {number} cornerstoneToolsVersion The cornerstoneTools major version to map against.
- * @returns {Object}
- */
-function generateSegmentation(images, labelmaps3DorBrushData) {
-  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
-    includeSliceSpacing: true
-  };
-  var cornerstoneToolsVersion = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 4;
-  if (cornerstoneToolsVersion === 4) {
-    return Segmentation$2.generateSegmentation(images, labelmaps3DorBrushData, options);
-  }
-  if (cornerstoneToolsVersion === 3) {
-    return Segmentation$3.generateSegmentation(images, labelmaps3DorBrushData, options);
-  }
-  console.warn("No generateSegmentation adapater for cornerstone version ".concat(cornerstoneToolsVersion, ", exiting."));
-}
-
-/**
- * generateToolState - Given a set of cornrstoneTools imageIds and a Segmentation buffer,
- * derive cornerstoneTools toolState and brush metadata.
- *
- * @param  {string[]} imageIds    An array of the imageIds.
- * @param  {ArrayBuffer} arrayBuffer The SEG arrayBuffer.
- * @param {*} metadataProvider
- * @param  {bool} skipOverlapping - skip checks for overlapping segs, default value false.
- * @param  {number} tolerance - default value 1.e-3.
- * @param  {number} cornerstoneToolsVersion - default value 4.
- *
- * @returns {Object}  The toolState and an object from which the
- *                    segment metadata can be derived.
- */
-function generateToolState(imageIds, arrayBuffer, metadataProvider) {
-  var skipOverlapping = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-  var tolerance = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1e-3;
-  var cornerstoneToolsVersion = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 4;
-  if (cornerstoneToolsVersion === 4) {
-    return Segmentation$2.generateToolState(imageIds, arrayBuffer, metadataProvider, skipOverlapping, tolerance);
-  }
-  if (cornerstoneToolsVersion === 3) {
-    return Segmentation$3.generateToolState(imageIds, arrayBuffer, metadataProvider);
-  }
-  console.warn("No generateToolState adapater for cornerstone version ".concat(cornerstoneToolsVersion, ", exiting."));
-}
-
-/**
- * fillSegmentation - Fills a derived segmentation dataset with cornerstoneTools `LabelMap3D` data.
- *
- * @param  {object[]} segmentation An empty segmentation derived dataset.
- * @param  {Object|Object[]} inputLabelmaps3D The cornerstone `Labelmap3D` object, or an array of objects.
- * @param  {Object} userOptions Options object to override default options.
- * @returns {Blob}           description
- */
-function fillSegmentation(segmentation, inputLabelmaps3D) {
-  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
-    includeSliceSpacing: true
-  };
-  var cornerstoneToolsVersion = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 4;
-  if (cornerstoneToolsVersion === 4) {
-    return Segmentation$2.fillSegmentation(segmentation, inputLabelmaps3D, options);
-  }
-  console.warn("No generateSegmentation adapater for cornerstone version ".concat(cornerstoneToolsVersion, ", exiting."));
-}
-
-var TID300CobbAngle$2 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.TID300.CobbAngle;
-var COBB_ANGLE = "CobbAngle";
-var CobbAngle$1 = /*#__PURE__*/function () {
-  function CobbAngle() {
-    _classCallCheck(this, CobbAngle);
-  }
-  _createClass(CobbAngle, null, [{
-    key: "getMeasurementData",
-    value:
-    // TODO: this function is required for all Cornerstone Tool Adapters, since it is called by MeasurementReport.
-    function getMeasurementData(MeasurementGroup) {
-      var _MeasurementReport$ge = MeasurementReport$1.getSetupMeasurementData(MeasurementGroup),
-        defaultState = _MeasurementReport$ge.defaultState,
-        NUMGroup = _MeasurementReport$ge.NUMGroup,
-        SCOORDGroup = _MeasurementReport$ge.SCOORDGroup;
-      var state = _objectSpread2(_objectSpread2({}, defaultState), {}, {
-        rAngle: NUMGroup.MeasuredValueSequence.NumericValue,
-        toolType: CobbAngle.toolType,
-        handles: {
-          start: {},
-          end: {},
-          start2: {
-            highlight: true,
-            drawnIndependently: true
-          },
-          end2: {
-            highlight: true,
-            drawnIndependently: true
-          },
-          textBox: {
-            hasMoved: false,
-            movesIndependently: false,
-            drawnIndependently: true,
-            allowedOutsideImage: true,
-            hasBoundingBox: true
-          }
-        }
-      });
-      var _SCOORDGroup$GraphicD = _slicedToArray(SCOORDGroup.GraphicData, 8);
-      state.handles.start.x = _SCOORDGroup$GraphicD[0];
-      state.handles.start.y = _SCOORDGroup$GraphicD[1];
-      state.handles.end.x = _SCOORDGroup$GraphicD[2];
-      state.handles.end.y = _SCOORDGroup$GraphicD[3];
-      state.handles.start2.x = _SCOORDGroup$GraphicD[4];
-      state.handles.start2.y = _SCOORDGroup$GraphicD[5];
-      state.handles.end2.x = _SCOORDGroup$GraphicD[6];
-      state.handles.end2.y = _SCOORDGroup$GraphicD[7];
-      return state;
-    }
-  }, {
-    key: "getTID300RepresentationArguments",
-    value: function getTID300RepresentationArguments(tool) {
-      var handles = tool.handles,
-        finding = tool.finding,
-        findingSites = tool.findingSites;
-      var point1 = handles.start;
-      var point2 = handles.end;
-      var point3 = handles.start2;
-      var point4 = handles.end2;
-      var rAngle = tool.rAngle;
-      var trackingIdentifierTextValue = "cornerstoneTools@^4.0.0:CobbAngle";
-      return {
-        point1: point1,
-        point2: point2,
-        point3: point3,
-        point4: point4,
-        rAngle: rAngle,
-        trackingIdentifierTextValue: trackingIdentifierTextValue,
-        finding: finding,
-        findingSites: findingSites || []
-      };
-    }
-  }]);
-  return CobbAngle;
-}();
-CobbAngle$1.toolType = COBB_ANGLE;
-CobbAngle$1.utilityToolType = COBB_ANGLE;
-CobbAngle$1.TID300Representation = TID300CobbAngle$2;
-CobbAngle$1.isValidCornerstoneTrackingIdentifier = function (TrackingIdentifier) {
-  if (!TrackingIdentifier.includes(":")) {
-    return false;
-  }
-  var _TrackingIdentifier$s = TrackingIdentifier.split(":"),
-    _TrackingIdentifier$s2 = _slicedToArray(_TrackingIdentifier$s, 2),
-    cornerstone4Tag = _TrackingIdentifier$s2[0],
-    toolType = _TrackingIdentifier$s2[1];
-  if (cornerstone4Tag !== CORNERSTONE_4_TAG) {
-    return false;
-  }
-  return toolType === COBB_ANGLE;
-};
-MeasurementReport$1.registerTool(CobbAngle$1);
-
-var TID300Angle = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.TID300.Angle;
-var ANGLE = "Angle";
-var Angle$1 = /*#__PURE__*/function () {
-  function Angle() {
-    _classCallCheck(this, Angle);
-  }
-  _createClass(Angle, null, [{
-    key: "getMeasurementData",
-    value:
-    /**
-     * Generate TID300 measurement data for a plane angle measurement - use a Angle, but label it as Angle
-     */
-    function getMeasurementData(MeasurementGroup) {
-      var _MeasurementReport$ge = MeasurementReport$1.getSetupMeasurementData(MeasurementGroup),
-        defaultState = _MeasurementReport$ge.defaultState,
-        NUMGroup = _MeasurementReport$ge.NUMGroup,
-        SCOORDGroup = _MeasurementReport$ge.SCOORDGroup;
-      var state = _objectSpread2(_objectSpread2({}, defaultState), {}, {
-        rAngle: NUMGroup.MeasuredValueSequence.NumericValue,
-        toolType: Angle.toolType,
-        handles: {
-          start: {},
-          middle: {},
-          end: {},
-          textBox: {
-            hasMoved: false,
-            movesIndependently: false,
-            drawnIndependently: true,
-            allowedOutsideImage: true,
-            hasBoundingBox: true
-          }
-        }
-      });
-      var _SCOORDGroup$GraphicD = _slicedToArray(SCOORDGroup.GraphicData, 8);
-      state.handles.start.x = _SCOORDGroup$GraphicD[0];
-      state.handles.start.y = _SCOORDGroup$GraphicD[1];
-      state.handles.middle.x = _SCOORDGroup$GraphicD[2];
-      state.handles.middle.y = _SCOORDGroup$GraphicD[3];
-      state.handles.middle.x = _SCOORDGroup$GraphicD[4];
-      state.handles.middle.y = _SCOORDGroup$GraphicD[5];
-      state.handles.end.x = _SCOORDGroup$GraphicD[6];
-      state.handles.end.y = _SCOORDGroup$GraphicD[7];
-      return state;
-    }
-  }, {
-    key: "getTID300RepresentationArguments",
-    value: function getTID300RepresentationArguments(tool) {
-      var handles = tool.handles,
-        finding = tool.finding,
-        findingSites = tool.findingSites;
-      var point1 = handles.start;
-      var point2 = handles.middle;
-      var point3 = handles.middle;
-      var point4 = handles.end;
-      var rAngle = tool.rAngle;
-      var trackingIdentifierTextValue = "cornerstoneTools@^4.0.0:Angle";
-      return {
-        point1: point1,
-        point2: point2,
-        point3: point3,
-        point4: point4,
-        rAngle: rAngle,
-        trackingIdentifierTextValue: trackingIdentifierTextValue,
-        finding: finding,
-        findingSites: findingSites || []
-      };
-    }
-  }]);
-  return Angle;
-}();
-Angle$1.toolType = ANGLE;
-Angle$1.utilityToolType = ANGLE;
-Angle$1.TID300Representation = TID300Angle;
-Angle$1.isValidCornerstoneTrackingIdentifier = function (TrackingIdentifier) {
-  if (!TrackingIdentifier.includes(":")) {
+ * @param  {Number[]} array1 - An array.
+ * @param  {Number[]} array2 - An array.
+ * @param {Number} tolerance.
+ * @return {Boolean} True if array1 and array2 are equal.
+ */
+function compareArrays(array1, array2, tolerance) {
+  if (array1.length != array2.length) {
     return false;
   }
-  var _TrackingIdentifier$s = TrackingIdentifier.split(":"),
-    _TrackingIdentifier$s2 = _slicedToArray(_TrackingIdentifier$s, 2),
-    cornerstone4Tag = _TrackingIdentifier$s2[0],
-    toolType = _TrackingIdentifier$s2[1];
-  if (cornerstone4Tag !== CORNERSTONE_4_TAG) {
-    return false;
+  for (var i = 0; i < array1.length; ++i) {
+    if (!nearlyEqual(array1[i], array2[i], tolerance)) {
+      return false;
+    }
   }
-  return toolType === ANGLE;
-};
-MeasurementReport$1.registerTool(Angle$1);
+  return true;
+}
+function getSegmentMetadata(multiframe, seriesInstanceUid) {
+  var segmentSequence = multiframe.SegmentSequence;
+  var data = [];
+  if (Array.isArray(segmentSequence)) {
+    data = [undefined].concat(_toConsumableArray(segmentSequence));
+  } else {
+    // Only one segment, will be stored as an object.
+    data = [undefined, segmentSequence];
+  }
+  return {
+    seriesInstanceUid: seriesInstanceUid,
+    data: data
+  };
+}
 
-var TID300Polyline$2 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.TID300.Polyline;
-var RectangleRoi = /*#__PURE__*/function () {
-  function RectangleRoi() {
-    _classCallCheck(this, RectangleRoi);
+/**
+ * Reads a range of bytes from an array of ArrayBuffer chunks and
+ * aggregate them into a new Uint8Array.
+ *
+ * @param {ArrayBuffer[]} chunks - An array of ArrayBuffer chunks.
+ * @param {number} offset - The offset of the first byte to read.
+ * @param {number} length - The number of bytes to read.
+ * @returns {Uint8Array} A new Uint8Array containing the requested bytes.
+ */
+function readFromUnpackedChunks(chunks, offset, length) {
+  var 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;
+      result.set(new Uint8Array(chunks[i].buffer, start, end - start), resultOffset);
+      resultOffset += end - start;
+    }
+    return result;
   }
-  _createClass(RectangleRoi, null, [{
-    key: "getMeasurementData",
-    value: function getMeasurementData(MeasurementGroup) {
-      var _MeasurementReport$ge = MeasurementReport$1.getSetupMeasurementData(MeasurementGroup),
-        defaultState = _MeasurementReport$ge.defaultState,
-        SCOORDGroup = _MeasurementReport$ge.SCOORDGroup,
-        NUMGroup = _MeasurementReport$ge.NUMGroup;
-      var state = _objectSpread2(_objectSpread2({}, defaultState), {}, {
-        toolType: RectangleRoi.toolType,
-        handles: {
-          start: {},
-          end: {},
-          textBox: {
-            active: false,
-            hasMoved: false,
-            movesIndependently: false,
-            drawnIndependently: true,
-            allowedOutsideImage: true,
-            hasBoundingBox: true
-          },
-          initialRotation: 0
-        },
-        cachedStats: {
-          area: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : 0
-        },
-        color: undefined,
-        invalidated: true
-      });
-      var _SCOORDGroup$GraphicD = _slicedToArray(SCOORDGroup.GraphicData, 6);
-      state.handles.start.x = _SCOORDGroup$GraphicD[0];
-      state.handles.start.y = _SCOORDGroup$GraphicD[1];
-      _SCOORDGroup$GraphicD[2];
-      _SCOORDGroup$GraphicD[3];
-      state.handles.end.x = _SCOORDGroup$GraphicD[4];
-      state.handles.end.y = _SCOORDGroup$GraphicD[5];
-      return state;
+}
+function getUnpackedOffsetAndLength(chunks, offset, length) {
+  var totalBytes = chunks.reduce(function (total, chunk) {
+    return total + chunk.length;
+  }, 0);
+  if (offset < 0 || offset + length > totalBytes) {
+    throw new Error("Offset and length out of bounds");
+  }
+  var startChunkIndex = 0;
+  var startOffsetInChunk = offset;
+  while (startOffsetInChunk >= chunks[startChunkIndex].length) {
+    startOffsetInChunk -= chunks[startChunkIndex].length;
+    startChunkIndex++;
+  }
+  var endChunkIndex = startChunkIndex;
+  var endOffsetInChunk = startOffsetInChunk + length;
+  while (endOffsetInChunk > chunks[endChunkIndex].length) {
+    endOffsetInChunk -= chunks[endChunkIndex].length;
+    endChunkIndex++;
+  }
+  return {
+    start: {
+      chunkIndex: startChunkIndex,
+      offset: startOffsetInChunk
+    },
+    end: {
+      chunkIndex: endChunkIndex,
+      offset: endOffsetInChunk
     }
-  }, {
-    key: "getTID300RepresentationArguments",
-    value: function getTID300RepresentationArguments(tool) {
-      var finding = tool.finding,
-        findingSites = tool.findingSites,
-        _tool$cachedStats = tool.cachedStats,
-        cachedStats = _tool$cachedStats === void 0 ? {} : _tool$cachedStats,
-        handles = tool.handles;
-      var start = handles.start,
-        end = handles.end;
-      var points = [start, {
-        x: start.x,
-        y: end.y
-      }, end, {
-        x: end.x,
-        y: start.y
-      }];
-      var area = cachedStats.area,
-        perimeter = cachedStats.perimeter;
-      var trackingIdentifierTextValue = "cornerstoneTools@^4.0.0:RectangleRoi";
-      return {
-        points: points,
-        area: area,
-        perimeter: perimeter,
-        trackingIdentifierTextValue: trackingIdentifierTextValue,
-        finding: finding,
-        findingSites: findingSites || []
-      };
+  };
+}
+function calculateCentroid(imageIdIndexBufferIndex, multiframe) {
+  var xAcc = 0;
+  var yAcc = 0;
+  var zAcc = 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);
+    if (!bufferIndices || bufferIndices.length === 0) {
+      continue;
+    }
+    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;
+        xAcc += x;
+        yAcc += y;
+        zAcc += z;
+        count++;
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
     }
-  }]);
-  return RectangleRoi;
-}();
-RectangleRoi.toolType = "RectangleRoi";
-RectangleRoi.utilityToolType = "RectangleRoi";
-RectangleRoi.TID300Representation = TID300Polyline$2;
-RectangleRoi.isValidCornerstoneTrackingIdentifier = function (TrackingIdentifier) {
-  if (!TrackingIdentifier.includes(":")) {
-    return false;
-  }
-  var _TrackingIdentifier$s = TrackingIdentifier.split(":"),
-    _TrackingIdentifier$s2 = _slicedToArray(_TrackingIdentifier$s, 2),
-    cornerstone4Tag = _TrackingIdentifier$s2[0],
-    toolType = _TrackingIdentifier$s2[1];
-  if (cornerstone4Tag !== CORNERSTONE_4_TAG) {
-    return false;
   }
-  return toolType === RectangleRoi.toolType;
+  return {
+    xAcc: xAcc,
+    yAcc: yAcc,
+    zAcc: zAcc,
+    count: count
+  };
+}
+var Segmentation$4 = {
+  generateSegmentation: generateSegmentation$2,
+  generateToolState: generateToolState$2,
+  fillSegmentation: fillSegmentation$1
 };
-MeasurementReport$1.registerTool(RectangleRoi);
 
-var Cornerstone = {
-  Length: Length$1,
-  FreehandRoi: FreehandRoi,
-  Bidirectional: Bidirectional$1,
-  EllipticalRoi: EllipticalRoi,
-  CircleRoi: CircleRoi,
-  ArrowAnnotate: ArrowAnnotate$1,
-  MeasurementReport: MeasurementReport$1,
-  Segmentation: Segmentation$1,
-  CobbAngle: CobbAngle$1,
-  Angle: Angle$1,
-  RectangleRoi: RectangleRoi
+var Segmentation$3 = {
+  generateSegmentation: generateSegmentation$1,
+  generateToolState: generateToolState$1,
+  fillSegmentation: fillSegmentation
+};
+
+/**
+ * generateSegmentation - Generates a DICOM Segmentation object given cornerstoneTools data.
+ *
+ * @param  {object[]} images    An array of the cornerstone image objects.
+ * @param  {Object|Object[]} labelmaps3DorBrushData For 4.X: The cornerstone `Labelmap3D` object, or an array of objects.
+ *                                                  For 3.X: the BrushData.
+ * @param  {number} cornerstoneToolsVersion The cornerstoneTools major version to map against.
+ * @returns {Object}
+ */
+function generateSegmentation$1(images, labelmaps3DorBrushData) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+    includeSliceSpacing: true
+  };
+  var cornerstoneToolsVersion = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 4;
+  if (cornerstoneToolsVersion === 4) {
+    return Segmentation$4.generateSegmentation(images, labelmaps3DorBrushData, options);
+  }
+  if (cornerstoneToolsVersion === 3) {
+    return Segmentation$5.generateSegmentation(images, labelmaps3DorBrushData, options);
+  }
+  console.warn("No generateSegmentation adapater for cornerstone version ".concat(cornerstoneToolsVersion, ", exiting."));
+}
+
+/**
+ * generateToolState - Given a set of cornrstoneTools imageIds and a Segmentation buffer,
+ * derive cornerstoneTools toolState and brush metadata.
+ *
+ * @param  {string[]} imageIds    An array of the imageIds.
+ * @param  {ArrayBuffer} arrayBuffer The SEG arrayBuffer.
+ * @param {*} metadataProvider
+ * @param  {bool} skipOverlapping - skip checks for overlapping segs, default value false.
+ * @param  {number} tolerance - default value 1.e-3.
+ * @param  {number} cornerstoneToolsVersion - default value 4.
+ *
+ * @returns {Object}  The toolState and an object from which the
+ *                    segment metadata can be derived.
+ */
+function generateToolState$1(imageIds, arrayBuffer, metadataProvider) {
+  var skipOverlapping = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  var tolerance = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1e-3;
+  var cornerstoneToolsVersion = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 4;
+  if (cornerstoneToolsVersion === 4) {
+    return Segmentation$4.generateToolState(imageIds, arrayBuffer, metadataProvider, skipOverlapping, tolerance);
+  }
+  if (cornerstoneToolsVersion === 3) {
+    return Segmentation$5.generateToolState(imageIds, arrayBuffer, metadataProvider);
+  }
+  console.warn("No generateToolState adapater for cornerstone version ".concat(cornerstoneToolsVersion, ", exiting."));
+}
+
+/**
+ * fillSegmentation - Fills a derived segmentation dataset with cornerstoneTools `LabelMap3D` data.
+ *
+ * @param  {object[]} segmentation An empty segmentation derived dataset.
+ * @param  {Object|Object[]} inputLabelmaps3D The cornerstone `Labelmap3D` object, or an array of objects.
+ * @param  {Object} userOptions Options object to override default options.
+ * @returns {Blob}           description
+ */
+function fillSegmentation(segmentation, inputLabelmaps3D) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+    includeSliceSpacing: true
+  };
+  var cornerstoneToolsVersion = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 4;
+  if (cornerstoneToolsVersion === 4) {
+    return Segmentation$4.fillSegmentation(segmentation, inputLabelmaps3D, options);
+  }
+  console.warn("No generateSegmentation adapater for cornerstone version ".concat(cornerstoneToolsVersion, ", exiting."));
+}
+
+var CornerstoneSR = {
+    Length: Length$1,
+    FreehandRoi: FreehandRoi,
+    Bidirectional: Bidirectional$1,
+    EllipticalRoi: EllipticalRoi,
+    CircleRoi: CircleRoi,
+    ArrowAnnotate: ArrowAnnotate$1,
+    MeasurementReport: MeasurementReport$1,
+    CobbAngle: CobbAngle$1,
+    Angle: Angle$1,
+    RectangleRoi: RectangleRoi
+};
+var CornerstoneSEG = {
+    Segmentation: Segmentation$3
 };
 
 /******************************************************************************
@@ -3049,7 +3583,7 @@ var CodingScheme = {
 
 var TID1500 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.TID1500, addAccessors = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .utilities */ .hC.addAccessors;
 var StructuredReport = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .derivations */ .U7.StructuredReport;
-var Normalizer = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .normalizers */ .oq.Normalizer;
+var Normalizer$1 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .normalizers */ .oq.Normalizer;
 var TID1500MeasurementReport = TID1500.TID1500MeasurementReport, TID1501MeasurementGroup = TID1500.TID1501MeasurementGroup;
 var DicomMetaDictionary = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .data */ .aT.DicomMetaDictionary;
 var FINDING = { CodingSchemeDesignator: "DCM", CodeValue: "121071" };
@@ -3218,7 +3752,7 @@ var MeasurementReport = /** @class */ (function () {
             if ((instance &&
                 instance.NumberOfFrames &&
                 instance.NumberOfFrames > 1) ||
-                Normalizer.isMultiframeSOPClassUID(sopClassUID)) {
+                Normalizer$1.isMultiframeSOPClassUID(sopClassUID)) {
                 ReferencedSOPSequence.ReferencedFrameNumber = frameNumber;
             }
             // Loop through each tool type for the image
@@ -3853,26 +4387,26 @@ var EllipticalROI = /** @class */ (function () {
             ]);
             pointsWorld.push(worldPos);
         }
-        var majorAxisStart = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.fromValues */ .R3.fromValues.apply(gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3 */ .R3, pointsWorld[0]);
-        var majorAxisEnd = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.fromValues */ .R3.fromValues.apply(gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3 */ .R3, pointsWorld[1]);
-        var minorAxisStart = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.fromValues */ .R3.fromValues.apply(gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3 */ .R3, pointsWorld[2]);
-        var minorAxisEnd = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.fromValues */ .R3.fromValues.apply(gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3 */ .R3, pointsWorld[3]);
-        var majorAxisVec = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.create */ .R3.create();
-        gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.sub */ .R3.sub(majorAxisVec, majorAxisEnd, majorAxisStart);
+        var majorAxisStart = gl_matrix__WEBPACK_IMPORTED_MODULE_4__/* .vec3.fromValues */ .R3.fromValues.apply(gl_matrix__WEBPACK_IMPORTED_MODULE_4__/* .vec3 */ .R3, pointsWorld[0]);
+        var majorAxisEnd = gl_matrix__WEBPACK_IMPORTED_MODULE_4__/* .vec3.fromValues */ .R3.fromValues.apply(gl_matrix__WEBPACK_IMPORTED_MODULE_4__/* .vec3 */ .R3, pointsWorld[1]);
+        var minorAxisStart = gl_matrix__WEBPACK_IMPORTED_MODULE_4__/* .vec3.fromValues */ .R3.fromValues.apply(gl_matrix__WEBPACK_IMPORTED_MODULE_4__/* .vec3 */ .R3, pointsWorld[2]);
+        var minorAxisEnd = gl_matrix__WEBPACK_IMPORTED_MODULE_4__/* .vec3.fromValues */ .R3.fromValues.apply(gl_matrix__WEBPACK_IMPORTED_MODULE_4__/* .vec3 */ .R3, pointsWorld[3]);
+        var majorAxisVec = gl_matrix__WEBPACK_IMPORTED_MODULE_4__/* .vec3.create */ .R3.create();
+        gl_matrix__WEBPACK_IMPORTED_MODULE_4__/* .vec3.sub */ .R3.sub(majorAxisVec, majorAxisEnd, majorAxisStart);
         // normalize majorAxisVec to avoid scaling issues
-        gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.normalize */ .R3.normalize(majorAxisVec, majorAxisVec);
-        var minorAxisVec = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.create */ .R3.create();
-        gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.sub */ .R3.sub(minorAxisVec, minorAxisEnd, minorAxisStart);
-        gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.normalize */ .R3.normalize(minorAxisVec, minorAxisVec);
+        gl_matrix__WEBPACK_IMPORTED_MODULE_4__/* .vec3.normalize */ .R3.normalize(majorAxisVec, majorAxisVec);
+        var minorAxisVec = gl_matrix__WEBPACK_IMPORTED_MODULE_4__/* .vec3.create */ .R3.create();
+        gl_matrix__WEBPACK_IMPORTED_MODULE_4__/* .vec3.sub */ .R3.sub(minorAxisVec, minorAxisEnd, minorAxisStart);
+        gl_matrix__WEBPACK_IMPORTED_MODULE_4__/* .vec3.normalize */ .R3.normalize(minorAxisVec, minorAxisVec);
         var imagePlaneModule = metadata.get("imagePlaneModule", referencedImageId);
         if (!imagePlaneModule) {
             throw new Error("imageId does not have imagePlaneModule metadata");
         }
         var columnCosines = imagePlaneModule.columnCosines;
         // find which axis is parallel to the columnCosines
-        var columnCosinesVec = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.fromValues */ .R3.fromValues(columnCosines[0], columnCosines[1], columnCosines[2]);
-        var projectedMajorAxisOnColVec = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.dot */ .R3.dot(columnCosinesVec, majorAxisVec);
-        var projectedMinorAxisOnColVec = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.dot */ .R3.dot(columnCosinesVec, minorAxisVec);
+        var columnCosinesVec = gl_matrix__WEBPACK_IMPORTED_MODULE_4__/* .vec3.fromValues */ .R3.fromValues(columnCosines[0], columnCosines[1], columnCosines[2]);
+        var projectedMajorAxisOnColVec = gl_matrix__WEBPACK_IMPORTED_MODULE_4__/* .vec3.dot */ .R3.dot(columnCosinesVec, majorAxisVec);
+        var projectedMinorAxisOnColVec = gl_matrix__WEBPACK_IMPORTED_MODULE_4__/* .vec3.dot */ .R3.dot(columnCosinesVec, minorAxisVec);
         var absoluteOfMajorDotProduct = Math.abs(projectedMajorAxisOnColVec);
         var absoluteOfMinorDotProduct = Math.abs(projectedMinorAxisOnColVec);
         var ellipsePoints = [];
@@ -4177,7 +4711,7 @@ var PlanarFreehandROI = /** @class */ (function () {
             ]);
             worldCoords.push(point);
         }
-        var distanceBetweenFirstAndLastPoint = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.distance */ .R3.distance(worldCoords[worldCoords.length - 1], worldCoords[0]);
+        var distanceBetweenFirstAndLastPoint = gl_matrix__WEBPACK_IMPORTED_MODULE_4__/* .vec3.distance */ .R3.distance(worldCoords[worldCoords.length - 1], worldCoords[0]);
         var isOpenContour = true;
         // If the contour is closed, this should have been encoded as exactly the same point, so check for a very small difference.
         if (distanceBetweenFirstAndLastPoint < closedContourThreshold) {
@@ -4329,7 +4863,115 @@ Probe.isValidCornerstoneTrackingIdentifier = function (TrackingIdentifier) {
 };
 MeasurementReport.registerTool(Probe);
 
-var Cornerstone3D = {
+var Normalizer = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .normalizers */ .oq.Normalizer;
+var SegmentationDerivation = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .derivations */ .U7.Segmentation;
+/**
+ * generateSegmentation - Generates a DICOM Segmentation object given cornerstoneTools data.
+ *
+ * @param images - An array of the cornerstone image objects, which includes imageId and metadata
+ * @param labelmaps - An array of the 3D Volumes that contain the segmentation data.
+ */
+function generateSegmentation(images, labelmaps, metadata, options) {
+    var segmentation = _createMultiframeSegmentationFromReferencedImages(images, metadata, options);
+    return fillSegmentation$1(segmentation, labelmaps, options);
+}
+/**
+ * _createMultiframeSegmentationFromReferencedImages - description
+ *
+ * @param images - An array of the cornerstone image objects related to the reference
+ * series that the segmentation is derived from. You can use methods such as
+ * volume.getCornerstoneImages() to get this array.
+ *
+ * @param options - the options object for the SegmentationDerivation.
+ * @returns The Seg derived dataSet.
+ */
+function _createMultiframeSegmentationFromReferencedImages(images, metadata, options) {
+    var datasets = images.map(function (image) {
+        // add the sopClassUID to the dataset
+        var instance = metadata.get("instance", image.imageId);
+        return __assign(__assign(__assign({}, image), instance), { 
+            // Todo: move to dcmjs tag style
+            SOPClassUID: instance.SopClassUID, SOPInstanceUID: instance.SopInstanceUID, PixelData: image.getPixelData(), _vrMap: {
+                PixelData: "OW"
+            }, _meta: {} });
+    });
+    var multiframe = Normalizer.normalizeToDataset(datasets);
+    return new SegmentationDerivation([multiframe], options);
+}
+
+/**
+ * Generates 2D label maps from a 3D label map.
+ * @param labelmap3D - The 3D label map object to generate 2D label maps from. It is derived
+ * from the volume labelmap.
+ * @returns The label map object containing the 2D label maps and segments on label maps.
+ */
+function generateLabelMaps2DFrom3D(labelmap3D) {
+    // 1. we need to generate labelmaps2D from labelmaps3D, a labelmap2D is for each
+    // slice
+    var scalarData = labelmap3D.scalarData, dimensions = labelmap3D.dimensions;
+    // scalarData is a flat array of all the pixels in the volume.
+    var labelmaps2D = [];
+    var segmentsOnLabelmap3D = new Set();
+    // X-Y are the row and column dimensions, Z is the number of slices.
+    for (var z = 0; z < dimensions[2]; z++) {
+        var pixelData = scalarData.slice(z * dimensions[0] * dimensions[1], (z + 1) * dimensions[0] * dimensions[1]);
+        var segmentsOnLabelmap = [];
+        for (var i = 0; i < pixelData.length; i++) {
+            var segment = pixelData[i];
+            if (!segmentsOnLabelmap.includes(segment) && segment !== 0) {
+                segmentsOnLabelmap.push(segment);
+            }
+        }
+        var labelmap2D = {
+            segmentsOnLabelmap: segmentsOnLabelmap,
+            pixelData: pixelData,
+            rows: dimensions[1],
+            columns: dimensions[0]
+        };
+        if (segmentsOnLabelmap.length === 0) {
+            continue;
+        }
+        segmentsOnLabelmap.forEach(function (segmentIndex) {
+            segmentsOnLabelmap3D.add(segmentIndex);
+        });
+        labelmaps2D[dimensions[2] - 1 - z] = labelmap2D;
+    }
+    // remove segment 0 from segmentsOnLabelmap3D
+    labelmap3D.segmentsOnLabelmap = Array.from(segmentsOnLabelmap3D);
+    labelmap3D.labelmaps2D = labelmaps2D;
+    return labelmap3D;
+}
+
+var Segmentation$2 = CornerstoneSEG.Segmentation;
+var generateToolStateCornerstoneLegacy = Segmentation$2.generateToolState;
+/**
+ * generateToolState - Given a set of cornerstoneTools imageIds and a Segmentation buffer,
+ * derive cornerstoneTools toolState and brush metadata.
+ *
+ * @param   imageIds - An array of the imageIds.
+ * @param   arrayBuffer - The SEG arrayBuffer.
+ * @param   skipOverlapping - skip checks for overlapping segs, default value false.
+ * @param   tolerance - default value 1.e-3.
+ *
+ * @returns a list of array buffer for each labelMap
+ *  an object from which the segment metadata can be derived
+ *  list containing the track of segments per frame
+ *  list containing the track of segments per frame for each labelMap                   (available only for the overlapping case).
+ */
+function generateToolState(imageIds, arrayBuffer, metadataProvider, skipOverlapping, tolerance) {
+    if (skipOverlapping === void 0) { skipOverlapping = false; }
+    if (tolerance === void 0) { tolerance = 1e-3; }
+    return generateToolStateCornerstoneLegacy(imageIds, arrayBuffer, metadataProvider, skipOverlapping, tolerance);
+}
+
+var Segmentation$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  generateLabelMaps2DFrom3D: generateLabelMaps2DFrom3D,
+  generateSegmentation: generateSegmentation,
+  generateToolState: generateToolState
+});
+
+var Cornerstone3DSR = {
     Bidirectional: Bidirectional,
     CobbAngle: CobbAngle,
     Angle: Angle,
@@ -4344,6 +4986,9 @@ var Cornerstone3D = {
     CodeScheme: CodingScheme,
     CORNERSTONE_3D_TAG: CORNERSTONE_3D_TAG
 };
+var Cornerstone3DSEG = {
+    Segmentation: Segmentation$1
+};
 
 var Colors = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .data */ .aT.Colors,
   BitArray = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .data */ .aT.BitArray;
@@ -4528,23 +5173,26 @@ var Segmentation = /*#__PURE__*/function () {
   return Segmentation;
 }();
 
-var VTKjs = {
-  Segmentation: Segmentation
+var VTKjsSEG = {
+    Segmentation: Segmentation
 };
 
-var adapters = {
-  Cornerstone: Cornerstone,
-  Cornerstone3D: Cornerstone3D,
-  VTKjs: VTKjs
+var adaptersSR = {
+    Cornerstone: CornerstoneSR,
+    Cornerstone3D: Cornerstone3DSR
+};
+var adaptersSEG = {
+    Cornerstone: CornerstoneSEG,
+    Cornerstone3D: Cornerstone3DSEG,
+    VTKjs: VTKjsSEG
 };
 
 
-//# sourceMappingURL=adapters.es.js.map
 
 
 /***/ }),
 
-/***/ 78738:
+/***/ 27318:
 /***/ ((module) => {
 
 "use strict";
@@ -4562,7 +5210,7 @@ module.exports = iota
 
 /***/ }),
 
-/***/ 28998:
+/***/ 8516:
 /***/ ((module) => {
 
 /*!
@@ -4580,11 +5228,11 @@ module.exports = function isBuffer (obj) {
 
 /***/ }),
 
-/***/ 73373:
+/***/ 87513:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-var iota = __webpack_require__(78738)
-var isBuffer = __webpack_require__(28998)
+var iota = __webpack_require__(27318)
+var isBuffer = __webpack_require__(8516)
 
 var hasTypedArrays  = ((typeof Float64Array) !== "undefined")