@ohif/app 3.7.0-beta.11 → 3.7.0-beta.110

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

@@ -1,19 +1,24 @@
-(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 */   Y: () => (/* binding */ index),
+/* harmony export */   adaptersRT: () => (/* binding */ adaptersRT),
+/* harmony export */   adaptersSEG: () => (/* binding */ adaptersSEG),
+/* harmony export */   adaptersSR: () => (/* binding */ adaptersSR),
+/* harmony export */   helpers: () => (/* binding */ index$1)
 /* 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);
-/* 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___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 dcmjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(67540);
+/* harmony import */ var buffer__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(58955);
+/* harmony import */ var ndarray__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(87513);
+/* harmony import */ var ndarray__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(ndarray__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var lodash_clonedeep__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(11677);
+/* harmony import */ var lodash_clonedeep__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(lodash_clonedeep__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(45451);
+
 
 
 
@@ -67,6 +72,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,22 +539,71 @@ 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 datasetToDict = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .data */ .aT.datasetToDict;
+/**
+ * Trigger file download from an array buffer
+ * @param bufferOrDataset - ArrayBuffer or DicomDataset
+ * @param filename - name of the file to download
+ */
+function downloadDICOMData(bufferOrDataset, filename) {
+    var blob;
+    if (bufferOrDataset instanceof ArrayBuffer) {
+        blob = new Blob([bufferOrDataset], { type: "application/dicom" });
+    }
+    else {
+        if (!bufferOrDataset._meta) {
+            throw new Error("Dataset must have a _meta property");
+        }
+        var buffer = buffer__WEBPACK_IMPORTED_MODULE_1__/* .Buffer */ .lW.from(datasetToDict(bufferOrDataset).write());
+        blob = new Blob([buffer], { type: "application/dicom" });
+    }
+    var link = document.createElement("a");
+    link.href = window.URL.createObjectURL(blob);
+    link.download = filename;
+    link.click();
+}
+
+var index$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  codeMeaningEquals: codeMeaningEquals,
+  downloadDICOMData: downloadDICOMData,
+  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;
+var DicomMetaDictionary$4 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .data */ .aT.DicomMetaDictionary;
 var FINDING$2 = {
   CodingSchemeDesignator: "DCM",
   CodeValue: "121071"
@@ -347,7 +732,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;
         }
 
@@ -389,7 +774,7 @@ var MeasurementReport$1 = /*#__PURE__*/function () {
           vr: "UI"
         },
         ImplementationClassUID: {
-          Value: [DicomMetaDictionary$3.uid()],
+          Value: [DicomMetaDictionary$4.uid()],
           // TODO: could be git hash or other valid id
           vr: "UI"
         },
@@ -1181,80 +1566,353 @@ 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 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(":")) {
+    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 === ANGLE;
+};
+MeasurementReport$1.registerTool(Angle$1);
+
+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 _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$3 = 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
+};
+
+/**
+ *
+ * @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) {
@@ -1319,21 +1977,21 @@ function _createSegFromImages$1(images, isMultiframe, options) {
     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);
+    var dataset = DicomMetaDictionary$3.naturalizeDataset(dicomData.dict);
+    dataset._meta = DicomMetaDictionary$3.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);
+      var _dataset = DicomMetaDictionary$3.naturalizeDataset(_dicomData.dict);
+      _dataset._meta = DicomMetaDictionary$3.namifyDataset(_dicomData.meta);
       datasets.push(_dataset);
     }
   }
-  var multiframe = Normalizer$2.normalizeToDataset(datasets);
-  return new SegmentationDerivation$1([multiframe], options);
+  var multiframe = Normalizer$3.normalizeToDataset(datasets);
+  return new SegmentationDerivation$2([multiframe], options);
 }
 
 /**
@@ -1346,11 +2004,11 @@ function _createSegFromImages$1(images, isMultiframe, options) {
  * @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 dataset = DicomMetaDictionary$3.naturalizeDataset(dicomData.dict);
+  dataset._meta = DicomMetaDictionary$3.namifyDataset(dicomData.meta);
+  var multiframe = Normalizer$3.normalizeToDataset([dataset]);
   var imagePlaneModule = metadataProvider.get("imagePlaneModule", imageIds[0]);
   if (!imagePlaneModule) {
     console.warn("Insufficient metadata, imagePlaneModule missing.");
@@ -1370,7 +2028,7 @@ function generateToolState$2(imageIds, arrayBuffer, metadataProvider) {
   for (var i = 0; i < PerFrameFunctionalGroupsSequence.length; i++) {
     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), [multiframe.Rows, multiframe.Columns]);
+    var pixelDataI2D = ndarray__WEBPACK_IMPORTED_MODULE_2___default()(new Uint8Array(pixelData.buffer, i * sliceLength, sliceLength), [multiframe.Rows, multiframe.Columns]);
     var alignedPixelDataI = alignPixelDataWithSourceData$1(pixelDataI2D, ImageOrientationPatientI, validOrientations);
     if (!alignedPixelDataI) {
       console.warn("This segmentation object is not in-plane with the source data. Bailing out of IO. It'd be better to render this with vtkjs. ");
@@ -1465,7 +2123,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 +2136,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 +2262,37 @@ 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 BitArray$1 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .data */ .aT.BitArray,
+  DicomMessage = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .data */ .aT.DicomMessage,
+  DicomMetaDictionary$2 = 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 +2301,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 +2316,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);
@@ -1656,12 +2324,13 @@ function generateSegmentation$1(images, inputLabelmaps3D) {
 }
 
 /**
- * fillSegmentation - Fills a derived segmentation dataset with cornerstoneTools `LabelMap3D` data.
+ * Fills a given segmentation object with data from the input labelmaps3D
  *
- * @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
+ * @param segmentation - The segmentation object to be filled.
+ * @param inputLabelmaps3D - An array of 3D labelmaps, or a single 3D labelmap.
+ * @param userOptions - Optional configuration settings. Will override the default options.
+ *
+ * @returns {object} The filled segmentation object.
  */
 function fillSegmentation$1(segmentation, inputLabelmaps3D) {
   var userOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
@@ -1714,7 +2383,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 +2412,9 @@ function fillSegmentation$1(segmentation, inputLabelmaps3D) {
     // If no rleEncoding, at least bitpack the data.
     segmentation.bitPackPixelData();
   }
-  var segBlob = datasetToBlob(segmentation.dataset);
-  return segBlob;
+  return segmentation;
 }
