@cornerstonejs/adapters 2.0.0-beta.5 → 2.0.0-beta.7

package/dist/adapters.es.js

@@ -2,355 +2,356 @@ import dcmjs, { data, utilities, derivations, normalizers, log } from 'dcmjs';
 import { Buffer } from 'buffer';
 import ndarray from 'ndarray';
 import { vec3 } from 'gl-matrix';
-
-function _iterableToArrayLimit(arr, i) {
-  var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
-  if (null != _i) {
-    var _s,
-      _e,
-      _x,
-      _r,
-      _arr = [],
-      _n = !0,
-      _d = !1;
+import { utilities as utilities$1 } from '@cornerstonejs/tools';
+
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = !0,
+      o = !1;
     try {
-      if (_x = (_i = _i.call(arr)).next, 0 === i) {
-        if (Object(_i) !== _i) return;
-        _n = !1;
-      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);
-    } catch (err) {
-      _d = !0, _e = err;
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = !1;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = !0, n = r;
     } finally {
       try {
-        if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return;
+        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
       } finally {
-        if (_d) throw _e;
+        if (o) throw n;
       }
     }
-    return _arr;
+    return a;
   }
 }
-function ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
+function ownKeys(e, r) {
+  var t = Object.keys(e);
   if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    enumerableOnly && (symbols = symbols.filter(function (sym) {
-      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-    })), keys.push.apply(keys, symbols);
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
   }
-  return keys;
+  return t;
 }
-function _objectSpread2(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = null != arguments[i] ? arguments[i] : {};
-    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
-      _defineProperty(target, key, source[key]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
-      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
     });
   }