-function _getLabelmapsFromRefernecedFrameIndicies(labelmap3D, referencedFrameIndicies) {
+function _getLabelmapsFromReferencedFrameIndicies(labelmap3D, referencedFrameIndicies) {
   var labelmaps2D = labelmap3D.labelmaps2D;
   var labelmaps = [];
   for (var i = 0; i < referencedFrameIndicies.length; i++) {
@@ -1769,21 +2437,21 @@ function _createSegFromImages(images, isMultiframe, options) {
     var image = images[0];
     var arrayBuffer = image.data.byteArray.buffer;
     var dicomData = DicomMessage.readFile(arrayBuffer);
-    var dataset = DicomMetaDictionary$1.naturalizeDataset(dicomData.dict);
-    dataset._meta = DicomMetaDictionary$1.namifyDataset(dicomData.meta);
+    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.readFile(_arrayBuffer);
-      var _dataset = DicomMetaDictionary$1.naturalizeDataset(_dicomData.dict);
-      _dataset._meta = DicomMetaDictionary$1.namifyDataset(_dicomData.meta);
+      var _dataset = DicomMetaDictionary$2.naturalizeDataset(_dicomData.dict);
+      _dataset._meta = DicomMetaDictionary$2.namifyDataset(_dicomData.meta);
       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 +2461,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 +2469,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 +2486,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 +2511,6 @@ function generateToolState$1(imageIds, arrayBuffer, metadataProvider) {
 //               firstImagePlaneModule.rowCosines.y,
 //               firstImagePlaneModule.rowCosines.z
 //           ];
-
 //     const columnCosines = Array.isArray(firstImagePlaneModule.columnCosines)
 //         ? [...firstImagePlaneModule.columnCosines]
 //         : [
@@ -1933,9 +2518,7 @@ function generateToolState$1(imageIds, arrayBuffer, metadataProvider) {
 //               firstImagePlaneModule.columnCosines.y,
 //               firstImagePlaneModule.columnCosines.z
 //           ];
-
 //     const { pixelSpacing } = firstImagePlaneModule;
-
 //     mat4.set(
 //         indexToWorld,
 //         // Column 1
@@ -1959,50 +2542,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 +2581,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 +2604,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$2.naturalizeDataset(dicomData.dict);
+          dataset._meta = DicomMetaDictionary$2.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 +2797,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 +2812,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 +2839,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 +2867,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_2___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 +2897,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;
 
@@ -2219,7 +2915,7 @@ function insertOverlappingPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray,
   var tempBuffer = labelmapBufferArray[m].slice(0);
 
   // temp list for checking overlaps
-  var tempSegmentsOnFrame = lodash_clonedeep__WEBPACK_IMPORTED_MODULE_2___default()(segmentsOnFrameArray[m]);
+  var tempSegmentsOnFrame = lodash_clonedeep__WEBPACK_IMPORTED_MODULE_3___default()(segmentsOnFrameArray[m]);
 
   /** split overlapping SEGs algorithm for each segment:
    *  A) copy the labelmapBuffer in the array with index 0
@@ -2241,12 +2937,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_2___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 +2960,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) {
@@ -2274,7 +2974,7 @@ function insertOverlappingPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray,
               M++;
             }
             tempBuffer = labelmapBufferArray[m].slice(0);
-            tempSegmentsOnFrame = lodash_clonedeep__WEBPACK_IMPORTED_MODULE_2___default()(segmentsOnFrameArray[m]);
+            tempSegmentsOnFrame = lodash_clonedeep__WEBPACK_IMPORTED_MODULE_3___default()(segmentsOnFrameArray[m]);
             _i2 = 0;
             break;
           } else {
@@ -2300,12 +3000,12 @@ function insertOverlappingPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray,
       if (_ret2 === "continue") continue;
     }
     labelmapBufferArray[m] = tempBuffer.slice(0);
-    segmentsOnFrameArray[m] = lodash_clonedeep__WEBPACK_IMPORTED_MODULE_2___default()(tempSegmentsOnFrame);
+    segmentsOnFrameArray[m] = lodash_clonedeep__WEBPACK_IMPORTED_MODULE_3___default()(tempSegmentsOnFrame);
 
     // reset temp variables/buffers for new segment
     m = 0;
     tempBuffer = labelmapBufferArray[m].slice(0);
-    tempSegmentsOnFrame = lodash_clonedeep__WEBPACK_IMPORTED_MODULE_2___default()(segmentsOnFrameArray[m]);
+    tempSegmentsOnFrame = lodash_clonedeep__WEBPACK_IMPORTED_MODULE_3___default()(segmentsOnFrameArray[m]);
   }
 }
 var getSegmentIndex = function getSegmentIndex(multiframe, frame) {
@@ -2314,60 +3014,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_2___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;
+        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();
       }
     }
-  };
-  for (var i = 0, groupsLen = PerFrameFunctionalGroupsSequence.length; i < groupsLen; ++i) {
-    var _ret3 = _loop5();
-    if (_ret3 === "continue") continue;
-  }
+    processInChunks();
+  });
 }
 function checkOrientation(multiframe, validOrientations, sourceDataDimensions, tolerance) {
   var SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence,
@@ -2406,12 +3139,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 +3157,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 +3174,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 +3212,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 +3232,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 +3239,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;
 }
 
 /**
@@ -2635,9 +3360,111 @@ function getSegmentMetadata(multiframe, seriesInstanceUid) {
   };
 }
 
-var Segmentation$1 = {
-  generateSegmentation: generateSegmentation,
-  generateToolState: generateToolState,
+/**
+ * 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;
+  }
+}
+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
+    }
+  };
+}
+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 {
+    xAcc: xAcc,
+    yAcc: yAcc,
+    zAcc: zAcc,
+    count: count
+  };
+}
+var Segmentation$4 = {
+  generateSegmentation: generateSegmentation$2,
+  generateToolState: generateToolState$2,
+  fillSegmentation: fillSegmentation$1
+};
+
+var Segmentation$3 = {
+  generateSegmentation: generateSegmentation$1,
+  generateToolState: generateToolState$1,
   fillSegmentation: fillSegmentation
 };
 
@@ -2650,16 +3477,16 @@ var Segmentation$1 = {
  * @param  {number} cornerstoneToolsVersion The cornerstoneTools major version to map against.
  * @returns {Object}
  */
-function generateSegmentation(images, labelmaps3DorBrushData) {
+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$2.generateSegmentation(images, labelmaps3DorBrushData, options);
+    return Segmentation$4.generateSegmentation(images, labelmaps3DorBrushData, options);
   }
   if (cornerstoneToolsVersion === 3) {
-    return Segmentation$3.generateSegmentation(images, labelmaps3DorBrushData, options);
+    return Segmentation$5.generateSegmentation(images, labelmaps3DorBrushData, options);
   }
   console.warn("No generateSegmentation adapater for cornerstone version ".concat(cornerstoneToolsVersion, ", exiting."));
 }
@@ -2678,323 +3505,52 @@ function generateSegmentation(images, labelmaps3DorBrushData) {
  * @returns {Object}  The toolState and an object from which the
  *                    segment metadata can be derived.
  */
-function generateToolState(imageIds, arrayBuffer, metadataProvider) {
+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$2.generateToolState(imageIds, arrayBuffer, metadataProvider, skipOverlapping, tolerance);
+    return Segmentation$4.generateToolState(imageIds, arrayBuffer, metadataProvider, skipOverlapping, tolerance);
   }
   if (cornerstoneToolsVersion === 3) {
-    return Segmentation$3.generateToolState(imageIds, arrayBuffer, metadataProvider);
+    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$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(":")) {
-    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 === ANGLE;
-};
-MeasurementReport$1.registerTool(Angle$1);
-
-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 _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;
+ *
+ * @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);
   }
-  return toolType === RectangleRoi.toolType;
-};
-MeasurementReport$1.registerTool(RectangleRoi);
+  console.warn("No generateSegmentation adapater for cornerstone version ".concat(cornerstoneToolsVersion, ", exiting."));
+}
 
-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 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,9 +3605,9 @@ 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 DicomMetaDictionary$1 = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .data */ .aT.DicomMetaDictionary;
 var FINDING = { CodingSchemeDesignator: "DCM", CodeValue: "121071" };
 var FINDING_SITE = { CodingSchemeDesignator: "SCT", CodeValue: "363698007" };
 var FINDING_SITE_OLD = { CodingSchemeDesignator: "SRT", CodeValue: "G-C0E3" };
@@ -3120,7 +3676,7 @@ var MeasurementReport = /** @class */ (function () {
                 vr: "UI"
             },
             ImplementationClassUID: {
-                Value: [DicomMetaDictionary.uid()],
+                Value: [DicomMetaDictionary$1.uid()],
                 vr: "UI"
             },
             ImplementationVersionName: {
@@ -3155,7 +3711,7 @@ var MeasurementReport = /** @class */ (function () {
             description: undefined,
             sopInstanceUid: ReferencedSOPInstanceUID,
             annotation: {
-                annotationUID: DicomMetaDictionary.uid(),
+                annotationUID: DicomMetaDictionary$1.uid(),
                 metadata: {
                     toolName: toolType,
                     referencedImageId: referencedImageId,
@@ -3218,7 +3774,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 +4409,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 +4733,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 +4885,836 @@ 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) {
+    if (options === void 0) { 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 || instance.SOPClassUID, SOPInstanceUID: instance.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
+});
+
+/**
+ * Checks if point is within array
+ * @param {*} array
+ * @param {*} pt
+ * @returns
+ */
+function ptInArray(array, pt) {
+  var index = -1;
+  for (var i = 0; i < array.length; i++) {
+    if (isSamePoint(pt, array[i])) {
+      index = i;
+    }
+  }
+  return index;
+}
+
+/**
+ * Checks if point A and point B contain same values
+ * @param {*} ptA
+ * @param {*} ptB
+ * @returns
+ */
+function isSamePoint(ptA, ptB) {
+  if (ptA[0] == ptB[0] && ptA[1] == ptB[1] && ptA[2] == ptB[2]) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+/**
+ * Goes through linesArray and replaces all references of old index with new index
+ * @param {*} linesArray
+ * @param {*} oldIndex
+ * @param {*} newIndex
+ */
+function replacePointIndexReferences(linesArray, oldIndex, newIndex) {
+  for (var i = 0; i < linesArray.length; i++) {
+    var line = linesArray[i];
+    if (line.a == oldIndex) {
+      line.a = newIndex;
+    } else if (line.b == oldIndex) {
+      line.b = newIndex;
+    }
+  }
+}
+
+/**
+ * Iterate through polyData from vtkjs and merge any points that are the same
+ * then update merged point references within lines array
+ * @param {*} polyData
+ * @param {*} bypass
+ * @returns
+ */
+function removeDuplicatePoints(polyData, bypass) {
+  var points = polyData.getPoints();
+  var lines = polyData.getLines();
+  var pointsArray = [];
+  for (var i = 0; i < points.getNumberOfPoints(); i++) {
+    var pt = points.getPoint(i).slice();
+    pointsArray.push(pt);
+  }
+  var linesArray = [];
+  for (var _i = 0; _i < lines.getNumberOfCells(); _i++) {
+    var cell = lines.getCell(_i * 3).slice();
+    //console.log(JSON.stringify(cell));
+    var a = cell[0];
+    var b = cell[1];
+    var line = {
+      a: a,
+      b: b
+    };
+    linesArray.push(line);
+  }
+  if (bypass) {
+    return {
+      points: pointsArray,
+      lines: linesArray
+    };
+  }
+
+  // Iterate through points and replace any duplicates
+  var newPoints = [];
+  for (var _i2 = 0; _i2 < pointsArray.length; _i2++) {
+    var _pt = pointsArray[_i2];
+    var index = ptInArray(newPoints, _pt);
+    if (index >= 0) {
+      // Duplicate Point -> replace references in lines
+      replacePointIndexReferences(linesArray, _i2, index);
+    } else {
+      index = newPoints.length;
+      newPoints.push(_pt);
+      replacePointIndexReferences(linesArray, _i2, index);
+    }
+  }
+
+  // Final pass through lines, remove any that refer to exact same point
+  var newLines = [];
+  linesArray.forEach(function (line) {
+    if (line.a != line.b) {
+      newLines.push(line);
+    }
+  });
+  return {
+    points: newPoints,
+    lines: newLines
+  };
+}
+
+function findNextLink(line, lines, contourPoints) {
+  var index = -1;
+  lines.forEach(function (cell, i) {
+    if (index >= 0) {
+      return;
+    }
+    if (cell.a == line.b) {
+      index = i;
+    }
+  });
+  if (index >= 0) {
+    var nextLine = lines[index];
+    lines.splice(index, 1);
+    contourPoints.push(nextLine.b);
+    if (contourPoints[0] == nextLine.b) {
+      return {
+        remainingLines: lines,
+        contourPoints: contourPoints,
+        type: "CLOSED_PLANAR"
+        //type: 'CLOSEDPLANAR_XOR',
+      };
+    }
+
+    return findNextLink(nextLine, lines, contourPoints);
+  }
+  return {
+    remainingLines: lines,
+    contourPoints: contourPoints,
+    type: "OPEN_PLANAR"
+  };
+}
+
+/**
+ *
+ * @param {*} lines
+ */
+function findContours(lines) {
+  if (lines.length == 0) {
+    return [];
+  }
+  var contourPoints = [];
+  var firstCell = lines.shift();
+  contourPoints.push(firstCell.a);
+  contourPoints.push(firstCell.b);
+  var result = findNextLink(firstCell, lines, contourPoints);
+  if (result.remainingLines.length == 0) {
+    return [{
+      type: result.type,
+      contourPoints: result.contourPoints
+    }];
+  } else {
+    var extraContours = findContours(result.remainingLines);
+    extraContours.push({
+      type: result.type,
+      contourPoints: result.contourPoints
+    });
+    return extraContours;
+  }
+}
+function findContoursFromReducedSet(lines, points) {
+  return findContours(lines);
+}
+
+function generateContourSetsFromLabelmap(_ref) {
+  var segmentations = _ref.segmentations,
+    cornerstoneCache = _ref.cornerstoneCache,
+    cornerstoneToolsEnums = _ref.cornerstoneToolsEnums,
+    vtkUtils = _ref.vtkUtils;
+  var LABELMAP = cornerstoneToolsEnums.SegmentationRepresentations.Labelmap;
+  var representationData = segmentations.representationData,
+    segments = segmentations.segments;
+  var segVolumeId = representationData[LABELMAP].volumeId;
+
+  // Get segmentation volume
+  var vol = cornerstoneCache.getVolume(segVolumeId);
+  if (!vol) {
+    console.warn("No volume found for ".concat(segVolumeId));
+    return;
+  }
+  var numSlices = vol.dimensions[2];
+
+  // Get image volume segmentation references
+  var imageVol = cornerstoneCache.getVolume(vol.referencedVolumeId);
+  if (!imageVol) {
+    console.warn("No volume found for ".concat(vol.referencedVolumeId));
+    return;
+  }
+
+  // NOTE: Workaround for marching squares not finding closed contours at
+  // boundary of image volume, clear pixels along x-y border of volume
+  var segData = vol.imageData.getPointData().getScalars().getData();
+  var pixelsPerSlice = vol.dimensions[0] * vol.dimensions[1];
+  for (var z = 0; z < numSlices; z++) {
+    for (var y = 0; y < vol.dimensions[1]; y++) {
+      for (var x = 0; x < vol.dimensions[0]; x++) {
+        var index = x + y * vol.dimensions[0] + z * pixelsPerSlice;
+        if (x === 0 || y === 0 || x === vol.dimensions[0] - 1 || y === vol.dimensions[1] - 1) {
+          segData[index] = 0;
+        }
+      }
+    }
+  }
+
+  // end workaround
+  //
+  //
+  var ContourSets = [];
+
+  // Iterate through all segments in current segmentation set
+  var numSegments = segments.length;
+  for (var segIndex = 0; segIndex < numSegments; segIndex++) {
+    var segment = segments[segIndex];
+
+    // Skip empty segments
+    if (!segment) {
+      continue;
+    }
+    var contourSequence = [];
+    for (var sliceIndex = 0; sliceIndex < numSlices; sliceIndex++) {
+      // Check if the slice is empty before running marching cube
+      if (isSliceEmptyForSegment(sliceIndex, segData, pixelsPerSlice, segIndex)) {
+        continue;
+      }
+      try {
+        var _reducedSet$points;
+        var scalars = vtkUtils.vtkDataArray.newInstance({
+          name: "Scalars",
+          values: Array.from(segData),
+          numberOfComponents: 1
+        });
+
+        // Modify segData for this specific segment directly
+        var segmentIndexFound = false;
+        for (var i = 0; i < segData.length; i++) {
+          var value = segData[i];
+          if (value === segIndex) {
+            segmentIndexFound = true;
+            scalars.setValue(i, 1);
+          } else {
+            scalars.setValue(i, 0);
+          }
+        }
+        if (!segmentIndexFound) {
+          continue;
+        }
+        var mSquares = vtkUtils.vtkImageMarchingSquares.newInstance({
+          slice: sliceIndex
+        });
+
+        // filter out the scalar data so that only it has background and
+        // the current segment index
+        var imageDataCopy = vtkUtils.vtkImageData.newInstance();
+        imageDataCopy.shallowCopy(vol.imageData);
+        imageDataCopy.getPointData().setScalars(scalars);
+
+        // Connect pipeline
+        mSquares.setInputData(imageDataCopy);
+        var cValues = [];
+        cValues[0] = 1;
+        mSquares.setContourValues(cValues);
+        mSquares.setMergePoints(false);
+
+        // Perform marching squares
+        var msOutput = mSquares.getOutputData();
+
+        // Clean up output from marching squares
+        var reducedSet = removeDuplicatePoints(msOutput);
+        if ((_reducedSet$points = reducedSet.points) !== null && _reducedSet$points !== void 0 && _reducedSet$points.length) {
+          var contours = findContoursFromReducedSet(reducedSet.lines, reducedSet.points);
+          contourSequence.push({
+            referencedImageId: imageVol.imageIds[sliceIndex],
+            contours: contours,
+            polyData: reducedSet
+          });
+        }
+      } catch (e) {
+        console.warn(sliceIndex);
+        console.warn(e);
+      }
+    }
+    var metadata = {
+      referencedImageId: imageVol.imageIds[0],
+      // just use 0
+      FrameOfReferenceUID: imageVol.metadata.FrameOfReferenceUID
+    };
+    var ContourSet = {
+      label: segment.label,
+      color: segment.color,
+      metadata: metadata,
+      sliceContours: contourSequence
+    };
+    ContourSets.push(ContourSet);
+  }
+  return ContourSets;
+}
+function isSliceEmptyForSegment(sliceIndex, segData, pixelsPerSlice, segIndex) {
+  var startIdx = sliceIndex * pixelsPerSlice;
+  var endIdx = startIdx + pixelsPerSlice;
+  for (var i = startIdx; i < endIdx; i++) {
+    if (segData[i] === segIndex) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// comment
+var RectangleROIStartEndThreshold = /*#__PURE__*/function () {
+  function RectangleROIStartEndThreshold() {
+    _classCallCheck(this, RectangleROIStartEndThreshold);
+  } // empty
+  _createClass(RectangleROIStartEndThreshold, null, [{
+    key: "getContourSequence",
+    value: function getContourSequence(toolData, metadataProvider) {
+      var data = toolData.data;
+      var _data$cachedStats = data.cachedStats,
+        projectionPoints = _data$cachedStats.projectionPoints,
+        projectionPointsImageIds = _data$cachedStats.projectionPointsImageIds;
+      return projectionPoints.map(function (point, index) {
+        var ContourData = getPointData(point);
+        var ContourImageSequence = getContourImageSequence(projectionPointsImageIds[index], metadataProvider);
+        return {
+          NumberOfContourPoints: ContourData.length / 3,
+          ContourImageSequence: ContourImageSequence,
+          ContourGeometricType: "CLOSED_PLANAR",
+          ContourData: ContourData
+        };
+      });
+    }
+  }]);
+  return RectangleROIStartEndThreshold;
+}();
+RectangleROIStartEndThreshold.toolName = "RectangleROIStartEndThreshold";
+function getPointData(points) {
+  // Since this is a closed contour, the order of the points is important.
+  // re-order the points to be in the correct order clockwise
+  // Spread to make sure Float32Arrays are converted to arrays
+  var orderedPoints = [].concat(_toConsumableArray(points[0]), _toConsumableArray(points[1]), _toConsumableArray(points[3]), _toConsumableArray(points[2]));
+  var pointsArray = orderedPoints.flat();
+
+  // reduce the precision of the points to 2 decimal places
+  var pointsArrayWithPrecision = pointsArray.map(function (point) {
+    return point.toFixed(2);
+  });
+  return pointsArrayWithPrecision;
+}
+function getContourImageSequence(imageId, metadataProvider) {
+  var sopCommon = metadataProvider.get("sopCommonModule", imageId);
+  return {
+    ReferencedSOPClassUID: sopCommon.sopClassUID,
+    ReferencedSOPInstanceUID: sopCommon.sopInstanceUID
+  };
+}
+
+function validateAnnotation(annotation) {
+  if (!(annotation !== null && annotation !== void 0 && annotation.data)) {
+    throw new Error("Tool data is empty");
+  }
+  if (!annotation.metadata || annotation.metadata.referenceImageId) {
+    throw new Error("Tool data is not associated with any imageId");
+  }
+}
+var AnnotationToPointData = /*#__PURE__*/function () {
+  function AnnotationToPointData() {
+    _classCallCheck(this, AnnotationToPointData);
+  } // empty
+  _createClass(AnnotationToPointData, null, [{
+    key: "convert",
+    value: function convert(annotation, index, metadataProvider) {
+      validateAnnotation(annotation);
+      var toolName = annotation.metadata.toolName;
+      var toolClass = AnnotationToPointData.TOOL_NAMES[toolName];
+      if (!toolClass) {
+        throw new Error("Unknown tool type: ".concat(toolName, ", cannot convert to RTSSReport"));
+      }
+
+      // Each toolData should become a list of contours, ContourSequence
+      // contains a list of contours with their pointData, their geometry
+      // type and their length.
+      var ContourSequence = toolClass.getContourSequence(annotation, metadataProvider);
+
+      // Todo: random rgb color for now, options should be passed in
+      var color = [Math.floor(Math.random() * 255), Math.floor(Math.random() * 255), Math.floor(Math.random() * 255)];
+      return {
+        ReferencedROINumber: index + 1,
+        ROIDisplayColor: color,
+        ContourSequence: ContourSequence
+      };
+    }
+  }, {
+    key: "register",
+    value: function register(toolClass) {
+      AnnotationToPointData.TOOL_NAMES[toolClass.toolName] = toolClass;
+    }
+  }]);
+  return AnnotationToPointData;
+}();
+AnnotationToPointData.TOOL_NAMES = {};
+AnnotationToPointData.register(RectangleROIStartEndThreshold);
+
+function getPatientModule(imageId, metadataProvider) {
+  var generalSeriesModule = metadataProvider.get("generalSeriesModule", imageId);
+  var generalStudyModule = metadataProvider.get("generalStudyModule", imageId);
+  var patientStudyModule = metadataProvider.get("patientStudyModule", imageId);
+  var patientModule = metadataProvider.get("patientModule", imageId);
+  var patientDemographicModule = metadataProvider.get("patientDemographicModule", imageId);
+  return {
+    Modality: generalSeriesModule.modality,
+    PatientID: patientModule.patientId,
+    PatientName: patientModule.patientName,
+    PatientBirthDate: "",
+    PatientAge: patientStudyModule.patientAge,
+    PatientSex: patientDemographicModule.patientSex,
+    PatientWeight: patientStudyModule.patientWeight,
+    StudyDate: generalStudyModule.studyDate,
+    StudyTime: generalStudyModule.studyTime,
+    StudyID: "ToDo",
+    AccessionNumber: generalStudyModule.accessionNumber
+  };
+}
+
+function getReferencedFrameOfReferenceSequence(metadata, metadataProvider, dataset) {
+  var imageId = metadata.referencedImageId,
+    FrameOfReferenceUID = metadata.FrameOfReferenceUID;
+  var instance = metadataProvider.get("instance", imageId);
+  var SeriesInstanceUID = instance.SeriesInstanceUID;
+  var ReferencedSeriesSequence = dataset.ReferencedSeriesSequence;
+  return [{
+    FrameOfReferenceUID: FrameOfReferenceUID,
+    RTReferencedStudySequence: [{
+      ReferencedSOPClassUID: dataset.SOPClassUID,
+      ReferencedSOPInstanceUID: dataset.SOPInstanceUID,
+      RTReferencedSeriesSequence: [{
+        SeriesInstanceUID: SeriesInstanceUID,
+        ContourImageSequence: _toConsumableArray(ReferencedSeriesSequence[0].ReferencedInstanceSequence)
+      }]
+    }]
+  }];
+}
+
+function getReferencedSeriesSequence(metadata, _index, metadataProvider, DicomMetadataStore) {
+  // grab imageId from toolData
+  var imageId = metadata.referencedImageId;
+  var instance = metadataProvider.get("instance", imageId);
+  var SeriesInstanceUID = instance.SeriesInstanceUID,
+    StudyInstanceUID = instance.StudyInstanceUID;
+  var ReferencedSeriesSequence = [];
+  if (SeriesInstanceUID) {
+    var series = DicomMetadataStore.getSeries(StudyInstanceUID, SeriesInstanceUID);
+    var ReferencedSeries = {
+      SeriesInstanceUID: SeriesInstanceUID,
+      ReferencedInstanceSequence: []
+    };
+    series.instances.forEach(function (instance) {
+      var SOPInstanceUID = instance.SOPInstanceUID,
+        SOPClassUID = instance.SOPClassUID;
+      ReferencedSeries.ReferencedInstanceSequence.push({
+        ReferencedSOPClassUID: SOPClassUID,
+        ReferencedSOPInstanceUID: SOPInstanceUID
+      });
+    });
+    ReferencedSeriesSequence.push(ReferencedSeries);
+  }
+  return ReferencedSeriesSequence;
+}
+
+function getRTROIObservationsSequence(toolData, index) {
+  return {
+    ObservationNumber: index + 1,
+    ReferencedROINumber: index + 1,
+    RTROIInterpretedType: "Todo: type",
+    ROIInterpreter: "Todo: interpreter"
+  };
+}
+
+function getRTSeriesModule(DicomMetaDictionary) {
+  return {
+    SeriesInstanceUID: DicomMetaDictionary.uid(),
+    // generate a new series instance uid
+    SeriesNumber: "99" // Todo:: what should be the series number?
+  };
+}
+
+function getStructureSetModule(contour, index) {
+  var FrameOfReferenceUID = contour.metadata.FrameOfReferenceUID;
+  return {
+    ROINumber: index + 1,
+    ROIName: contour.name || "Todo: name ".concat(index + 1),
+    ROIDescription: "Todo: description ".concat(index + 1),
+    ROIGenerationAlgorithm: "Todo: algorithm",
+    ReferencedFrameOfReferenceUID: FrameOfReferenceUID
+  };
+}
+
+var DicomMetaDictionary = dcmjs__WEBPACK_IMPORTED_MODULE_0__["default"].data.DicomMetaDictionary;
+/**
+ * Convert handles to RTSS report containing the dcmjs dicom dataset.
+ *
+ * Note: current WIP and using segmentation to contour conversion,
+ * routine that is not fully tested
+ *
+ * @param segmentations - Cornerstone tool segmentations data
+ * @param metadataProvider - Metadata provider
+ * @param DicomMetadataStore - metadata store instance
+ * @param cs - cornerstone instance
+ * @param csTools - cornerstone tool instance
+ * @returns Report object containing the dataset
+ */
+function generateRTSSFromSegmentations(segmentations, metadataProvider, DicomMetadataStore, cornerstoneCache, cornerstoneToolsEnums, vtkUtils) {
+    // Convert segmentations to ROIContours
+    var roiContours = [];
+    var contourSets = generateContourSetsFromLabelmap({
+        segmentations: segmentations,
+        cornerstoneCache: cornerstoneCache,
+        cornerstoneToolsEnums: cornerstoneToolsEnums,
+        vtkUtils: vtkUtils
+    });
+    contourSets.forEach(function (contourSet, segIndex) {
+        // Check contour set isn't undefined
+        if (contourSet) {
+            var contourSequence_1 = [];
+            contourSet.sliceContours.forEach(function (sliceContour) {
+                /**
+                 * addContour - Adds a new ROI with related contours to ROIContourSequence
+                 *
+                 * @param newContour - cornerstoneTools `ROIContour` object
+                 *
+                 * newContour = {
+                 *   name: string,
+                 *   description: string,
+                 *   contourSequence: array[contour]
+                 *   color: array[number],
+                 *   metadata: {
+                 *       referencedImageId: string,
+                 *       FrameOfReferenceUID: string
+                 *     }
+                 * }
+                 *
+                 * contour = {
+                 *   ContourImageSequence: array[
+                 *       { ReferencedSOPClassUID: string, ReferencedSOPInstanceUID: string}
+                 *     ]
+                 *   ContourGeometricType: string,
+                 *   NumberOfContourPoints: number,
+                 *   ContourData: array[number]
+                 * }
+                 */
+                // Note: change needed if support non-planar contour representation is needed
+                var sopCommon = metadataProvider.get("sopCommonModule", sliceContour.referencedImageId);
+                var ReferencedSOPClassUID = sopCommon.sopClassUID;
+                var ReferencedSOPInstanceUID = sopCommon.sopInstanceUID;
+                var ContourImageSequence = [
+                    { ReferencedSOPClassUID: ReferencedSOPClassUID, ReferencedSOPInstanceUID: ReferencedSOPInstanceUID } // NOTE: replace in dcmjs?
+                ];
+                var sliceContourPolyData = sliceContour.polyData;
+                sliceContour.contours.forEach(function (contour, index) {
+                    var ContourGeometricType = contour.type;
+                    var NumberOfContourPoints = contour.contourPoints.length;
+                    var ContourData = [];
+                    contour.contourPoints.forEach(function (point) {
+                        var pointData = sliceContourPolyData.points[point];
+                        pointData[0] = +pointData[0].toFixed(2);
+                        pointData[1] = +pointData[1].toFixed(2);
+                        pointData[2] = +pointData[2].toFixed(2);
+                        ContourData.push(pointData[0]);
+                        ContourData.push(pointData[1]);
+                        ContourData.push(pointData[2]);
+                    });
+                    contourSequence_1.push({
+                        ContourImageSequence: ContourImageSequence,
+                        ContourGeometricType: ContourGeometricType,
+                        NumberOfContourPoints: NumberOfContourPoints,
+                        ContourNumber: index + 1,
+                        ContourData: ContourData
+                    });
+                });
+            });
+            var segLabel = contourSet.label || "Segment ".concat(segIndex + 1);
+            var ROIContour = {
+                name: segLabel,
+                description: segLabel,
+                contourSequence: contourSequence_1,
+                color: contourSet.color,
+                metadata: contourSet.metadata
+            };
+            roiContours.push(ROIContour);
+        }
+    });
+    var rtMetadata = {
+        name: segmentations.label,
+        label: segmentations.label
+    };
+    var dataset = _initializeDataset(rtMetadata, roiContours[0].metadata, metadataProvider);
+    roiContours.forEach(function (contour, index) {
+        var roiContour = {
+            ROIDisplayColor: contour.color || [255, 0, 0],
+            ContourSequence: contour.contourSequence,
+            ReferencedROINumber: index + 1
+        };
+        dataset.StructureSetROISequence.push(getStructureSetModule(contour, index));
+        dataset.ROIContourSequence.push(roiContour);
+        // ReferencedSeriesSequence
+        dataset.ReferencedSeriesSequence = getReferencedSeriesSequence(contour.metadata, index, metadataProvider, DicomMetadataStore);
+        // ReferencedFrameOfReferenceSequence
+        dataset.ReferencedFrameOfReferenceSequence =
+            getReferencedFrameOfReferenceSequence(contour.metadata, metadataProvider, dataset);
+    });
+    var fileMetaInformationVersionArray = new Uint8Array(2);
+    fileMetaInformationVersionArray[1] = 1;
+    var _meta = {
+        FileMetaInformationVersion: {
+            Value: [fileMetaInformationVersionArray.buffer],
+            vr: "OB"
+        },
+        TransferSyntaxUID: {
+            Value: ["1.2.840.10008.1.2.1"],
+            vr: "UI"
+        },
+        ImplementationClassUID: {
+            Value: [DicomMetaDictionary.uid()],
+            vr: "UI"
+        },
+        ImplementationVersionName: {
+            Value: ["dcmjs"],
+            vr: "SH"
+        }
+    };
+    dataset._meta = _meta;
+    return dataset;
+}
+/**
+ * Convert handles to RTSSReport report object containing the dcmjs dicom dataset.
+ *
+ * Note: The tool data needs to be formatted in a specific way, and currently
+ * it is limited to the RectangleROIStartEndTool in the Cornerstone.
+ *
+ * @param annotations Array of Cornerstone tool annotation data
+ * @param metadataProvider Metadata provider
+ * @param options report generation options
+ * @returns Report object containing the dataset
+ */
+function generateRTSSFromAnnotations(annotations, metadataProvider, DicomMetadataStore, options) {
+    var rtMetadata = {
+        name: "RTSS from Annotations",
+        label: "RTSS from Annotations"
+    };
+    var dataset = _initializeDataset(rtMetadata, annotations[0].metadata, metadataProvider);
+    annotations.forEach(function (annotation, index) {
+        var ContourSequence = AnnotationToPointData.convert(annotation, index, metadataProvider, options);
+        dataset.StructureSetROISequence.push(getStructureSetModule(annotation, index));
+        dataset.ROIContourSequence.push(ContourSequence);
+        dataset.RTROIObservationsSequence.push(getRTROIObservationsSequence(annotation, index));
+        // ReferencedSeriesSequence
+        // Todo: handle more than one series
+        dataset.ReferencedSeriesSequence = getReferencedSeriesSequence(annotation.metadata, index, metadataProvider, DicomMetadataStore);
+        // ReferencedFrameOfReferenceSequence
+        dataset.ReferencedFrameOfReferenceSequence =
+            getReferencedFrameOfReferenceSequence(annotation.metadata, metadataProvider, dataset);
+    });
+    var fileMetaInformationVersionArray = new Uint8Array(2);
+    fileMetaInformationVersionArray[1] = 1;
+    var _meta = {
+        FileMetaInformationVersion: {
+            Value: [fileMetaInformationVersionArray.buffer],
+            vr: "OB"
+        },
+        TransferSyntaxUID: {
+            Value: ["1.2.840.10008.1.2.1"],
+            vr: "UI"
+        },
+        ImplementationClassUID: {
+            Value: [DicomMetaDictionary.uid()],
+            vr: "UI"
+        },
+        ImplementationVersionName: {
+            Value: ["dcmjs"],
+            vr: "SH"
+        }
+    };
+    dataset._meta = _meta;
+    return dataset;
+}
+// /**
+//  * Generate Cornerstone tool state from dataset
+//  * @param {object} dataset dataset
+//  * @param {object} hooks
+//  * @param {function} hooks.getToolClass Function to map dataset to a tool class
+//  * @returns
+//  */
+// //static generateToolState(_dataset, _hooks = {}) {
+// function generateToolState() {
+//     // Todo
+//     console.warn("RTSS.generateToolState not implemented");
+// }
+function _initializeDataset(rtMetadata, imgMetadata, metadataProvider) {
+    var rtSOPInstanceUID = DicomMetaDictionary.uid();
+    // get the first annotation data
+    var imageId = imgMetadata.referencedImageId, FrameOfReferenceUID = imgMetadata.FrameOfReferenceUID;
+    var studyInstanceUID = metadataProvider.get("generalSeriesModule", imageId).studyInstanceUID;
+    var patientModule = getPatientModule(imageId, metadataProvider);
+    var rtSeriesModule = getRTSeriesModule(DicomMetaDictionary);
+    return __assign(__assign(__assign({ StructureSetROISequence: [], ROIContourSequence: [], RTROIObservationsSequence: [], ReferencedSeriesSequence: [], ReferencedFrameOfReferenceSequence: [] }, patientModule), rtSeriesModule), { StudyInstanceUID: studyInstanceUID, SOPClassUID: "1.2.840.10008.5.1.4.1.1.481.3", SOPInstanceUID: rtSOPInstanceUID, Manufacturer: "dcmjs", Modality: "RTSTRUCT", FrameOfReferenceUID: FrameOfReferenceUID, PositionReferenceIndicator: "", StructureSetLabel: rtMetadata.label || "", StructureSetName: rtMetadata.name || "", ReferringPhysicianName: "", OperatorsName: "", StructureSetDate: DicomMetaDictionary.date(), StructureSetTime: DicomMetaDictionary.time() });
+}
+
+var RTSS = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  generateContourSetsFromLabelmap: generateContourSetsFromLabelmap,
+  generateRTSSFromAnnotations: generateRTSSFromAnnotations,
+  generateRTSSFromSegmentations: generateRTSSFromSegmentations
+});
+
+var Cornerstone3DSR = {
     Bidirectional: Bidirectional,
     CobbAngle: CobbAngle,
     Angle: Angle,
@@ -4344,6 +5729,12 @@ var Cornerstone3D = {
     CodeScheme: CodingScheme,
     CORNERSTONE_3D_TAG: CORNERSTONE_3D_TAG
 };
+var Cornerstone3DSEG = {
+    Segmentation: Segmentation$1
+};
+var Cornerstone3DRT = {
+    RTSS: RTSS
+};
 
 var Colors = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .data */ .aT.Colors,
   BitArray = dcmjs__WEBPACK_IMPORTED_MODULE_0__/* .data */ .aT.BitArray;
@@ -4528,23 +5919,29 @@ 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
+};
+var adaptersRT = {
+    Cornerstone3D: Cornerstone3DRT
 };
 
 
-//# sourceMappingURL=adapters.es.js.map
 
 
 /***/ }),
 
-/***/ 78738:
+/***/ 27318:
 /***/ ((module) => {
 
 "use strict";
@@ -4562,7 +5959,7 @@ module.exports = iota
 
 /***/ }),
 
-/***/ 28998:
+/***/ 8516:
 /***/ ((module) => {
 
 /*!
@@ -4580,11 +5977,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")