-  return target;
+  return e;
 }
 function _regeneratorRuntime() {
   _regeneratorRuntime = function () {
-    return exports;
+    return e;
   };
-  var exports = {},
-    Op = Object.prototype,
-    hasOwn = Op.hasOwnProperty,
-    defineProperty = Object.defineProperty || function (obj, key, desc) {
-      obj[key] = desc.value;
+  var t,
+    e = {},
+    r = Object.prototype,
+    n = r.hasOwnProperty,
+    o = Object.defineProperty || function (t, e, r) {
+      t[e] = r.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,
+    i = "function" == typeof Symbol ? Symbol : {},
+    a = i.iterator || "@@iterator",
+    c = i.asyncIterator || "@@asyncIterator",
+    u = i.toStringTag || "@@toStringTag";
+  function define(t, e, r) {
+    return Object.defineProperty(t, e, {
+      value: r,
       enumerable: !0,
       configurable: !0,
       writable: !0
-    }), obj[key];
+    }), t[e];
   }
   try {
     define({}, "");
-  } catch (err) {
-    define = function (obj, key, value) {
-      return obj[key] = value;
+  } catch (t) {
+    define = function (t, e, r) {
+      return t[e] = r;
     };
   }
-  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 wrap(t, e, r, n) {
+    var i = e && e.prototype instanceof Generator ? e : Generator,
+      a = Object.create(i.prototype),
+      c = new Context(n || []);
+    return o(a, "_invoke", {
+      value: makeInvokeMethod(t, r, c)
+    }), a;
   }
-  function tryCatch(fn, obj, arg) {
+  function tryCatch(t, e, r) {
     try {
       return {
         type: "normal",
-        arg: fn.call(obj, arg)
+        arg: t.call(e, r)
       };
-    } catch (err) {
+    } catch (t) {
       return {
         type: "throw",
-        arg: err
+        arg: t
       };
     }
   }
-  exports.wrap = wrap;
-  var ContinueSentinel = {};
+  e.wrap = wrap;
+  var h = "suspendedStart",
+    l = "suspendedYield",
+    f = "executing",
+    s = "completed",
+    y = {};
   function Generator() {}
   function GeneratorFunction() {}
   function GeneratorFunctionPrototype() {}
-  var IteratorPrototype = {};
-  define(IteratorPrototype, iteratorSymbol, function () {
+  var p = {};
+  define(p, a, 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);
+  var d = Object.getPrototypeOf,
+    v = d && d(d(values([])));
+  v && v !== r && n.call(v, a) && (p = v);
+  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
+  function defineIteratorMethods(t) {
+    ["next", "throw", "return"].forEach(function (e) {
+      define(t, e, function (t) {
+        return this._invoke(e, t);
       });
     });
   }
-  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);
+  function AsyncIterator(t, e) {
+    function invoke(r, o, i, a) {
+      var c = tryCatch(t[r], t, o);
+      if ("throw" !== c.type) {
+        var u = c.arg,
+          h = u.value;
+        return h && "object" == typeof h && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
+          invoke("next", t, i, a);
+        }, function (t) {
+          invoke("throw", t, i, a);
+        }) : e.resolve(h).then(function (t) {
+          u.value = t, i(u);
+        }, function (t) {
+          return invoke("throw", t, i, a);
         });
       }
-      reject(record.arg);
+      a(c.arg);
     }
-    var previousPromise;
-    defineProperty(this, "_invoke", {
-      value: function (method, arg) {
+    var r;
+    o(this, "_invoke", {
+      value: function (t, n) {
         function callInvokeWithMethodAndArg() {
-          return new PromiseImpl(function (resolve, reject) {
-            invoke(method, arg, resolve, reject);
+          return new e(function (e, r) {
+            invoke(t, n, e, r);
           });
         }
-        return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+        return r = r ? r.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();
+  function makeInvokeMethod(e, r, n) {
+    var o = h;
+    return function (i, a) {
+      if (o === f) throw new Error("Generator is already running");
+      if (o === s) {
+        if ("throw" === i) throw a;
+        return {
+          value: t,
+          done: !0
+        };
       }
-      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;
+      for (n.method = i, n.arg = a;;) {
+        var c = n.delegate;
+        if (c) {
+          var u = maybeInvokeDelegate(c, n);
+          if (u) {
+            if (u === y) continue;
+            return u;
           }
         }
-        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;
+        if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
+          if (o === h) throw o = s, n.arg;
+          n.dispatchException(n.arg);
+        } else "return" === n.method && n.abrupt("return", n.arg);
+        o = f;
+        var p = tryCatch(e, r, n);
+        if ("normal" === p.type) {
+          if (o = n.done ? s : l, p.arg === y) continue;
           return {
-            value: record.arg,
-            done: context.done
+            value: p.arg,
+            done: n.done
           };
         }
-        "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
+        "throw" === p.type && (o = s, n.method = "throw", n.arg = p.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]
+  function maybeInvokeDelegate(e, r) {
+    var n = r.method,
+      o = e.iterator[n];
+    if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
+    var i = tryCatch(o, e.iterator, r.arg);
+    if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
+    var a = i.arg;
+    return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
+  }
+  function pushTryEntry(t) {
+    var e = {
+      tryLoc: t[0]
     };
-    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
+    1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
   }
-  function resetTryEntry(entry) {
-    var record = entry.completion || {};
-    record.type = "normal", delete record.arg, entry.completion = record;
+  function resetTryEntry(t) {
+    var e = t.completion || {};
+    e.type = "normal", delete e.arg, t.completion = e;
   }
-  function Context(tryLocsList) {
+  function Context(t) {
     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;
+    }], t.forEach(pushTryEntry, this), this.reset(!0);
+  }
+  function values(e) {
+    if (e || "" === e) {
+      var r = e[a];
+      if (r) return r.call(e);
+      if ("function" == typeof e.next) return e;
+      if (!isNaN(e.length)) {
+        var o = -1,
+          i = function next() {
+            for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;
+            return next.value = t, next.done = !0, next;
           };
-        return next.next = next;
+        return i.next = i;
       }
     }
-    return {
-      next: doneResult
-    };
-  }
-  function doneResult() {
-    return {
-      value: undefined,
-      done: !0
-    };
+    throw new TypeError(typeof e + " is not iterable");
   }
-  return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", {
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
     value: GeneratorFunctionPrototype,
     configurable: !0
-  }), defineProperty(GeneratorFunctionPrototype, "constructor", {
+  }), o(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) {
+  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
+    var e = "function" == typeof t && t.constructor;
+    return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
+  }, e.mark = function (t) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
+  }, e.awrap = function (t) {
     return {
-      __await: arg
+      __await: t
     };
-  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
+  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, 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();
+  }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
+    void 0 === i && (i = Promise);
+    var a = new AsyncIterator(wrap(t, r, n, o), i);
+    return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
+      return t.done ? t.value : a.next();
     });
-  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
+  }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
     return this;
-  }), define(Gp, "toString", function () {
+  }), define(g, "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;
+  }), e.keys = function (t) {
+    var e = Object(t),
+      r = [];
+    for (var n in e) r.push(n);
+    return r.reverse(), function next() {
+      for (; r.length;) {
+        var t = r.pop();
+        if (t in e) return next.value = t, next.done = !1, next;
       }
       return next.done = !0, next;
     };
-  }, exports.values = values, Context.prototype = {
+  }, e.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);
+    reset: function (e) {
+      if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
     },
     stop: function () {
       this.done = !0;
-      var rootRecord = this.tryEntries[0].completion;
-      if ("throw" === rootRecord.type) throw rootRecord.arg;
+      var t = this.tryEntries[0].completion;
+      if ("throw" === t.type) throw t.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;
+    dispatchException: function (e) {
+      if (this.done) throw e;
+      var r = this;
+      function handle(n, o) {
+        return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
       }
-      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);
+      for (var o = this.tryEntries.length - 1; o >= 0; --o) {
+        var i = this.tryEntries[o],
+          a = i.completion;
+        if ("root" === i.tryLoc) return handle("end");
+        if (i.tryLoc <= this.prev) {
+          var c = n.call(i, "catchLoc"),
+            u = n.call(i, "finallyLoc");
+          if (c && u) {
+            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
+            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
+          } else if (c) {
+            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
           } else {
-            if (!hasFinally) throw new Error("try statement without catch or finally");
-            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+            if (!u) throw new Error("try statement without catch or finally");
+            if (this.prev < i.finallyLoc) return handle(i.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;
+    abrupt: function (t, e) {
+      for (var r = this.tryEntries.length - 1; r >= 0; --r) {
+        var o = this.tryEntries[r];
+        if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
+          var i = o;
           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);
+      i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
+      var a = i ? i.completion : {};
+      return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
     },
-    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;
+    complete: function (t, e) {
+      if ("throw" === t.type) throw t.arg;
+      return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
     },
-    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;
+    finish: function (t) {
+      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+        var r = this.tryEntries[e];
+        if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
       }
     },
-    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);
+    catch: function (t) {
+      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+        var r = this.tryEntries[e];
+        if (r.tryLoc === t) {
+          var n = r.completion;
+          if ("throw" === n.type) {
+            var o = n.arg;
+            resetTryEntry(r);
           }
-          return thrown;
+          return o;
         }
       }
       throw new Error("illegal catch attempt");
     },
-    delegateYield: function (iterable, resultName, nextLoc) {
+    delegateYield: function (e, r, n) {
       return this.delegate = {
-        iterator: values(iterable),
-        resultName: resultName,
-        nextLoc: nextLoc
-      }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
+        iterator: values(e),
+        resultName: r,
+        nextLoc: n
+      }, "next" === this.method && (this.arg = t), y;
     }
-  }, exports;
+  }, e;
 }
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
@@ -773,6 +774,7 @@ var MeasurementReport$1 = /*#__PURE__*/function () {
       // Merge the derived dataset with the content from the Measurement Report
       report.dataset = Object.assign(report.dataset, contentItem);
       report.dataset._meta = _meta;
+      report.dataset.SpecificCharacterSet = "ISO_IR 192";
       return report;
     }
 
@@ -846,7 +848,7 @@ MeasurementReport$1.CORNERSTONE_TOOL_CLASSES_BY_TOOL_TYPE = {};
 
 var CORNERSTONE_4_TAG = "cornerstoneTools@^4.0.0";
 
-var TID300Length$1 = utilities.TID300.Length;
+var TID300Length$2 = utilities.TID300.Length;
 var LENGTH$1 = "Length";
 var Length$1 = /*#__PURE__*/function () {
   function Length() {
@@ -907,7 +909,7 @@ var Length$1 = /*#__PURE__*/function () {
 }();
 Length$1.toolType = LENGTH$1;
 Length$1.utilityToolType = LENGTH$1;
-Length$1.TID300Representation = TID300Length$1;
+Length$1.TID300Representation = TID300Length$2;
 Length$1.isValidCornerstoneTrackingIdentifier = function (TrackingIdentifier) {
   if (!TrackingIdentifier.includes(":")) {
     return false;
@@ -2385,6 +2387,7 @@ function fillSegmentation$1(segmentation, inputLabelmaps3D) {
       Value: ["1.2.840.10008.1.2.5"],
       vr: "UI"
     };
+    segmentation.dataset.SpecificCharacterSet = "ISO_IR 192";
     segmentation.dataset._vrMap.PixelData = "OB";
     segmentation.dataset.PixelData = rleEncodedFrames;
   } else {
@@ -2418,6 +2421,7 @@ function _createSegFromImages(images, isMultiframe, options) {
     var dicomData = DicomMessage.readFile(arrayBuffer);
     var dataset = DicomMetaDictionary$2.naturalizeDataset(dicomData.dict);
     dataset._meta = DicomMetaDictionary$2.namifyDataset(dicomData.meta);
+    dataset.SpecificCharacterSet = "ISO_IR 192";
     datasets.push(dataset);
   } else {
     for (var i = 0; i < images.length; i++) {
@@ -2426,6 +2430,7 @@ function _createSegFromImages(images, isMultiframe, options) {
       var _dicomData = DicomMessage.readFile(_arrayBuffer);
       var _dataset = DicomMetaDictionary$2.naturalizeDataset(_dicomData.dict);
       _dataset._meta = DicomMetaDictionary$2.namifyDataset(_dicomData.meta);
+      _dataset.SpecificCharacterSet = "ISO_IR 192";
       datasets.push(_dataset);
     }
   }
@@ -2603,7 +2608,7 @@ function generateToolState$2(_x, _x2, _x3, _x4) {
  */
 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;
+    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, overlappingSegments, centroidXYZ;
     return _regeneratorRuntime().wrap(function _callee$(_context) {
       while (1) switch (_context.prev = _context.next) {
         case 0:
@@ -2655,8 +2660,8 @@ function _generateToolState() {
           // and over again.
           sopUIDImageIdIndexMap = imageIds.reduce(function (acc, imageId) {
             var _metadataProvider$get = metadataProvider.get("generalImageModule", imageId),
-              sopInstanceUid = _metadataProvider$get.sopInstanceUid;
-            acc[sopInstanceUid] = imageId;
+              sopInstanceUID = _metadataProvider$get.sopInstanceUID;
+            acc[sopInstanceUID] = imageId;
             return acc;
           }, {});
           overlapping = false;
@@ -2690,7 +2695,7 @@ function _generateToolState() {
           labelmapBufferArray = [];
           labelmapBufferArray[0] = new ArrayBuffer(arrayBufferLength);
 
-          // Precompute the indices and metadata so that we don't have to call
+          // Pre-compute 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;
@@ -2707,6 +2712,7 @@ function _generateToolState() {
           _context.next = 47;
           return insertFunction(segmentsOnFrame, segmentsOnFrameArray, labelmapBufferArray, pixelDataChunks, multiframe, imageIds, validOrientations, metadataProvider, tolerance, TypedArrayConstructor, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps, eventTarget, triggerEvent);
         case 47:
+          overlappingSegments = _context.sent;
           // calculate the centroid of each segment
           centroidXYZ = new Map();
           segmentsPixelIndices.forEach(function (imageIdIndexBufferIndex, segmentIndex) {
@@ -2726,9 +2732,10 @@ function _generateToolState() {
             segMetadata: segMetadata,
             segmentsOnFrame: segmentsOnFrame,
             segmentsOnFrameArray: segmentsOnFrameArray,
-            centroids: centroidXYZ
+            centroids: centroidXYZ,
+            overlappingSegments: overlappingSegments
           });
-        case 50:
+        case 51:
         case "end":
           return _context.stop();
       }
@@ -2753,9 +2760,7 @@ function findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadata
     return imageId;
   }
   var frameSourceImageSequence = undefined;
-  if (SourceImageSequence && SourceImageSequence.length !== 0) {
-    frameSourceImageSequence = SourceImageSequence[frameSegment];
-  } else if (PerFrameFunctionalGroup.DerivationImageSequence) {
+  if (PerFrameFunctionalGroup.DerivationImageSequence) {
     var DerivationImageSequence = PerFrameFunctionalGroup.DerivationImageSequence;
     if (Array.isArray(DerivationImageSequence)) {
       if (DerivationImageSequence.length !== 0) {
@@ -2774,6 +2779,9 @@ function findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadata
         }
       }
     }
+  } else if (SourceImageSequence && SourceImageSequence.length !== 0) {
+    console.warn("DerivationImageSequence not present, using SourceImageSequence assuming SEG has the same geometry as the source image.");
+    frameSourceImageSequence = SourceImageSequence[frameSegment];
   }
   if (frameSourceImageSequence) {
     imageId = getImageIdOfSourceImageBySourceImageSequence(frameSourceImageSequence, sopUIDImageIdIndexMap);
@@ -2813,32 +2821,33 @@ function checkSEGsOverlapping(pixelData, multiframe, imageIds, validOrientations
 
   var frameSegmentsMapping = new Map();
   var _loop3 = function _loop3() {
-    var segmentIndex = getSegmentIndex(multiframe, frameSegment);
-    if (segmentIndex === undefined) {
-      console.warn("Could not retrieve the segment index for frame segment " + frameSegment + ", skipping this frame.");
-      return "continue";
-    }
-    var imageId = findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
-    if (!imageId) {
-      console.warn("Image not present in stack, can't import frame : " + frameSegment + ".");
-      return "continue";
-    }
-    var imageIdIndex = imageIds.findIndex(function (element) {
-      return element === imageId;
-    });
-    if (frameSegmentsMapping.has(imageIdIndex)) {
-      var segmentArray = frameSegmentsMapping.get(imageIdIndex);
-      if (!segmentArray.includes(frameSegment)) {
-        segmentArray.push(frameSegment);
-        frameSegmentsMapping.set(imageIdIndex, segmentArray);
+      var segmentIndex = getSegmentIndex(multiframe, frameSegment);
+      if (segmentIndex === undefined) {
+        console.warn("Could not retrieve the segment index for frame segment " + frameSegment + ", skipping this frame.");
+        return 0; // continue
       }
-    } else {
-      frameSegmentsMapping.set(imageIdIndex, [frameSegment]);
-    }
-  };
+      var imageId = findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
+      if (!imageId) {
+        console.warn("Image not present in stack, can't import frame : " + frameSegment + ".");
+        return 0; // continue
+      }
+      var imageIdIndex = imageIds.findIndex(function (element) {
+        return element === imageId;
+      });
+      if (frameSegmentsMapping.has(imageIdIndex)) {
+        var segmentArray = frameSegmentsMapping.get(imageIdIndex);
+        if (!segmentArray.includes(frameSegment)) {
+          segmentArray.push(frameSegment);
+          frameSegmentsMapping.set(imageIdIndex, segmentArray);
+        }
+      } else {
+        frameSegmentsMapping.set(imageIdIndex, [frameSegment]);
+      }
+    },
+    _ret;
   for (var frameSegment = 0; frameSegment < groupsLen; ++frameSegment) {
-    var _ret = _loop3();
-    if (_ret === "continue") continue;
+    _ret = _loop3();
+    if (_ret === 0) continue;
   }
   var _iterator = _createForOfIteratorHelper(frameSegmentsMapping.entries()),
     _step;
@@ -2906,77 +2915,78 @@ function insertOverlappingPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray,
   var numberOfSegs = multiframe.SegmentSequence.length;
   for (var segmentIndexToProcess = 1; segmentIndexToProcess <= numberOfSegs; ++segmentIndexToProcess) {
     var _loop4 = function _loop4(_i2) {
-      var PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[_i2];
-      var segmentIndex = getSegmentIndex(multiframe, _i2);
-      if (segmentIndex === undefined) {
-        throw new Error("Could not retrieve the segment index. Aborting segmentation loading.");
-      }
-      if (segmentIndex !== segmentIndexToProcess) {
-        i = _i2;
-        return "continue";
-      }
-      var ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
-
-      // Since we moved to the chunks approach, we need to read the data
-      // and handle scenarios where the portion of data is in one chunk
-      // and the other portion is in another chunk
-      var view = readFromUnpackedChunks(pixelData, _i2 * sliceLength, sliceLength);
-      var pixelDataI2D = ndarray(view, [Rows, Columns]);
-      var alignedPixelDataI = alignPixelDataWithSourceData(pixelDataI2D, ImageOrientationPatientI, validOrientations, tolerance);
-      if (!alignedPixelDataI) {
-        throw new Error("Individual SEG frames are out of plane with respect to the first SEG frame. " + "This is not yet supported. Aborting segmentation loading.");
-      }
-      var imageId = findReferenceSourceImageId(multiframe, _i2, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
-      if (!imageId) {
-        console.warn("Image not present in stack, can't import frame : " + _i2 + ".");
-        i = _i2;
-        return "continue";
-      }
-      var sourceImageMetadata = metadataProvider.get("instance", imageId);
-      if (Rows !== sourceImageMetadata.Rows || Columns !== sourceImageMetadata.Columns) {
-        throw new Error("Individual SEG frames have different geometry dimensions (Rows and Columns) " + "respect to the source image reference frame. This is not yet supported. " + "Aborting segmentation loading. ");
-      }
-      var imageIdIndex = imageIds.findIndex(function (element) {
-        return element === imageId;
-      });
-      var byteOffset = sliceLength * imageIdIndex * TypedArrayConstructor.BYTES_PER_ELEMENT;
-      var labelmap2DView = new TypedArrayConstructor(tempBuffer, byteOffset, sliceLength);
-      var data = alignedPixelDataI.data;
-      var segmentOnFrame = false;
-      for (var j = 0, len = alignedPixelDataI.data.length; j < len; ++j) {
-        if (data[j]) {
-          if (labelmap2DView[j] !== 0) {
-            m++;
-            if (m >= M) {
-              labelmapBufferArray[m] = new ArrayBuffer(arrayBufferLength);
-              segmentsOnFrameArray[m] = [];
-              M++;
+        var PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[_i2];
+        var segmentIndex = getSegmentIndex(multiframe, _i2);
+        if (segmentIndex === undefined) {
+          throw new Error("Could not retrieve the segment index. Aborting segmentation loading.");
+        }
+        if (segmentIndex !== segmentIndexToProcess) {
+          i = _i2;
+          return 0; // continue
+        }
+        var ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
+
+        // Since we moved to the chunks approach, we need to read the data
+        // and handle scenarios where the portion of data is in one chunk
+        // and the other portion is in another chunk
+        var view = readFromUnpackedChunks(pixelData, _i2 * sliceLength, sliceLength);
+        var pixelDataI2D = ndarray(view, [Rows, Columns]);
+        var alignedPixelDataI = alignPixelDataWithSourceData(pixelDataI2D, ImageOrientationPatientI, validOrientations, tolerance);
+        if (!alignedPixelDataI) {
+          throw new Error("Individual SEG frames are out of plane with respect to the first SEG frame. " + "This is not yet supported. Aborting segmentation loading.");
+        }
+        var imageId = findReferenceSourceImageId(multiframe, _i2, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
+        if (!imageId) {
+          console.warn("Image not present in stack, can't import frame : " + _i2 + ".");
+          i = _i2;
+          return 0; // continue
+        }
+        var sourceImageMetadata = metadataProvider.get("instance", imageId);
+        if (Rows !== sourceImageMetadata.Rows || Columns !== sourceImageMetadata.Columns) {
+          throw new Error("Individual SEG frames have different geometry dimensions (Rows and Columns) " + "respect to the source image reference frame. This is not yet supported. " + "Aborting segmentation loading. ");
+        }
+        var imageIdIndex = imageIds.findIndex(function (element) {
+          return element === imageId;
+        });
+        var byteOffset = sliceLength * imageIdIndex * TypedArrayConstructor.BYTES_PER_ELEMENT;
+        var labelmap2DView = new TypedArrayConstructor(tempBuffer, byteOffset, sliceLength);
+        var data = alignedPixelDataI.data;
+        var segmentOnFrame = false;
+        for (var j = 0, len = alignedPixelDataI.data.length; j < len; ++j) {
+          if (data[j]) {
+            if (labelmap2DView[j] !== 0) {
+              m++;
+              if (m >= M) {
+                labelmapBufferArray[m] = new ArrayBuffer(arrayBufferLength);
+                segmentsOnFrameArray[m] = [];
+                M++;
+              }
+              tempBuffer = labelmapBufferArray[m].slice(0);
+              tempSegmentsOnFrame = structuredClone(segmentsOnFrameArray[m]);
+              _i2 = 0;
+              break;
+            } else {
+              labelmap2DView[j] = segmentIndex;
+              segmentOnFrame = true;
             }
-            tempBuffer = labelmapBufferArray[m].slice(0);
-            tempSegmentsOnFrame = structuredClone(segmentsOnFrameArray[m]);
-            _i2 = 0;
-            break;
-          } else {
-            labelmap2DView[j] = segmentIndex;
-            segmentOnFrame = true;
           }
         }
-      }
-      if (segmentOnFrame) {
-        if (!tempSegmentsOnFrame[imageIdIndex]) {
-          tempSegmentsOnFrame[imageIdIndex] = [];
-        }
-        tempSegmentsOnFrame[imageIdIndex].push(segmentIndex);
-        if (!segmentsOnFrame[imageIdIndex]) {
-          segmentsOnFrame[imageIdIndex] = [];
+        if (segmentOnFrame) {
+          if (!tempSegmentsOnFrame[imageIdIndex]) {
+            tempSegmentsOnFrame[imageIdIndex] = [];
+          }
+          tempSegmentsOnFrame[imageIdIndex].push(segmentIndex);
+          if (!segmentsOnFrame[imageIdIndex]) {
+            segmentsOnFrame[imageIdIndex] = [];
+          }
+          segmentsOnFrame[imageIdIndex].push(segmentIndex);
         }
-        segmentsOnFrame[imageIdIndex].push(segmentIndex);
-      }
-      i = _i2;
-    };
+        i = _i2;
+      },
+      _ret2;
     for (var i = 0, groupsLen = PerFrameFunctionalGroupsSequence.length; i < groupsLen; ++i) {
-      var _ret2 = _loop4(i);
-      if (_ret2 === "continue") continue;
+      _ret2 = _loop4(i);
+      if (_ret2 === 0) continue;
     }
     labelmapBufferArray[m] = tempBuffer.slice(0);
     segmentsOnFrameArray[m] = structuredClone(tempSegmentsOnFrame);
@@ -3005,7 +3015,7 @@ function insertPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray, labelmapBu
   var chunkSize = Math.ceil(groupsLen / 10); // 10% of total length
 
   var shouldTriggerEvent = triggerEvent && eventTarget;
-
+  var overlapping = false;
   // Below, we chunk the processing of the frames to avoid blocking the main thread
   // if the segmentation is large. We also use a promise to allow the caller to
   // wait for the processing to finish.
@@ -3046,6 +3056,9 @@ function insertPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray, labelmapBu
           if (data[j]) {
             for (var x = j; x < len; ++x) {
               if (data[x]) {
+                if (!overlapping && labelmap2DView[x] !== 0) {
+                  overlapping = true;
+                }
                 labelmap2DView[x] = segmentIndex;
                 indexCache.push(x);
               }
@@ -3075,7 +3088,7 @@ function insertPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray, labelmapBu
         setTimeout(processInChunks, 0);
       } else {
         // resolve the Promise when all chunks have been processed
-        resolve();
+        resolve(overlapping);
       }
     }
     processInChunks();
@@ -3546,6 +3559,8 @@ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
 var __assign = function () {
   __assign = Object.assign || function __assign(t) {
     for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -3565,6 +3580,10 @@ function __spreadArray(to, from, pack) {
   }
   return to.concat(ar || Array.prototype.slice.call(from));
 }
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
 
 var CORNERSTONE_3D_TAG = "Cornerstone3DTools@^0.1.0";
 
@@ -3773,6 +3792,7 @@ var MeasurementReport = /** @class */ (function () {
         // Merge the derived dataset with the content from the Measurement Report
         report.dataset = Object.assign(report.dataset, contentItem);
         report.dataset._meta = _meta;
+        report.SpecificCharacterSet = "ISO_IR 192";
         return report;
     };
     /**
@@ -3786,6 +3806,7 @@ var MeasurementReport = /** @class */ (function () {
         var REPORT = "Imaging Measurements";
         var GROUP = "Measurement Group";
         var TRACKING_IDENTIFIER = "Tracking Identifier";
+        var TRACKING_UNIQUE_IDENTIFIER = "Tracking Unique Identifier";
         // Identify the Imaging Measurements
         var imagingMeasurementContent = toArray(dataset.ContentSequence).find(codeMeaningEquals(REPORT));
         // Retrieve the Measurements themselves
@@ -3807,12 +3828,19 @@ var MeasurementReport = /** @class */ (function () {
                         TRACKING_IDENTIFIER;
                 });
                 var TrackingIdentifierValue_1 = TrackingIdentifierGroup.TextValue;
+                var TrackingUniqueIdentifierGroup = measurementGroupContentSequence.find(function (contentItem) {
+                    return contentItem.ConceptNameCodeSequence.CodeMeaning ===
+                        TRACKING_UNIQUE_IDENTIFIER;
+                });
+                var TrackingUniqueIdentifierValue = TrackingUniqueIdentifierGroup === null || TrackingUniqueIdentifierGroup === void 0 ? void 0 : TrackingUniqueIdentifierGroup.UID;
                 var toolClass = ((_a = hooks === null || hooks === void 0 ? void 0 : hooks.getToolClass) === null || _a === void 0 ? void 0 : _a.call(hooks, measurementGroup, dataset, registeredToolClasses)) ||
                     registeredToolClasses.find(function (tc) {
                         return tc.isValidCornerstoneTrackingIdentifier(TrackingIdentifierValue_1);
                     });
                 if (toolClass) {
                     var measurement = toolClass.getMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata);
+                    measurement.TrackingUniqueIdentifier =
+                        TrackingUniqueIdentifierValue;
                     console.log("=== ".concat(toolClass.toolType, " ==="));
                     console.log(measurement);
                     measurementData[toolClass.toolType].push(measurement);
@@ -3853,7 +3881,7 @@ var MeasurementReport = /** @class */ (function () {
 
 var TID300Point$1 = utilities.TID300.Point;
 var ARROW_ANNOTATE = "ArrowAnnotate";
-var trackingIdentifierTextValue$7 = "".concat(CORNERSTONE_3D_TAG, ":").concat(ARROW_ANNOTATE);
+var trackingIdentifierTextValue$8 = "".concat(CORNERSTONE_3D_TAG, ":").concat(ARROW_ANNOTATE);
 var codeValues = CodingScheme.codeValues,
   CodingSchemeDesignator = CodingScheme.CodingSchemeDesignator;
 var ArrowAnnotate = /*#__PURE__*/function () {
@@ -3932,7 +3960,7 @@ var ArrowAnnotate = /*#__PURE__*/function () {
           x: pointImage[0],
           y: pointImage[1]
         }],
-        trackingIdentifierTextValue: trackingIdentifierTextValue$7,
+        trackingIdentifierTextValue: trackingIdentifierTextValue$8,
         findingSites: findingSites || []
       };
 
@@ -3972,7 +4000,7 @@ var TID300Bidirectional = utilities.TID300.Bidirectional;
 var BIDIRECTIONAL = "Bidirectional";
 var LONG_AXIS = "Long Axis";
 var SHORT_AXIS = "Short Axis";
-var trackingIdentifierTextValue$6 = "".concat(CORNERSTONE_3D_TAG, ":").concat(BIDIRECTIONAL);
+var trackingIdentifierTextValue$7 = "".concat(CORNERSTONE_3D_TAG, ":").concat(BIDIRECTIONAL);
 var Bidirectional = /** @class */ (function () {
     function Bidirectional() {
     }
@@ -4075,7 +4103,7 @@ var Bidirectional = /** @class */ (function () {
             },
             longAxisLength: length,
             shortAxisLength: width,
-            trackingIdentifierTextValue: trackingIdentifierTextValue$6,
+            trackingIdentifierTextValue: trackingIdentifierTextValue$7,
             finding: finding,
             findingSites: findingSites || []
         };
@@ -4099,7 +4127,7 @@ MeasurementReport.registerTool(Bidirectional);
 
 var TID300CobbAngle$1 = utilities.TID300.CobbAngle;
 var MEASUREMENT_TYPE$1 = "Angle";
-var trackingIdentifierTextValue$5 = "".concat(CORNERSTONE_3D_TAG, ":").concat(MEASUREMENT_TYPE$1);
+var trackingIdentifierTextValue$6 = "".concat(CORNERSTONE_3D_TAG, ":").concat(MEASUREMENT_TYPE$1);
 var Angle = /** @class */ (function () {
     function Angle() {
     }
@@ -4159,7 +4187,7 @@ var Angle = /** @class */ (function () {
             point3: point3,
             point4: point4,
             rAngle: angle,
-            trackingIdentifierTextValue: trackingIdentifierTextValue$5,
+            trackingIdentifierTextValue: trackingIdentifierTextValue$6,
             finding: finding,
             findingSites: findingSites || []
         };
@@ -4183,7 +4211,7 @@ MeasurementReport.registerTool(Angle);
 
 var TID300CobbAngle = utilities.TID300.CobbAngle;
 var MEASUREMENT_TYPE = "CobbAngle";
-var trackingIdentifierTextValue$4 = "".concat(CORNERSTONE_3D_TAG, ":").concat(MEASUREMENT_TYPE);
+var trackingIdentifierTextValue$5 = "".concat(CORNERSTONE_3D_TAG, ":").concat(MEASUREMENT_TYPE);
 var CobbAngle = /** @class */ (function () {
     function CobbAngle() {
     }
@@ -4248,7 +4276,7 @@ var CobbAngle = /** @class */ (function () {
             point3: point3,
             point4: point4,
             rAngle: angle,
-            trackingIdentifierTextValue: trackingIdentifierTextValue$4,
+            trackingIdentifierTextValue: trackingIdentifierTextValue$5,
             finding: finding,
             findingSites: findingSites || []
         };
@@ -4512,7 +4540,7 @@ MeasurementReport.registerTool(EllipticalROI);
 
 var TID300Polyline$1 = utilities.TID300.Polyline;
 var TOOLTYPE = "RectangleROI";
-var trackingIdentifierTextValue$3 = "".concat(CORNERSTONE_3D_TAG, ":").concat(TOOLTYPE);
+var trackingIdentifierTextValue$4 = "".concat(CORNERSTONE_3D_TAG, ":").concat(TOOLTYPE);
 var RectangleROI = /** @class */ (function () {
     function RectangleROI() {
     }
@@ -4575,7 +4603,7 @@ var RectangleROI = /** @class */ (function () {
             ],
             area: area,
             perimeter: perimeter,
-            trackingIdentifierTextValue: trackingIdentifierTextValue$3,
+            trackingIdentifierTextValue: trackingIdentifierTextValue$4,
             finding: finding,
             findingSites: findingSites || []
         };
@@ -4597,9 +4625,9 @@ var RectangleROI = /** @class */ (function () {
 }());
 MeasurementReport.registerTool(RectangleROI);
 
-var TID300Length = utilities.TID300.Length;
+var TID300Length$1 = utilities.TID300.Length;
 var LENGTH = "Length";
-var trackingIdentifierTextValue$2 = "".concat(CORNERSTONE_3D_TAG, ":").concat(LENGTH);
+var trackingIdentifierTextValue$3 = "".concat(CORNERSTONE_3D_TAG, ":").concat(LENGTH);
 var Length = /*#__PURE__*/function () {
   function Length() {
     _classCallCheck(this, Length);
@@ -4667,7 +4695,7 @@ var Length = /*#__PURE__*/function () {
         point1: point1,
         point2: point2,
         distance: distance,
-        trackingIdentifierTextValue: trackingIdentifierTextValue$2,
+        trackingIdentifierTextValue: trackingIdentifierTextValue$3,
         finding: finding,
         findingSites: findingSites || []
       };
@@ -4677,7 +4705,7 @@ var Length = /*#__PURE__*/function () {
 }();
 Length.toolType = LENGTH;
 Length.utilityToolType = LENGTH;
-Length.TID300Representation = TID300Length;
+Length.TID300Representation = TID300Length$1;
 Length.isValidCornerstoneTrackingIdentifier = function (TrackingIdentifier) {
   if (!TrackingIdentifier.includes(":")) {
     return false;
@@ -4695,13 +4723,14 @@ MeasurementReport.registerTool(Length);
 
 var TID300Polyline = utilities.TID300.Polyline;
 var PLANARFREEHANDROI = "PlanarFreehandROI";
-var trackingIdentifierTextValue$1 = "".concat(CORNERSTONE_3D_TAG, ":").concat(PLANARFREEHANDROI);
+var trackingIdentifierTextValue$2 = "".concat(CORNERSTONE_3D_TAG, ":").concat(PLANARFREEHANDROI);
 var closedContourThreshold = 1e-5;
 var PlanarFreehandROI = /** @class */ (function () {
     function PlanarFreehandROI() {
     }
     PlanarFreehandROI.getMeasurementData = function (MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
-        var _a = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, PlanarFreehandROI.toolType), defaultState = _a.defaultState, SCOORDGroup = _a.SCOORDGroup, ReferencedFrameNumber = _a.ReferencedFrameNumber;
+        var _a;
+        var _b = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, PlanarFreehandROI.toolType), defaultState = _b.defaultState, NUMGroup = _b.NUMGroup, SCOORDGroup = _b.SCOORDGroup, ReferencedFrameNumber = _b.ReferencedFrameNumber;
         var referencedImageId = defaultState.annotation.metadata.referencedImageId;
         var GraphicData = SCOORDGroup.GraphicData;
         var worldCoords = [];
@@ -4725,8 +4754,7 @@ var PlanarFreehandROI = /** @class */ (function () {
         }
         var state = defaultState;
         state.annotation.data = {
-            polyline: worldCoords,
-            isOpenContour: isOpenContour,
+            contour: { polyline: worldCoords, closed: !isOpenContour },
             handles: {
                 points: points,
                 activeHandleIndex: null,
@@ -4734,13 +4762,21 @@ var PlanarFreehandROI = /** @class */ (function () {
                     hasMoved: false
                 }
             },
+            cachedStats: (_a = {},
+                _a["imageId:".concat(referencedImageId)] = {
+                    area: NUMGroup
+                        ? NUMGroup.MeasuredValueSequence.NumericValue
+                        : null
+                },
+                _a),
             frameNumber: ReferencedFrameNumber
         };
         return state;
     };
     PlanarFreehandROI.getTID300RepresentationArguments = function (tool, worldToImageCoords) {
         var data = tool.data, finding = tool.finding, findingSites = tool.findingSites, metadata = tool.metadata;
-        var isOpenContour = data.isOpenContour, polyline = data.polyline;
+        var _a = data.contour, polyline = _a.polyline, closed = _a.closed;
+        var isOpenContour = closed !== true;
         var referencedImageId = metadata.referencedImageId;
         if (!referencedImageId) {
             throw new Error("PlanarFreehandROI.getTID300RepresentationArguments: referencedImageId is not defined");
@@ -4754,13 +4790,19 @@ var PlanarFreehandROI = /** @class */ (function () {
             // Explicitly expand to avoid ciruclar references.
             points.push([firstPoint[0], firstPoint[1]]);
         }
-        var area = 0; // TODO -> The tool doesn't have these stats yet.
-        var perimeter = 0;
+        var _b = data.cachedStats["imageId:".concat(referencedImageId)] || {}, area = _b.area, areaUnit = _b.areaUnit, modalityUnit = _b.modalityUnit, perimeter = _b.perimeter, mean = _b.mean, max = _b.max, stdDev = _b.stdDev;
         return {
+            /** From cachedStats */
             points: points,
             area: area,
+            areaUnit: areaUnit,
             perimeter: perimeter,
-            trackingIdentifierTextValue: trackingIdentifierTextValue$1,
+            modalityUnit: modalityUnit,
+            mean: mean,
+            max: max,
+            stdDev: stdDev,
+            /** Other */
+            trackingIdentifierTextValue: trackingIdentifierTextValue$2,
             finding: finding,
             findingSites: findingSites || []
         };
@@ -4784,7 +4826,7 @@ MeasurementReport.registerTool(PlanarFreehandROI);
 
 var TID300Point = utilities.TID300.Point;
 var PROBE = "Probe";
-var trackingIdentifierTextValue = "".concat(CORNERSTONE_3D_TAG, ":").concat(PROBE);
+var trackingIdentifierTextValue$1 = "".concat(CORNERSTONE_3D_TAG, ":").concat(PROBE);
 var Probe = /*#__PURE__*/function () {
   function Probe() {
     _classCallCheck(this, Probe);
@@ -4837,7 +4879,7 @@ var Probe = /*#__PURE__*/function () {
       });
       var TID300RepresentationArguments = {
         points: pointsImage,
-        trackingIdentifierTextValue: trackingIdentifierTextValue,
+        trackingIdentifierTextValue: trackingIdentifierTextValue$1,
         findingSites: findingSites || [],
         finding: finding
       };
@@ -4864,6 +4906,75 @@ Probe.isValidCornerstoneTrackingIdentifier = function (TrackingIdentifier) {
 };
 MeasurementReport.registerTool(Probe);
 
+var TID300Length = utilities.TID300.Length;
+var ULTRASOUND_DIRECTIONAL = "UltrasoundDirectionalTool";
+var trackingIdentifierTextValue = "".concat(CORNERSTONE_3D_TAG, ":").concat(ULTRASOUND_DIRECTIONAL);
+var UltrasoundDirectional = /** @class */ (function () {
+    function UltrasoundDirectional() {
+    }
+    // TODO: this function is required for all Cornerstone Tool Adapters, since it is called by MeasurementReport.
+    UltrasoundDirectional.getMeasurementData = function (MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+        var _a = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, UltrasoundDirectional.toolType), defaultState = _a.defaultState, SCOORDGroup = _a.SCOORDGroup, ReferencedFrameNumber = _a.ReferencedFrameNumber;
+        var referencedImageId = defaultState.annotation.metadata.referencedImageId;
+        var GraphicData = SCOORDGroup.GraphicData;
+        var worldCoords = [];
+        for (var i = 0; i < GraphicData.length; i += 2) {
+            var point = imageToWorldCoords(referencedImageId, [
+                GraphicData[i],
+                GraphicData[i + 1]
+            ]);
+            worldCoords.push(point);
+        }
+        var state = defaultState;
+        state.annotation.data = {
+            handles: {
+                points: [worldCoords[0], worldCoords[1]],
+                activeHandleIndex: 0,
+                textBox: {
+                    hasMoved: false
+                }
+            },
+            cachedStats: {},
+            frameNumber: ReferencedFrameNumber
+        };
+        return state;
+    };
+    UltrasoundDirectional.getTID300RepresentationArguments = function (tool, worldToImageCoords) {
+        var data = tool.data, finding = tool.finding, findingSites = tool.findingSites, metadata = tool.metadata;
+        var handles = data.handles;
+        var referencedImageId = metadata.referencedImageId;
+        if (!referencedImageId) {
+            throw new Error("UltrasoundDirectionalTool.getTID300RepresentationArguments: referencedImageId is not defined");
+        }
+        var start = worldToImageCoords(referencedImageId, handles.points[0]);
+        var end = worldToImageCoords(referencedImageId, handles.points[1]);
+        var point1 = { x: start[0], y: start[1] };
+        var point2 = { x: end[0], y: end[1] };
+        return {
+            point1: point1,
+            point2: point2,
+            trackingIdentifierTextValue: trackingIdentifierTextValue,
+            finding: finding,
+            findingSites: findingSites || []
+        };
+    };
+    UltrasoundDirectional.toolType = ULTRASOUND_DIRECTIONAL;
+    UltrasoundDirectional.utilityToolType = ULTRASOUND_DIRECTIONAL;
+    UltrasoundDirectional.TID300Representation = TID300Length;
+    UltrasoundDirectional.isValidCornerstoneTrackingIdentifier = function (TrackingIdentifier) {
+        if (!TrackingIdentifier.includes(":")) {
+            return false;
+        }
+        var _a = TrackingIdentifier.split(":"), cornerstone3DTag = _a[0], toolType = _a[1];
+        if (cornerstone3DTag !== CORNERSTONE_3D_TAG) {
+            return false;
+        }
+        return toolType === ULTRASOUND_DIRECTIONAL;
+    };
+    return UltrasoundDirectional;
+}());
+MeasurementReport.registerTool(UltrasoundDirectional);
+
 var Normalizer = normalizers.Normalizer;
 var SegmentationDerivation = derivations.Segmentation;
 /**
@@ -4973,415 +5084,6 @@ var Segmentation$1 = /*#__PURE__*/Object.freeze({
   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);
@@ -5476,6 +5178,7 @@ function getStructureSetModule(contour, index) {
   };
 }
 
+var _a = utilities$1.contours, generateContourSetsFromLabelmap$1 = _a.generateContourSetsFromLabelmap, AnnotationToPointData = _a.AnnotationToPointData;
 var DicomMetaDictionary = dcmjs.data.DicomMetaDictionary;
 /**
  * Convert handles to RTSS report containing the dcmjs dicom dataset.
@@ -5490,14 +5193,11 @@ var DicomMetaDictionary = dcmjs.data.DicomMetaDictionary;
  * @param csTools - cornerstone tool instance
  * @returns Report object containing the dataset
  */
-function generateRTSSFromSegmentations(segmentations, metadataProvider, DicomMetadataStore, cornerstoneCache, cornerstoneToolsEnums, vtkUtils) {
+function generateRTSSFromSegmentations(segmentations, metadataProvider, DicomMetadataStore) {
     // Convert segmentations to ROIContours
     var roiContours = [];
-    var contourSets = generateContourSetsFromLabelmap({
-        segmentations: segmentations,
-        cornerstoneCache: cornerstoneCache,
-        cornerstoneToolsEnums: cornerstoneToolsEnums,
-        vtkUtils: vtkUtils
+    var contourSets = generateContourSetsFromLabelmap$1({
+        segmentations: segmentations
     });
     contourSets.forEach(function (contourSet, segIndex) {
         // Check contour set isn't undefined
@@ -5610,6 +5310,7 @@ function generateRTSSFromSegmentations(segmentations, metadataProvider, DicomMet
         }
     };
     dataset._meta = _meta;
+    dataset.SpecificCharacterSet = "ISO_IR 192";
     return dataset;
 }
 /**
@@ -5618,19 +5319,18 @@ function generateRTSSFromSegmentations(segmentations, metadataProvider, DicomMet
  * 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
+ * @param annotations - Array of Cornerstone tool annotation data
+ * @param metadataProvider -  Metadata provider
  * @returns Report object containing the dataset
  */
-function generateRTSSFromAnnotations(annotations, metadataProvider, DicomMetadataStore, options) {
+function generateRTSSFromAnnotations(annotations, metadataProvider, DicomMetadataStore) {
     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);
+        var ContourSequence = AnnotationToPointData.convert(annotation, index, metadataProvider);
         dataset.StructureSetROISequence.push(getStructureSetModule(annotation, index));
         dataset.ROIContourSequence.push(ContourSequence);
         dataset.RTROIObservationsSequence.push(getRTROIObservationsSequence(annotation, index));
@@ -5662,6 +5362,7 @@ function generateRTSSFromAnnotations(annotations, metadataProvider, DicomMetadat
         }
     };
     dataset._meta = _meta;
+    dataset.SpecificCharacterSet = "ISO_IR 192";
     return dataset;
 }
 // /**
@@ -5683,9 +5384,11 @@ function _initializeDataset(rtMetadata, imgMetadata, metadataProvider) {
     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() });
+    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(), _meta: null });
 }
 
+var generateContourSetsFromLabelmap = utilities$1.contours.generateContourSetsFromLabelmap;
+
 var RTSS = /*#__PURE__*/Object.freeze({
   __proto__: null,
   generateContourSetsFromLabelmap: generateContourSetsFromLabelmap,
@@ -5704,6 +5407,7 @@ var Cornerstone3DSR = {
     ArrowAnnotate: ArrowAnnotate,
     Probe: Probe,
     PlanarFreehandROI: PlanarFreehandROI,
+    UltrasoundDirectional: UltrasoundDirectional,
     MeasurementReport: MeasurementReport,
     CodeScheme: CodingScheme,
     CORNERSTONE_3D_TAG: CORNERSTONE_3D_TAG