@ohif/app 3.11.0-beta.7 → 3.11.0-beta.70

package/dist/{3166.bundle.0f97235b970e279a4707.js → 1443.bundle.1514ced63fdeb24497a5.js}

@@ -1,6 +1,6 @@
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[3166],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[1443],{
 
-/***/ 59874:
+/***/ 34279:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -15,6 +15,8 @@ __webpack_require__.d(__webpack_exports__, {
   _$: () => (/* reexport */ helpers_namespaceObject)
 });
 
+// UNUSED EXPORTS: NO_IMAGE_ID
+
 // NAMESPACE OBJECT: ../../../node_modules/@cornerstonejs/adapters/dist/esm/adapters/Cornerstone/Segmentation.js
 var Segmentation_namespaceObject = {};
 __webpack_require__.r(Segmentation_namespaceObject);
@@ -2707,6 +2709,18 @@ function Segmentation_4X_unpackPixelData(multiframe, options) {
     // MAX 2GB is the limit right now to allocate a buffer
     return getUnpackedChunks(data, options.maxBytesPerChunk);
   }
+  if (segType === "LABELMAP") {
+    // For LABELMAP, we can return the data as is, since it is already in a
+    // format that Cornerstone can handle. Also here we are returning the
+    // whole data at once, since the storage is more efficent than BINARY mode
+    if (multiframe.BitsStored === 8) {
+      return new Uint8Array(data);
+    } else if (multiframe.BitsStored === 16) {
+      return new Uint16Array(data);
+    } else {
+      return new Uint8Array(data);
+    }
+  }
   const pixelData = new Uint8Array(data);
   const max = multiframe.MaximumFractionalValue;
   const onlyMaxAndZero = pixelData.find(element => element !== 0 && element !== max) === undefined;
@@ -3332,6 +3346,8 @@ const CornerstonePMAP = {
 
 
 
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
+var esm = __webpack_require__(15327);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/adapters/dist/esm/adapters/Cornerstone3D/cornerstone3DTag.js
 var CORNERSTONE_3D_TAG = "Cornerstone3DTools@^0.1.0";
 
@@ -3358,6 +3374,25 @@ function copyStudyTags(src) {
 
 
 
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/adapters/dist/esm/adapters/helpers/copySeriesTags.js
+const seriesTags = ["SeriesInstanceUID", "SeriesNumber", "SeriesDescription", "Modality", "SeriesDate", "SeriesTime"];
+function copySeriesTags(src) {
+  const study = {
+    _meta: src._meta,
+    _vrMap: src._vrMap
+  };
+  for (const tagKey of seriesTags) {
+    const value = src[tagKey];
+    if (value === undefined) {
+      continue;
+    }
+    study[tagKey] = value;
+  }
+  return study;
+}
+
+
+
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/adapters/dist/esm/adapters/Cornerstone3D/CodingScheme.js
 // This is a custom coding scheme defined to store some annotations from Cornerstone.
 // Note: CodeMeaning is VR type LO, which means we only actually support 64 characters
@@ -3375,6 +3410,11 @@ const CodingScheme = {
 
 
 
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/adapters/dist/esm/adapters/Cornerstone3D/constants/index.js
+const NO_IMAGE_ID = "none";
+
+
+
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/adapters/dist/esm/adapters/Cornerstone3D/MeasurementReport.js
 
 
@@ -3384,6 +3424,9 @@ const CodingScheme = {
 
 
 
+
+
+
 var _MeasurementReport;
 const {
   TID1500: MeasurementReport_TID1500,
@@ -3469,15 +3512,13 @@ class MeasurementReport_MeasurementReport {
     };
     return _meta;
   }
-  static getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, toolType) {
-    const {
-      ContentSequence
-    } = MeasurementGroup;
-    const contentSequenceArr = toArray(ContentSequence);
-    const findingGroup = contentSequenceArr.find(group => this.codeValueMatch(group, MeasurementReport_FINDING));
-    const findingSiteGroups = contentSequenceArr.filter(group => this.codeValueMatch(group, MeasurementReport_FINDING_SITE, MeasurementReport_FINDING_SITE_OLD)) || [];
-    const NUMGroup = contentSequenceArr.find(group => group.ValueType === "NUM");
-    const SCOORDGroup = toArray(NUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD");
+  static processSCOORDGroup(_ref) {
+    let {
+      SCOORDGroup,
+      toolType,
+      sopInstanceUIDToImageIdMap,
+      metadata
+    } = _ref;
     const {
       ReferencedSOPSequence
     } = SCOORDGroup.ContentSequence;
@@ -3487,23 +3528,101 @@ class MeasurementReport_MeasurementReport {
     } = ReferencedSOPSequence;
     const referencedImageId = sopInstanceUIDToImageIdMap[ReferencedSOPInstanceUID];
     const imagePlaneModule = metadata.get("imagePlaneModule", referencedImageId);
+    return {
+      SCOORDGroup,
+      ReferencedSOPSequence,
+      ReferencedSOPInstanceUID,
+      ReferencedFrameNumber,
+      state: {
+        description: undefined,
+        sopInstanceUid: ReferencedSOPInstanceUID,
+        annotation: {
+          annotationUID: MeasurementReport_DicomMetaDictionary.uid(),
+          metadata: {
+            toolName: toolType,
+            referencedImageId,
+            FrameOfReferenceUID: imagePlaneModule.frameOfReferenceUID,
+            label: ""
+          }
+        }
+      }
+    };
+  }
+  static processSCOORD3DGroup(_ref2) {
+    let {
+      SCOORD3DGroup,
+      toolType
+    } = _ref2;
+    return {
+      SCOORD3DGroup,
+      FrameOfReferenceUID: SCOORD3DGroup.ReferencedFrameOfReferenceUID,
+      state: {
+        description: undefined,
+        annotation: {
+          annotationUID: MeasurementReport_DicomMetaDictionary.uid(),
+          metadata: {
+            toolName: toolType,
+            FrameOfReferenceUID: SCOORD3DGroup.ReferencedFrameOfReferenceUID,
+            label: ""
+          }
+        }
+      }
+    };
+  }
+  static getSpatialCoordinatesState(_ref3) {
+    let {
+      NUMGroup,
+      sopInstanceUIDToImageIdMap,
+      metadata,
+      toolType
+    } = _ref3;
+    const SCOORDGroup = toArray(NUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD");
+    const SCOORD3DGroup = toArray(NUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD3D");
+    if (SCOORDGroup) {
+      return this.processSCOORDGroup({
+        SCOORDGroup,
+        toolType,
+        metadata,
+        sopInstanceUIDToImageIdMap
+      });
+    } else if (SCOORD3DGroup) {
+      return this.processSCOORD3DGroup({
+        SCOORD3DGroup,
+        toolType
+      });
+    } else {
+      throw new Error("No spatial coordinates group found.");
+    }
+  }
+  static processSpatialCoordinatesGroup(_ref4) {
+    let {
+      NUMGroup,
+      sopInstanceUIDToImageIdMap,
+      metadata,
+      findingGroup,
+      findingSiteGroups,
+      toolType
+    } = _ref4;
+    const {
+      state,
+      SCOORDGroup,
+      ReferencedSOPSequence,
+      ReferencedSOPInstanceUID,
+      ReferencedFrameNumber,
+      SCOORD3DGroup,
+      FrameOfReferenceUID
+    } = this.getSpatialCoordinatesState({
+      NUMGroup,
+      sopInstanceUIDToImageIdMap,
+      metadata,
+      toolType
+    });
     const finding = findingGroup ? MeasurementReport_addAccessors(findingGroup.ConceptCodeSequence) : undefined;
     const findingSites = findingSiteGroups.map(fsg => {
       return MeasurementReport_addAccessors(fsg.ConceptCodeSequence);
     });
     const defaultState = {
-      description: undefined,
-      sopInstanceUid: ReferencedSOPInstanceUID,
-      annotation: {
-        annotationUID: MeasurementReport_DicomMetaDictionary.uid(),
-        metadata: {
-          toolName: toolType,
-          referencedImageId,
-          FrameOfReferenceUID: imagePlaneModule.frameOfReferenceUID,
-          label: ""
-        },
-        data: undefined
-      },
+      ...state,
       finding,
       findingSites
     };
@@ -3517,39 +3636,96 @@ class MeasurementReport_MeasurementReport {
       SCOORDGroup,
       ReferencedSOPSequence,
       ReferencedSOPInstanceUID,
-      ReferencedFrameNumber
+      ReferencedFrameNumber,
+      SCOORD3DGroup,
+      FrameOfReferenceUID
+    };
+  }
+  static getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, toolType) {
+    const {
+      ContentSequence
+    } = MeasurementGroup;
+    const contentSequenceArr = toArray(ContentSequence);
+    const findingGroup = contentSequenceArr.find(group => this.codeValueMatch(group, MeasurementReport_FINDING));
+    const findingSiteGroups = contentSequenceArr.filter(group => this.codeValueMatch(group, MeasurementReport_FINDING_SITE, MeasurementReport_FINDING_SITE_OLD)) || [];
+    const NUMGroup = contentSequenceArr.find(group => group.ValueType === "NUM");
+    return this.processSpatialCoordinatesGroup({
+      NUMGroup,
+      sopInstanceUIDToImageIdMap,
+      metadata,
+      findingGroup,
+      findingSiteGroups,
+      toolType
+    });
+  }
+  static generateReferencedSOPSequence(_ref5) {
+    let {
+      toolData,
+      toolTypes,
+      metadataProvider,
+      imageId,
+      sopInstanceUIDsToSeriesInstanceUIDMap,
+      derivationSourceDatasets
+    } = _ref5;
+    const effectiveImageId = imageId === NO_IMAGE_ID ? this.getImageIdFromVolume({
+      toolData,
+      toolTypes
+    }) : imageId;
+    const sopCommonModule = metadataProvider.get("sopCommonModule", effectiveImageId);
+    const instance = metadataProvider.get("instance", effectiveImageId);
+    const {
+      sopInstanceUID,
+      sopClassUID
+    } = sopCommonModule;
+    const {
+      SeriesInstanceUID: seriesInstanceUID
+    } = instance;
+    sopInstanceUIDsToSeriesInstanceUIDMap[sopInstanceUID] = seriesInstanceUID;
+    if (!derivationSourceDatasets.find(dsd => dsd.SeriesInstanceUID === seriesInstanceUID)) {
+      const derivationSourceDataset = MeasurementReport_MeasurementReport.generateDerivationSourceDataset(instance);
+      derivationSourceDatasets.push(derivationSourceDataset);
+    }
+    const frameNumber = metadataProvider.get("frameNumber", effectiveImageId);
+    const ReferencedSOPSequence = {
+      ReferencedSOPClassUID: sopClassUID,
+      ReferencedSOPInstanceUID: sopInstanceUID,
+      ReferencedFrameNumber: undefined
     };
+    if (instance && instance.NumberOfFrames && instance.NumberOfFrames > 1 || MeasurementReport_Normalizer.isMultiframeSOPClassUID(sopClassUID)) {
+      ReferencedSOPSequence.ReferencedFrameNumber = frameNumber;
+    }
+    return ReferencedSOPSequence;
+  }
+  static getImageIdFromVolume(_ref6) {
+    let {
+      toolData,
+      toolTypes
+    } = _ref6;
+    const referenceToolData = toolData?.[toolTypes?.[0]]?.data?.[0];
+    const volumeId = referenceToolData?.metadata?.volumeId;
+    const volume = esm.cache.getVolume(volumeId);
+    const imageId = volume.imageIds[0];
+    return imageId;
   }
   static generateReport(toolState, metadataProvider, worldToImageCoords, options) {
     let allMeasurementGroups = [];
     const sopInstanceUIDsToSeriesInstanceUIDMap = {};
     const derivationSourceDatasets = [];
     const _meta = MeasurementReport_MeasurementReport.generateDatasetMeta();
+    let is3DSR = false;
     Object.keys(toolState).forEach(imageId => {
-      const sopCommonModule = metadataProvider.get("sopCommonModule", imageId);
-      const instance = metadataProvider.get("instance", imageId);
-      const {
-        sopInstanceUID,
-        sopClassUID
-      } = sopCommonModule;
-      const {
-        SeriesInstanceUID: seriesInstanceUID
-      } = instance;
-      sopInstanceUIDsToSeriesInstanceUIDMap[sopInstanceUID] = seriesInstanceUID;
-      if (!derivationSourceDatasets.find(dsd => dsd.SeriesInstanceUID === seriesInstanceUID)) {
-        const derivationSourceDataset = MeasurementReport_MeasurementReport.generateDerivationSourceDataset(instance);
-        derivationSourceDatasets.push(derivationSourceDataset);
-      }
-      const frameNumber = metadataProvider.get("frameNumber", imageId);
       const toolData = toolState[imageId];
       const toolTypes = Object.keys(toolData);
-      const ReferencedSOPSequence = {
-        ReferencedSOPClassUID: sopClassUID,
-        ReferencedSOPInstanceUID: sopInstanceUID,
-        ReferencedFrameNumber: undefined
-      };
-      if (instance && instance.NumberOfFrames && instance.NumberOfFrames > 1 || MeasurementReport_Normalizer.isMultiframeSOPClassUID(sopClassUID)) {
-        ReferencedSOPSequence.ReferencedFrameNumber = frameNumber;
+      const ReferencedSOPSequence = this.generateReferencedSOPSequence({
+        toolData,
+        toolTypes,
+        metadataProvider,
+        imageId,
+        sopInstanceUIDsToSeriesInstanceUIDMap,
+        derivationSourceDatasets
+      });
+      if (imageId === NO_IMAGE_ID) {
+        is3DSR = true;
       }
       const measurementGroups = [];
       toolTypes.forEach(toolType => {
@@ -3571,6 +3747,9 @@ class MeasurementReport_MeasurementReport {
     report.dataset = Object.assign(report.dataset, contentItem);
     report.dataset._meta = _meta;
     report.SpecificCharacterSet = "ISO_IR 192";
+    if (is3DSR) {
+      report.dataset.SOPClassUID = MeasurementReport_DicomMetaDictionary.sopClassUIDsByName.Comprehensive3DSR;
+    }
     return report;
   }
   static generateToolState(dataset, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata, hooks) {
@@ -3661,9 +3840,12 @@ _MeasurementReport.codeValueMatch = (group, code, oldCode) => {
   return CodingSchemeDesignator == code.CodingSchemeDesignator && CodeValue == code.CodeValue || oldCode && CodingSchemeDesignator == oldCode.CodingSchemeDesignator && CodeValue == oldCode.CodeValue;
 };
 _MeasurementReport.generateDerivationSourceDataset = instance => {
-  _MeasurementReport.generateDatasetMeta();
-  const derivationSourceDataset = copyStudyTags(instance);
-  return derivationSourceDataset;
+  const studyTags = copyStudyTags(instance);
+  const seriesTags = copySeriesTags(instance);
+  return {
+    ...studyTags,
+    ...seriesTags
+  };
 };
 
 
@@ -3736,7 +3918,7 @@ class BaseAdapter3D {
       referencedImageId
     } = metadata;
     if (!referencedImageId) {
-      throw new Error("Probe.getTID300RepresentationArguments: referencedImageId is not defined");
+      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
     }
     const {
       handles: {
@@ -3758,6 +3940,30 @@ class BaseAdapter3D {
     };
     return tidArguments;
   }
+  static getTID300RepresentationArgumentsSCOORD3D(tool) {
+    const {
+      data,
+      finding,
+      findingSites
+    } = tool;
+    const {
+      handles: {
+        points = []
+      }
+    } = data;
+    const point = points[0];
+    const pointXYZ = {
+      x: point[0],
+      y: point[1],
+      z: point[2]
+    };
+    return {
+      points: [pointXYZ],
+      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
+      findingSites: findingSites || [],
+      finding
+    };
+  }
 }
 
 
@@ -3780,10 +3986,69 @@ class ArrowAnnotate_ArrowAnnotate extends BaseAdapter3D {
     const {
       defaultState,
       SCOORDGroup,
+      SCOORD3DGroup,
       ReferencedFrameNumber
     } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, ArrowAnnotate_ArrowAnnotate.toolType);
     const referencedImageId = defaultState.annotation.metadata.referencedImageId;
     const text = defaultState.annotation.metadata.label;
+    if (SCOORDGroup) {
+      return this.getMeasurementDataFromScoord({
+        SCOORDGroup,
+        referencedImageId,
+        metadata,
+        imageToWorldCoords,
+        defaultState,
+        text,
+        ReferencedFrameNumber
+      });
+    } else if (SCOORD3DGroup) {
+      return this.getMeasurementDataFromScoord3D({
+        SCOORD3DGroup,
+        defaultState,
+        text
+      });
+    } else {
+      throw new Error("Can't get measurement data with missing SCOORD and SCOORD3D groups.");
+    }
+  }
+  static getMeasurementDataFromScoord3D(_ref) {
+    let {
+      SCOORD3DGroup,
+      defaultState,
+      text
+    } = _ref;
+    const {
+      GraphicData
+    } = SCOORD3DGroup;
+    const worldCoords = [];
+    for (let i = 0; i < GraphicData.length; i += 3) {
+      const point = [GraphicData[i], GraphicData[i + 1], GraphicData[i + 2]];
+      worldCoords.push(point);
+    }
+    const state = defaultState;
+    state.annotation.data = {
+      text,
+      handles: {
+        arrowFirst: true,
+        points: [worldCoords[0], worldCoords[1]],
+        activeHandleIndex: 0,
+        textBox: {
+          hasMoved: false
+        }
+      }
+    };
+    return state;
+  }
+  static getMeasurementDataFromScoord(_ref2) {
+    let {
+      SCOORDGroup,
+      referencedImageId,
+      metadata,
+      imageToWorldCoords,
+      defaultState,
+      text,
+      ReferencedFrameNumber
+    } = _ref2;
     const {
       GraphicData
     } = SCOORDGroup;
@@ -3835,7 +4100,7 @@ class ArrowAnnotate_ArrowAnnotate extends BaseAdapter3D {
       referencedImageId
     } = metadata;
     if (!referencedImageId) {
-      throw new Error("ArrowAnnotate.getTID300RepresentationArguments: referencedImageId is not defined");
+      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
     }
     const {
       points,
@@ -3862,7 +4127,57 @@ class ArrowAnnotate_ArrowAnnotate extends BaseAdapter3D {
       }],
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       findingSites: findingSites || [],
+      finding,
+      use3DSpatialCoordinates: false
+    };
+    if (!finding || finding.CodeValue !== codeValues.CORNERSTONEFREETEXT) {
+      finding = {
+        CodeValue: codeValues.CORNERSTONEFREETEXT,
+        CodingSchemeDesignator: CodingScheme.CodingSchemeDesignator,
+        CodeMeaning: data.text
+      };
+    }
+    return TID300RepresentationArguments;
+  }
+  static getTID300RepresentationArgumentsSCOORD3D(tool) {
+    const {
+      data,
+      findingSites,
+      metadata
+    } = tool;
+    let {
       finding
+    } = tool;
+    const {
+      points,
+      arrowFirst
+    } = data.handles;
+    let point;
+    let point2;
+    if (arrowFirst) {
+      point = points[0];
+      point2 = points[1];
+    } else {
+      point = points[1];
+      point2 = points[0];
+    }
+    const pointImage = point;
+    const pointImage2 = point2;
+    const TID300RepresentationArguments = {
+      points: [{
+        x: pointImage[0],
+        y: pointImage[1],
+        z: pointImage[2]
+      }, {
+        x: pointImage2[0],
+        y: pointImage2[1],
+        z: pointImage2[2]
+      }],
+      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
+      findingSites: findingSites || [],
+      finding,
+      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
+      use3DSpatialCoordinates: true
     };
     if (!finding || finding.CodeValue !== codeValues.CORNERSTONEFREETEXT) {
       finding = {
@@ -3906,9 +4221,39 @@ class Bidirectional_Bidirectional extends BaseAdapter3D {
       ContentSequence
     } = MeasurementGroup;
     const longAxisNUMGroup = toArray(ContentSequence).find(group => group.ConceptNameCodeSequence.CodeMeaning === Bidirectional_LONG_AXIS);
-    const longAxisSCOORDGroup = toArray(longAxisNUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD");
     const shortAxisNUMGroup = toArray(ContentSequence).find(group => group.ConceptNameCodeSequence.CodeMeaning === Bidirectional_SHORT_AXIS);
+    const longAxisSCOORDGroup = toArray(longAxisNUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD");
     const shortAxisSCOORDGroup = toArray(shortAxisNUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD");
+    if (longAxisSCOORDGroup && shortAxisSCOORDGroup) {
+      return this.getMeasurementDataFromScoord({
+        longAxisNUMGroup,
+        shortAxisNUMGroup,
+        longAxisSCOORDGroup,
+        shortAxisSCOORDGroup,
+        referencedImageId,
+        imageToWorldCoords,
+        ReferencedFrameNumber,
+        defaultState
+      });
+    } else {
+      return this.getMeasurementDataFromScoord3d({
+        longAxisNUMGroup,
+        shortAxisNUMGroup,
+        defaultState
+      });
+    }
+  }
+  static getMeasurementDataFromScoord(_ref) {
+    let {
+      longAxisNUMGroup,
+      shortAxisNUMGroup,
+      longAxisSCOORDGroup,
+      shortAxisSCOORDGroup,
+      referencedImageId,
+      imageToWorldCoords,
+      ReferencedFrameNumber,
+      defaultState
+    } = _ref;
     const worldCoords = [];
     [longAxisSCOORDGroup, shortAxisSCOORDGroup].forEach(group => {
       const {
@@ -3938,6 +4283,37 @@ class Bidirectional_Bidirectional extends BaseAdapter3D {
     };
     return state;
   }
+  static getMeasurementDataFromScoord3d(_ref2) {
+    let {
+      longAxisNUMGroup,
+      shortAxisNUMGroup,
+      defaultState
+    } = _ref2;
+    const worldCoords = [];
+    const longAxisSCOORD3DGroup = toArray(longAxisNUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD3D");
+    const shortAxisSCOORD3DGroup = toArray(shortAxisNUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD3D");
+    [longAxisSCOORD3DGroup, shortAxisSCOORD3DGroup].forEach(group => {
+      const {
+        GraphicData
+      } = group;
+      for (let i = 0; i < GraphicData.length; i += 3) {
+        const point = [GraphicData[i], GraphicData[i + 1], GraphicData[i + 2]];
+        worldCoords.push(point);
+      }
+    });
+    const state = defaultState;
+    state.annotation.data = {
+      handles: {
+        points: [worldCoords[0], worldCoords[1], worldCoords[2], worldCoords[3]],
+        activeHandleIndex: 0,
+        textBox: {
+          hasMoved: false
+        }
+      },
+      cachedStats: {}
+    };
+    return state;
+  }
   static getTID300RepresentationArguments(tool, worldToImageCoords) {
     const {
       data,
@@ -3952,13 +4328,6 @@ class Bidirectional_Bidirectional extends BaseAdapter3D {
     const {
       referencedImageId
     } = metadata;
-    if (!referencedImageId) {
-      throw new Error("Bidirectional.getTID300RepresentationArguments: referencedImageId is not defined");
-    }
-    const {
-      length,
-      width
-    } = cachedStats[`imageId:${referencedImageId}`] || {};
     const {
       points
     } = handles;
@@ -3975,10 +4344,21 @@ class Bidirectional_Bidirectional extends BaseAdapter3D {
       shortAxisPoints = secondPointPairs;
       longAxisPoints = firstPointPairs;
     }
+    if (!referencedImageId) {
+      return this.getTID300RepresentationArgumentsSCOORD3D({
+        tool,
+        shortAxisPoints,
+        longAxisPoints
+      });
+    }
     const longAxisStartImage = worldToImageCoords(referencedImageId, shortAxisPoints[0]);
     const longAxisEndImage = worldToImageCoords(referencedImageId, shortAxisPoints[1]);
     const shortAxisStartImage = worldToImageCoords(referencedImageId, longAxisPoints[0]);
     const shortAxisEndImage = worldToImageCoords(referencedImageId, longAxisPoints[1]);
+    const {
+      length,
+      width
+    } = cachedStats[`imageId:${referencedImageId}`] || {};
     return {
       longAxis: {
         point1: {
@@ -4004,15 +4384,74 @@ class Bidirectional_Bidirectional extends BaseAdapter3D {
       shortAxisLength: width,
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding: finding,
-      findingSites: findingSites || []
+      findingSites: findingSites || [],
+      use3DSpatialCoordinates: false
     };
   }
-}
-_Bidirectional = Bidirectional_Bidirectional;
-(() => {
-  _Bidirectional.init("Bidirectional", Bidirectional_TID300Bidirectional);
-  _Bidirectional.registerLegacy();
-})();
+  static getTID300RepresentationArgumentsSCOORD3D(_ref3) {
+    let {
+      tool,
+      shortAxisPoints,
+      longAxisPoints
+    } = _ref3;
+    const {
+      data,
+      finding,
+      findingSites,
+      metadata
+    } = tool;
+    const {
+      cachedStats = {}
+    } = data;
+    const longAxisStart = shortAxisPoints[0];
+    const longAxisEnd = shortAxisPoints[1];
+    const shortAxisStart = longAxisPoints[0];
+    const shortAxisEnd = longAxisPoints[1];
+    const cachedStatsKeys = Object.keys(cachedStats)[0];
+    const {
+      length,
+      width
+    } = cachedStatsKeys ? cachedStats[cachedStatsKeys] : {};
+    return {
+      longAxis: {
+        point1: {
+          x: longAxisStart[0],
+          y: longAxisStart[1],
+          z: longAxisStart[2]
+        },
+        point2: {
+          x: longAxisEnd[0],
+          y: longAxisEnd[1],
+          z: longAxisEnd[2]
+        }
+      },
+      shortAxis: {
+        point1: {
+          x: shortAxisStart[0],
+          y: shortAxisStart[1],
+          z: shortAxisStart[2]
+        },
+        point2: {
+          x: shortAxisEnd[0],
+          y: shortAxisEnd[1],
+          z: shortAxisEnd[2]
+        }
+      },
+      longAxisLength: length,
+      shortAxisLength: width,
+      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
+      finding: finding,
+      findingSites: findingSites || [],
+      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
+      use3DSpatialCoordinates: true
+    };
+  }
+}
+_Bidirectional = Bidirectional_Bidirectional;
+(() => {
+  _Bidirectional.init("Bidirectional", Bidirectional_TID300Bidirectional);
+  _Bidirectional.registerLegacy();
+})();
 
 
 
@@ -4031,8 +4470,34 @@ class Angle_Angle extends BaseAdapter3D {
       defaultState,
       NUMGroup,
       SCOORDGroup,
+      SCOORD3DGroup,
       ReferencedFrameNumber
     } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, Angle_Angle.toolType);
+    if (SCOORDGroup) {
+      return this.getMeasurementDataFromScoord({
+        defaultState,
+        SCOORDGroup,
+        imageToWorldCoords,
+        NUMGroup,
+        ReferencedFrameNumber
+      });
+    } else if (SCOORD3DGroup) {
+      return this.getMeasurementDataFromScoord3D({
+        defaultState,
+        SCOORD3DGroup
+      });
+    } else {
+      throw new Error("Can't get measurement data with missing SCOORD and SCOORD3D groups.");
+    }
+  }
+  static getMeasurementDataFromScoord(_ref) {
+    let {
+      defaultState,
+      SCOORDGroup,
+      imageToWorldCoords,
+      NUMGroup,
+      ReferencedFrameNumber
+    } = _ref;
     const referencedImageId = defaultState.annotation.metadata.referencedImageId;
     const {
       GraphicData
@@ -4060,6 +4525,32 @@ class Angle_Angle extends BaseAdapter3D {
     };
     return state;
   }
+  static getMeasurementDataFromScoord3D(_ref2) {
+    let {
+      defaultState,
+      SCOORD3DGroup
+    } = _ref2;
+    const {
+      GraphicData
+    } = SCOORD3DGroup;
+    const worldCoords = [];
+    for (let i = 0; i < GraphicData.length; i += 3) {
+      const point = [GraphicData[i], GraphicData[i + 1], GraphicData[i + 2]];
+      worldCoords.push(point);
+    }
+    const state = defaultState;
+    state.annotation.data = {
+      handles: {
+        points: [worldCoords[0], worldCoords[1], worldCoords[3]],
+        activeHandleIndex: 0,
+        textBox: {
+          hasMoved: false
+        }
+      },
+      cachedStats: {}
+    };
+    return state;
+  }
   static getTID300RepresentationArguments(tool, worldToImageCoords) {
     const {
       data,
@@ -4075,7 +4566,7 @@ class Angle_Angle extends BaseAdapter3D {
       referencedImageId
     } = metadata;
     if (!referencedImageId) {
-      throw new Error("Angle.getTID300RepresentationArguments: referencedImageId is not defined");
+      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
     }
     const start1 = worldToImageCoords(referencedImageId, handles.points[0]);
     const middle = worldToImageCoords(referencedImageId, handles.points[1]);
@@ -4104,7 +4595,55 @@ class Angle_Angle extends BaseAdapter3D {
       rAngle: angle,
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding,
-      findingSites: findingSites || []
+      findingSites: findingSites || [],
+      use3DSpatialCoordinates: false
+    };
+  }
+  static getTID300RepresentationArgumentsSCOORD3D(tool) {
+    const {
+      data,
+      finding,
+      findingSites,
+      metadata
+    } = tool;
+    const {
+      cachedStats = {},
+      handles
+    } = data;
+    const start = handles.points[0];
+    const middle = handles.points[1];
+    const end = handles.points[2];
+    const point1 = {
+      x: start[0],
+      y: start[1],
+      z: start[2]
+    };
+    const point2 = {
+      x: middle[0],
+      y: middle[1],
+      z: middle[2]
+    };
+    const point3 = point2;
+    const point4 = {
+      x: end[0],
+      y: end[1],
+      z: end[2]
+    };
+    const cachedStatsKeys = Object.keys(cachedStats)[0];
+    const {
+      angle
+    } = cachedStatsKeys ? cachedStats[cachedStatsKeys] : {};
+    return {
+      point1,
+      point2,
+      point3,
+      point4,
+      rAngle: angle,
+      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
+      finding,
+      findingSites: findingSites || [],
+      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
+      use3DSpatialCoordinates: true
     };
   }
 }
@@ -4131,8 +4670,34 @@ class CobbAngle_CobbAngle extends BaseAdapter3D {
       defaultState,
       NUMGroup,
       SCOORDGroup,
+      SCOORD3DGroup,
       ReferencedFrameNumber
     } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, CobbAngle_CobbAngle.toolType);
+    if (SCOORDGroup) {
+      return this.getMeasurementDataFromScoord({
+        defaultState,
+        SCOORDGroup,
+        imageToWorldCoords,
+        NUMGroup,
+        ReferencedFrameNumber
+      });
+    } else if (SCOORD3DGroup) {
+      return this.getMeasurementDataFromScoord3D({
+        defaultState,
+        SCOORD3DGroup
+      });
+    } else {
+      throw new Error("Can't get measurement data with missing SCOORD and SCOORD3D groups.");
+    }
+  }
+  static getMeasurementDataFromScoord(_ref) {
+    let {
+      defaultState,
+      SCOORDGroup,
+      imageToWorldCoords,
+      NUMGroup,
+      ReferencedFrameNumber
+    } = _ref;
     const referencedImageId = defaultState.annotation.metadata.referencedImageId;
     const {
       GraphicData
@@ -4160,6 +4725,32 @@ class CobbAngle_CobbAngle extends BaseAdapter3D {
     };
     return state;
   }
+  static getMeasurementDataFromScoord3D(_ref2) {
+    let {
+      defaultState,
+      SCOORD3DGroup
+    } = _ref2;
+    const {
+      GraphicData
+    } = SCOORD3DGroup;
+    const worldCoords = [];
+    for (let i = 0; i < GraphicData.length; i += 3) {
+      const point = [GraphicData[i], GraphicData[i + 1], GraphicData[i + 2]];
+      worldCoords.push(point);
+    }
+    const state = defaultState;
+    state.annotation.data = {
+      handles: {
+        points: [worldCoords[0], worldCoords[1], worldCoords[2], worldCoords[3]],
+        activeHandleIndex: 0,
+        textBox: {
+          hasMoved: false
+        }
+      },
+      cachedStats: {}
+    };
+    return state;
+  }
   static getTID300RepresentationArguments(tool, worldToImageCoords) {
     const {
       data,
@@ -4175,7 +4766,7 @@ class CobbAngle_CobbAngle extends BaseAdapter3D {
       referencedImageId
     } = metadata;
     if (!referencedImageId) {
-      throw new Error("CobbAngle.getTID300RepresentationArguments: referencedImageId is not defined");
+      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
     }
     const start1 = worldToImageCoords(referencedImageId, handles.points[0]);
     const end1 = worldToImageCoords(referencedImageId, handles.points[1]);
@@ -4208,7 +4799,60 @@ class CobbAngle_CobbAngle extends BaseAdapter3D {
       rAngle: angle,
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding,
-      findingSites: findingSites || []
+      findingSites: findingSites || [],
+      use3DSpatialCoordinates: false
+    };
+  }
+  static getTID300RepresentationArgumentsSCOORD3D(tool) {
+    const {
+      data,
+      finding,
+      findingSites,
+      metadata
+    } = tool;
+    const {
+      cachedStats = {},
+      handles
+    } = data;
+    const start1 = handles.points[0];
+    const end1 = handles.points[1];
+    const start2 = handles.points[2];
+    const end2 = handles.points[3];
+    const point1 = {
+      x: start1[0],
+      y: start1[1],
+      z: start1[2]
+    };
+    const point2 = {
+      x: end1[0],
+      y: end1[1],
+      z: end1[2]
+    };
+    const point3 = {
+      x: start2[0],
+      y: start2[1],
+      z: start2[2]
+    };
+    const point4 = {
+      x: end2[0],
+      y: end2[1],
+      z: end2[2]
+    };
+    const cachedStatsKeys = Object.keys(cachedStats)[0];
+    const {
+      angle
+    } = cachedStatsKeys ? cachedStats[cachedStatsKeys] : {};
+    return {
+      point1,
+      point2,
+      point3,
+      point4,
+      rAngle: angle,
+      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
+      finding,
+      findingSites: findingSites || [],
+      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
+      use3DSpatialCoordinates: true
     };
   }
 }
@@ -4235,8 +4879,34 @@ class CircleROI extends BaseAdapter3D {
       defaultState,
       NUMGroup,
       SCOORDGroup,
+      SCOORD3DGroup,
       ReferencedFrameNumber
     } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, CircleROI.toolType);
+    if (SCOORDGroup) {
+      return this.getMeasurementDataFromScoord({
+        defaultState,
+        SCOORDGroup,
+        imageToWorldCoords,
+        NUMGroup,
+        ReferencedFrameNumber
+      });
+    } else if (SCOORD3DGroup) {
+      return this.getMeasurementDataFromScoord3D({
+        defaultState,
+        SCOORD3DGroup
+      });
+    } else {
+      throw new Error("Can't get measurement data with missing SCOORD and SCOORD3D groups.");
+    }
+  }
+  static getMeasurementDataFromScoord(_ref) {
+    let {
+      defaultState,
+      SCOORDGroup,
+      imageToWorldCoords,
+      NUMGroup,
+      ReferencedFrameNumber
+    } = _ref;
     const referencedImageId = defaultState.annotation.metadata.referencedImageId;
     const {
       GraphicData
@@ -4266,6 +4936,32 @@ class CircleROI extends BaseAdapter3D {
     };
     return state;
   }
+  static getMeasurementDataFromScoord3D(_ref2) {
+    let {
+      defaultState,
+      SCOORD3DGroup
+    } = _ref2;
+    const {
+      GraphicData
+    } = SCOORD3DGroup;
+    const pointsWorld = [];
+    for (let i = 0; i < GraphicData.length; i += 3) {
+      const worldPos = [GraphicData[i], GraphicData[i + 1], GraphicData[i + 2]];
+      pointsWorld.push(worldPos);
+    }
+    const state = defaultState;
+    state.annotation.data = {
+      handles: {
+        points: [...pointsWorld],
+        activeHandleIndex: 0,
+        textBox: {
+          hasMoved: false
+        }
+      },
+      cachedStats: {}
+    };
+    return state;
+  }
   static getTID300RepresentationArguments(tool, worldToImageCoords) {
     const {
       data,
@@ -4281,7 +4977,7 @@ class CircleROI extends BaseAdapter3D {
       referencedImageId
     } = metadata;
     if (!referencedImageId) {
-      throw new Error("CircleROI.getTID300RepresentationArguments: referencedImageId is not defined");
+      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
     }
     const center = worldToImageCoords(referencedImageId, handles.points[0]);
     const end = worldToImageCoords(referencedImageId, handles.points[1]);
@@ -4306,7 +5002,50 @@ class CircleROI extends BaseAdapter3D {
       points,
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding,
-      findingSites: findingSites || []
+      findingSites: findingSites || [],
+      use3DSpatialCoordinates: false
+    };
+  }
+  static getTID300RepresentationArgumentsSCOORD3D(tool) {
+    const {
+      data,
+      finding,
+      findingSites,
+      metadata
+    } = tool;
+    const {
+      cachedStats = {},
+      handles
+    } = data;
+    const center = handles.points[0];
+    const end = handles.points[1];
+    const points = [];
+    points.push({
+      x: center[0],
+      y: center[1],
+      z: center[2]
+    });
+    points.push({
+      x: end[0],
+      y: end[1],
+      z: center[2]
+    });
+    const cachedStatsKeys = Object.keys(cachedStats)[0];
+    const {
+      area,
+      radius
+    } = cachedStatsKeys ? cachedStats[cachedStatsKeys] : {};
+    const perimeter = 2 * Math.PI * radius;
+    return {
+      area,
+      perimeter,
+      radius,
+      points,
+      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
+      finding,
+      findingSites: findingSites || [],
+      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
+      use3DSpatialCoordinates: true
     };
   }
 }
@@ -4319,7 +5058,7 @@ _CircleROI = CircleROI;
 
 
 // EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 1 modules
-var esm = __webpack_require__(3823);
+var gl_matrix_esm = __webpack_require__(3823);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/adapters/dist/esm/adapters/Cornerstone3D/EllipticalROI.js
 
 
@@ -4337,8 +5076,36 @@ class EllipticalROI extends BaseAdapter3D {
       defaultState,
       NUMGroup,
       SCOORDGroup,
+      SCOORD3DGroup,
       ReferencedFrameNumber
     } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, EllipticalROI.toolType);
+    if (SCOORDGroup) {
+      return this.getMeasurementDataFromScoord({
+        defaultState,
+        SCOORDGroup,
+        imageToWorldCoords,
+        metadata,
+        NUMGroup,
+        ReferencedFrameNumber
+      });
+    } else if (SCOORD3DGroup) {
+      return this.getMeasurementDataFromScoord3D({
+        defaultState,
+        SCOORD3DGroup
+      });
+    } else {
+      throw new Error("Can't get measurement data with missing SCOORD and SCOORD3D groups.");
+    }
+  }
+  static getMeasurementDataFromScoord(_ref) {
+    let {
+      defaultState,
+      SCOORDGroup,
+      imageToWorldCoords,
+      metadata,
+      NUMGroup,
+      ReferencedFrameNumber
+    } = _ref;
     const referencedImageId = defaultState.annotation.metadata.referencedImageId;
     const {
       GraphicData
@@ -4348,16 +5115,16 @@ class EllipticalROI extends BaseAdapter3D {
       const worldPos = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
       pointsWorld.push(worldPos);
     }
-    const majorAxisStart = esm/* vec3.fromValues */.eR.fromValues(...pointsWorld[0]);
-    const majorAxisEnd = esm/* vec3.fromValues */.eR.fromValues(...pointsWorld[1]);
-    const minorAxisStart = esm/* vec3.fromValues */.eR.fromValues(...pointsWorld[2]);
-    const minorAxisEnd = esm/* vec3.fromValues */.eR.fromValues(...pointsWorld[3]);
-    const majorAxisVec = esm/* vec3.create */.eR.create();
-    esm/* vec3.sub */.eR.sub(majorAxisVec, majorAxisEnd, majorAxisStart);
-    esm/* vec3.normalize */.eR.normalize(majorAxisVec, majorAxisVec);
-    const minorAxisVec = esm/* vec3.create */.eR.create();
-    esm/* vec3.sub */.eR.sub(minorAxisVec, minorAxisEnd, minorAxisStart);
-    esm/* vec3.normalize */.eR.normalize(minorAxisVec, minorAxisVec);
+    const majorAxisStart = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(...pointsWorld[0]);
+    const majorAxisEnd = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(...pointsWorld[1]);
+    const minorAxisStart = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(...pointsWorld[2]);
+    const minorAxisEnd = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(...pointsWorld[3]);
+    const majorAxisVec = gl_matrix_esm/* vec3.create */.eR.create();
+    gl_matrix_esm/* vec3.sub */.eR.sub(majorAxisVec, majorAxisEnd, majorAxisStart);
+    gl_matrix_esm/* vec3.normalize */.eR.normalize(majorAxisVec, majorAxisVec);
+    const minorAxisVec = gl_matrix_esm/* vec3.create */.eR.create();
+    gl_matrix_esm/* vec3.sub */.eR.sub(minorAxisVec, minorAxisEnd, minorAxisStart);
+    gl_matrix_esm/* vec3.normalize */.eR.normalize(minorAxisVec, minorAxisVec);
     const imagePlaneModule = metadata.get("imagePlaneModule", referencedImageId);
     if (!imagePlaneModule) {
       throw new Error("imageId does not have imagePlaneModule metadata");
@@ -4365,9 +5132,9 @@ class EllipticalROI extends BaseAdapter3D {
     const {
       columnCosines
     } = imagePlaneModule;
-    const columnCosinesVec = esm/* vec3.fromValues */.eR.fromValues(columnCosines[0], columnCosines[1], columnCosines[2]);
-    const projectedMajorAxisOnColVec = esm/* vec3.dot */.eR.dot(columnCosinesVec, majorAxisVec);
-    const projectedMinorAxisOnColVec = esm/* vec3.dot */.eR.dot(columnCosinesVec, minorAxisVec);
+    const columnCosinesVec = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(columnCosines[0], columnCosines[1], columnCosines[2]);
+    const projectedMajorAxisOnColVec = gl_matrix_esm/* vec3.dot */.eR.dot(columnCosinesVec, majorAxisVec);
+    const projectedMinorAxisOnColVec = gl_matrix_esm/* vec3.dot */.eR.dot(columnCosinesVec, minorAxisVec);
     const absoluteOfMajorDotProduct = Math.abs(projectedMajorAxisOnColVec);
     const absoluteOfMinorDotProduct = Math.abs(projectedMinorAxisOnColVec);
     let ellipsePoints = [];
@@ -4396,6 +5163,42 @@ class EllipticalROI extends BaseAdapter3D {
     };
     return state;
   }
+  static getMeasurementDataFromScoord3D(_ref2) {
+    let {
+      defaultState,
+      SCOORD3DGroup
+    } = _ref2;
+    const {
+      GraphicData
+    } = SCOORD3DGroup;
+    const pointsWorld = [];
+    for (let i = 0; i < GraphicData.length; i += 3) {
+      const worldPos = [GraphicData[i], GraphicData[i + 1], GraphicData[i + 2]];
+      pointsWorld.push(worldPos);
+    }
+    const majorAxisStart = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(...pointsWorld[0]);
+    const majorAxisEnd = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(...pointsWorld[1]);
+    const minorAxisStart = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(...pointsWorld[2]);
+    const minorAxisEnd = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(...pointsWorld[3]);
+    const majorAxisVec = gl_matrix_esm/* vec3.create */.eR.create();
+    gl_matrix_esm/* vec3.sub */.eR.sub(majorAxisVec, majorAxisEnd, majorAxisStart);
+    gl_matrix_esm/* vec3.normalize */.eR.normalize(majorAxisVec, majorAxisVec);
+    const minorAxisVec = gl_matrix_esm/* vec3.create */.eR.create();
+    gl_matrix_esm/* vec3.sub */.eR.sub(minorAxisVec, minorAxisEnd, minorAxisStart);
+    gl_matrix_esm/* vec3.normalize */.eR.normalize(minorAxisVec, minorAxisVec);
+    const state = defaultState;
+    state.annotation.data = {
+      handles: {
+        points: [majorAxisStart, majorAxisEnd, minorAxisStart, minorAxisEnd],
+        activeHandleIndex: 0,
+        textBox: {
+          hasMoved: false
+        }
+      },
+      cachedStats: {}
+    };
+    return state;
+  }
   static getTID300RepresentationArguments(tool, worldToImageCoords) {
     const {
       data,
@@ -4412,7 +5215,7 @@ class EllipticalROI extends BaseAdapter3D {
       referencedImageId
     } = metadata;
     if (!referencedImageId) {
-      throw new Error("EllipticalROI.getTID300RepresentationArguments: referencedImageId is not defined");
+      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
     }
     let top, bottom, left, right;
     if (rotation == 90 || rotation == 270) {
@@ -4472,7 +5275,92 @@ class EllipticalROI extends BaseAdapter3D {
       points,
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding,
-      findingSites: findingSites || []
+      findingSites: findingSites || [],
+      use3DSpatialCoordinates: false
+    };
+  }
+  static getTID300RepresentationArgumentsSCOORD3D(tool) {
+    const {
+      data,
+      finding,
+      findingSites,
+      metadata
+    } = tool;
+    const {
+      cachedStats,
+      handles
+    } = data;
+    const rotation = data.initialRotation || 0;
+    let top, bottom, left, right;
+    if (rotation == 90 || rotation == 270) {
+      bottom = handles.points[2];
+      top = handles.points[3];
+      left = handles.points[0];
+      right = handles.points[1];
+    } else {
+      top = handles.points[0];
+      bottom = handles.points[1];
+      left = handles.points[2];
+      right = handles.points[3];
+    }
+    const topBottomLength = Math.sqrt((top[0] - bottom[0]) ** 2 + (top[1] - bottom[1]) ** 2 + (top[2] - bottom[2]) ** 2);
+    const leftRightLength = Math.sqrt((left[0] - right[0]) ** 2 + (left[1] - right[1]) ** 2 + (left[2] - right[2]) ** 2);
+    const points = [];
+    if (topBottomLength > leftRightLength) {
+      points.push({
+        x: top[0],
+        y: top[1],
+        z: top[2]
+      });
+      points.push({
+        x: bottom[0],
+        y: bottom[1],
+        z: bottom[2]
+      });
+      points.push({
+        x: left[0],
+        y: left[1],
+        z: left[2]
+      });
+      points.push({
+        x: right[0],
+        y: right[1],
+        z: right[2]
+      });
+    } else {
+      points.push({
+        x: left[0],
+        y: left[1],
+        z: left[2]
+      });
+      points.push({
+        x: right[0],
+        y: right[1],
+        z: right[2]
+      });
+      points.push({
+        x: top[0],
+        y: top[1],
+        z: top[2]
+      });
+      points.push({
+        x: bottom[0],
+        y: bottom[1],
+        z: bottom[2]
+      });
+    }
+    const cachedStatsKeys = Object.keys(cachedStats)[0];
+    const {
+      area
+    } = cachedStatsKeys ? cachedStats[cachedStatsKeys] : {};
+    return {
+      area,
+      points,
+      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
+      finding,
+      findingSites: findingSites || [],
+      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
+      use3DSpatialCoordinates: true
     };
   }
 }
@@ -4496,8 +5384,34 @@ class RectangleROI extends BaseAdapter3D {
       defaultState,
       NUMGroup,
       SCOORDGroup,
+      SCOORD3DGroup,
       ReferencedFrameNumber
     } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, RectangleROI.toolType);
+    if (SCOORDGroup) {
+      return this.getMeasurementDataFromScoord({
+        defaultState,
+        SCOORDGroup,
+        imageToWorldCoords,
+        NUMGroup,
+        ReferencedFrameNumber
+      });
+    } else if (SCOORD3DGroup) {
+      return this.getMeasurementDataFromScoord3D({
+        SCOORD3DGroup,
+        defaultState
+      });
+    } else {
+      throw new Error("Can't get measurement data with missing SCOORD and SCOORD3D groups.");
+    }
+  }
+  static getMeasurementDataFromScoord(_ref) {
+    let {
+      defaultState,
+      SCOORDGroup,
+      imageToWorldCoords,
+      NUMGroup,
+      ReferencedFrameNumber
+    } = _ref;
     const referencedImageId = defaultState.annotation.metadata.referencedImageId;
     const {
       GraphicData
@@ -4525,6 +5439,32 @@ class RectangleROI extends BaseAdapter3D {
     };
     return state;
   }
+  static getMeasurementDataFromScoord3D(_ref2) {
+    let {
+      SCOORD3DGroup,
+      defaultState
+    } = _ref2;
+    const {
+      GraphicData
+    } = SCOORD3DGroup;
+    const worldCoords = [];
+    for (let i = 0; i < GraphicData.length; i += 3) {
+      const point = [GraphicData[i], GraphicData[i + 1], GraphicData[i + 2]];
+      worldCoords.push(point);
+    }
+    const state = defaultState;
+    state.annotation.data = {
+      handles: {
+        points: [worldCoords[0], worldCoords[1], worldCoords[3], worldCoords[2]],
+        activeHandleIndex: 0,
+        textBox: {
+          hasMoved: false
+        }
+      },
+      cachedStats: {}
+    };
+    return state;
+  }
   static getTID300RepresentationArguments(tool, worldToImageCoords) {
     const {
       data,
@@ -4540,7 +5480,7 @@ class RectangleROI extends BaseAdapter3D {
       referencedImageId
     } = metadata;
     if (!referencedImageId) {
-      throw new Error("CobbAngle.getTID300RepresentationArguments: referencedImageId is not defined");
+      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
     }
     const corners = handles.points.map(point => worldToImageCoords(referencedImageId, point));
     const {
@@ -4553,7 +5493,35 @@ class RectangleROI extends BaseAdapter3D {
       perimeter,
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding,
-      findingSites: findingSites || []
+      findingSites: findingSites || [],
+      use3DSpatialCoordinates: false
+    };
+  }
+  static getTID300RepresentationArgumentsSCOORD3D(tool) {
+    const {
+      data,
+      finding,
+      findingSites,
+      metadata
+    } = tool;
+    const {
+      cachedStats = {},
+      handles
+    } = data;
+    const corners = handles.points;
+    const {
+      area,
+      perimeter
+    } = cachedStats;
+    return {
+      points: [corners[0], corners[1], corners[3], corners[2], corners[0]],
+      area,
+      perimeter,
+      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
+      finding,
+      findingSites: findingSites || [],
+      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
+      use3DSpatialCoordinates: true
     };
   }
 }
@@ -4576,13 +5544,14 @@ const {
 } = dcmjs_es/* utilities */.BF.TID300;
 const Length_LENGTH = "Length";
 class Length_Length extends BaseAdapter3D {
-  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
-    const {
+  static getMeasurementDataFromScoord(_ref) {
+    let {
       defaultState,
       NUMGroup,
       SCOORDGroup,
-      ReferencedFrameNumber
-    } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
+      ReferencedFrameNumber,
+      imageToWorldCoords
+    } = _ref;
     const referencedImageId = defaultState.annotation.metadata.referencedImageId;
     const {
       GraphicData
@@ -4610,6 +5579,53 @@ class Length_Length extends BaseAdapter3D {
     };
     return state;
   }
+  static getMeasurementDataFromScoord3d(_ref2) {
+    let {
+      defaultState,
+      SCOORD3DGroup
+    } = _ref2;
+    const {
+      GraphicData
+    } = SCOORD3DGroup;
+    const worldCoords = GraphicData;
+    const state = defaultState;
+    state.annotation.data = {
+      handles: {
+        points: [worldCoords.slice(0, 3), worldCoords.slice(3, 6)],
+        activeHandleIndex: 0,
+        textBox: {
+          hasMoved: false
+        }
+      },
+      cachedStats: {}
+    };
+    return state;
+  }
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+    const {
+      defaultState,
+      NUMGroup,
+      SCOORDGroup,
+      SCOORD3DGroup,
+      ReferencedFrameNumber
+    } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
+    if (SCOORDGroup) {
+      return this.getMeasurementDataFromScoord({
+        defaultState,
+        NUMGroup,
+        SCOORDGroup,
+        ReferencedFrameNumber,
+        imageToWorldCoords
+      });
+    } else if (SCOORD3DGroup) {
+      return this.getMeasurementDataFromScoord3d({
+        defaultState,
+        SCOORD3DGroup
+      });
+    } else {
+      throw new Error("Can't get measurement data with missing SCOORD and SCOORD3D groups.");
+    }
+  }
   static getTID300RepresentationArguments(tool, worldToImageCoords) {
     const {
       data,
@@ -4625,7 +5641,7 @@ class Length_Length extends BaseAdapter3D {
       referencedImageId
     } = metadata;
     if (!referencedImageId) {
-      throw new Error("Length.getTID300RepresentationArguments: referencedImageId is not defined");
+      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
     }
     const start = worldToImageCoords(referencedImageId, handles.points[0]);
     const end = worldToImageCoords(referencedImageId, handles.points[1]);
@@ -4646,7 +5662,46 @@ class Length_Length extends BaseAdapter3D {
       distance,
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding,
-      findingSites: findingSites || []
+      findingSites: findingSites || [],
+      use3DSpatialCoordinates: false
+    };
+  }
+  static getTID300RepresentationArgumentsSCOORD3D(tool) {
+    const {
+      data,
+      finding,
+      findingSites,
+      metadata
+    } = tool;
+    const {
+      cachedStats = {},
+      handles
+    } = data;
+    const start = handles.points[0];
+    const end = handles.points[1];
+    const point1 = {
+      x: start[0],
+      y: start[1],
+      z: start[2]
+    };
+    const point2 = {
+      x: end[0],
+      y: end[1],
+      z: end[2]
+    };
+    const cachedStatsKeys = Object.keys(cachedStats)[0];
+    const {
+      length: distance
+    } = cachedStatsKeys ? cachedStats[cachedStatsKeys] : {};
+    return {
+      point1,
+      point2,
+      distance,
+      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
+      finding,
+      findingSites: findingSites || [],
+      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
+      use3DSpatialCoordinates: true
     };
   }
 }
@@ -4674,8 +5729,34 @@ class PlanarFreehandROI extends BaseAdapter3D {
       defaultState,
       NUMGroup,
       SCOORDGroup,
+      SCOORD3DGroup,
       ReferencedFrameNumber
     } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, PlanarFreehandROI.toolType);
+    if (SCOORDGroup) {
+      return this.getMeasurementDataFromScoord({
+        defaultState,
+        SCOORDGroup,
+        imageToWorldCoords,
+        NUMGroup,
+        ReferencedFrameNumber
+      });
+    } else if (SCOORD3DGroup) {
+      return this.getMeasurementDataFromScoord3D({
+        defaultState,
+        SCOORD3DGroup
+      });
+    } else {
+      throw new Error("Can't get measurement data with missing SCOORD and SCOORD3D groups.");
+    }
+  }
+  static getMeasurementDataFromScoord(_ref) {
+    let {
+      defaultState,
+      SCOORDGroup,
+      imageToWorldCoords,
+      NUMGroup,
+      ReferencedFrameNumber
+    } = _ref;
     const referencedImageId = defaultState.annotation.metadata.referencedImageId;
     const {
       GraphicData
@@ -4685,7 +5766,7 @@ class PlanarFreehandROI extends BaseAdapter3D {
       const point = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
       worldCoords.push(point);
     }
-    const distanceBetweenFirstAndLastPoint = esm/* vec3.distance */.eR.distance(worldCoords[worldCoords.length - 1], worldCoords[0]);
+    const distanceBetweenFirstAndLastPoint = gl_matrix_esm/* vec3.distance */.eR.distance(worldCoords[worldCoords.length - 1], worldCoords[0]);
     let isOpenContour = true;
     if (distanceBetweenFirstAndLastPoint < this.closedContourThreshold) {
       worldCoords.pop();
@@ -4717,6 +5798,46 @@ class PlanarFreehandROI extends BaseAdapter3D {
     };
     return state;
   }
+  static getMeasurementDataFromScoord3D(_ref2) {
+    let {
+      defaultState,
+      SCOORD3DGroup
+    } = _ref2;
+    const {
+      GraphicData
+    } = SCOORD3DGroup;
+    const worldCoords = [];
+    for (let i = 0; i < GraphicData.length; i += 3) {
+      const point = [GraphicData[i], GraphicData[i + 1], GraphicData[i + 2]];
+      worldCoords.push(point);
+    }
+    const distanceBetweenFirstAndLastPoint = gl_matrix_esm/* vec3.distance */.eR.distance(worldCoords[worldCoords.length - 1], worldCoords[0]);
+    let isOpenContour = true;
+    if (distanceBetweenFirstAndLastPoint < this.closedContourThreshold) {
+      worldCoords.pop();
+      isOpenContour = false;
+    }
+    const points = [];
+    if (isOpenContour) {
+      points.push(worldCoords[0], worldCoords[worldCoords.length - 1]);
+    }
+    const state = defaultState;
+    state.annotation.data = {
+      contour: {
+        polyline: worldCoords,
+        closed: !isOpenContour
+      },
+      handles: {
+        points,
+        activeHandleIndex: null,
+        textBox: {
+          hasMoved: false
+        }
+      },
+      cachedStats: {}
+    };
+    return state;
+  }
   static getTID300RepresentationArguments(tool, worldToImageCoords) {
     const {
       data,
@@ -4733,7 +5854,7 @@ class PlanarFreehandROI extends BaseAdapter3D {
       referencedImageId
     } = metadata;
     if (!referencedImageId) {
-      throw new Error("PlanarFreehandROI.getTID300RepresentationArguments: referencedImageId is not defined");
+      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
     }
     const points = polyline.map(worldPos => worldToImageCoords(referencedImageId, worldPos));
     if (!isOpenContour) {
@@ -4760,7 +5881,51 @@ class PlanarFreehandROI extends BaseAdapter3D {
       stdDev,
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding,
-      findingSites: findingSites || []
+      findingSites: findingSites || [],
+      use3DSpatialCoordinates: false
+    };
+  }
+  static getTID300RepresentationArgumentsSCOORD3D(tool) {
+    const {
+      data,
+      finding,
+      findingSites,
+      metadata
+    } = tool;
+    const {
+      polyline,
+      closed
+    } = data.contour;
+    const isOpenContour = closed !== true;
+    const points = polyline;
+    if (!isOpenContour) {
+      const firstPoint = points[0];
+      points.push([firstPoint[0], firstPoint[1], firstPoint[2]]);
+    }
+    const cachedStatsKeys = Object.keys(data.cachedStats)[0];
+    const {
+      area,
+      areaUnit,
+      modalityUnit,
+      perimeter,
+      mean,
+      max,
+      stdDev
+    } = cachedStatsKeys ? data.cachedStats[cachedStatsKeys] : {};
+    return {
+      points,
+      area,
+      areaUnit,
+      perimeter,
+      modalityUnit,
+      mean,
+      max,
+      stdDev,
+      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
+      finding,
+      findingSites: findingSites || [],
+      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
+      use3DSpatialCoordinates: true
     };
   }
 }
@@ -4784,8 +5949,32 @@ class Probe extends BaseAdapter3D {
     const state = super.getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata, trackingIdentifier);
     const {
       defaultState,
-      SCOORDGroup
+      SCOORDGroup,
+      SCOORD3DGroup
     } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, Probe.toolType);
+    if (SCOORDGroup) {
+      return this.getMeasurementDataFromScoord({
+        state,
+        defaultState,
+        SCOORDGroup,
+        imageToWorldCoords
+      });
+    } else if (SCOORD3DGroup) {
+      return this.getMeasurementDataFromScoord3D({
+        state,
+        SCOORD3DGroup
+      });
+    } else {
+      throw new Error("Can't get measurement data with missing SCOORD and SCOORD3D groups.");
+    }
+  }
+  static getMeasurementDataFromScoord(_ref) {
+    let {
+      state,
+      defaultState,
+      SCOORDGroup,
+      imageToWorldCoords
+    } = _ref;
     const referencedImageId = defaultState.annotation.metadata.referencedImageId;
     const {
       GraphicData
@@ -4807,6 +5996,93 @@ class Probe extends BaseAdapter3D {
     };
     return state;
   }
+  static getMeasurementDataFromScoord3D(_ref2) {
+    let {
+      state,
+      SCOORD3DGroup
+    } = _ref2;
+    const {
+      GraphicData
+    } = SCOORD3DGroup;
+    const worldCoords = [];
+    for (let i = 0; i < GraphicData.length; i += 3) {
+      const point = [GraphicData[i], GraphicData[i + 1], GraphicData[i + 2]];
+      worldCoords.push(point);
+    }
+    state.annotation.data = {
+      ...state.annotation.data,
+      handles: {
+        points: worldCoords,
+        activeHandleIndex: null,
+        textBox: {
+          hasMoved: false
+        }
+      }
+    };
+    return state;
+  }
+  static getTID300RepresentationArguments(tool, worldToImageCoords) {
+    const {
+      data,
+      metadata
+    } = tool;
+    const {
+      finding,
+      findingSites
+    } = tool;
+    const {
+      referencedImageId
+    } = metadata;
+    if (!referencedImageId) {
+      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
+    }
+    const {
+      handles: {
+        points = []
+      }
+    } = data;
+    const pointsImage = points.map(point => {
+      const pointImage = worldToImageCoords(referencedImageId, point);
+      return {
+        x: pointImage[0],
+        y: pointImage[1]
+      };
+    });
+    return {
+      points: pointsImage,
+      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
+      findingSites: findingSites || [],
+      finding,
+      use3DSpatialCoordinates: false
+    };
+  }
+  static getTID300RepresentationArgumentsSCOORD3D(tool) {
+    const {
+      data,
+      finding,
+      findingSites,
+      metadata
+    } = tool;
+    const {
+      handles: {
+        points = []
+      }
+    } = data;
+    const point = points[0];
+    const pointXYZ = {
+      x: point[0],
+      y: point[1],
+      z: point[2]
+    };
+    return {
+      points: [pointXYZ],
+      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
+      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
+      findingSites: findingSites || [],
+      finding,
+      use3DSpatialCoordinates: true
+    };
+  }
 }
 _Probe = Probe;
 (() => {
@@ -4972,10 +6248,8 @@ function generateLabelMaps2DFrom3D(labelmap3D) {
 
 
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
-var dist_esm = __webpack_require__(15327);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/index.js
-var tools_dist_esm = __webpack_require__(4667);
+var dist_esm = __webpack_require__(4667);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/adapters/dist/esm/adapters/Cornerstone3D/Segmentation/compactMergeSegData.js
 const checkHasOverlapping = _ref => {
   let {
@@ -5166,7 +6440,7 @@ async function createLabelmapsFromBufferInternal(referencedImageIds, arrayBuffer
     const referenceImageId = referencedImageIds[i];
     imageIdMaps.indices[referenceImageId] = i;
     imageIdMaps.metadata[referenceImageId] = metadataProvider.get("instance", referenceImageId);
-    const labelMapImage = dist_esm.imageLoader.createAndCacheDerivedLabelmapImage(referenceImageId);
+    const labelMapImage = esm.imageLoader.createAndCacheDerivedLabelmapImage(referenceImageId);
     labelMapImages.push(labelMapImage);
   }
   const segmentsPixelIndices = new Map();
@@ -5200,8 +6474,8 @@ async function createLabelmapsFromBufferInternal(referencedImageIds, arrayBuffer
     overlappingSegments: hasOverlappingSegments
   };
 }
-const throttledTriggerLoadProgressEvent = tools_dist_esm.utilities.throttle(percentComplete => {
-  (0,dist_esm.triggerEvent)(dist_esm.eventTarget, Events.SEGMENTATION_LOAD_PROGRESS, {
+const throttledTriggerLoadProgressEvent = dist_esm.utilities.throttle(percentComplete => {
+  (0,esm.triggerEvent)(esm.eventTarget, Events.SEGMENTATION_LOAD_PROGRESS, {
     percentComplete
   });
 }, 200);
@@ -5309,7 +6583,72 @@ function labelmapImagesFromBuffer_insertPixelDataPlanar(_ref4) {
         });
       }
     };
-    processChunk(0);
+    const processLabelmapChunk = firstIndex => {
+      const pfSeq = multiframe.PerFrameFunctionalGroupsSequence;
+      const sharedPlaneOrientation = multiframe.SharedFunctionalGroupsSequence.PlaneOrientationSequence?.ImageOrientationPatient;
+      for (let i = firstIndex; i < firstIndex + imagesPerChunk && i < groupsLen; i++) {
+        const PerFrameFunctionalGroups = pfSeq[i];
+        const ImageOrientationPatientI = sharedPlaneOrientation || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
+        const view = pixelDataChunks.subarray(i * sliceLength, (i + 1) * sliceLength);
+        const pixelDataI2D = ndarray_default()(view, [Rows, Columns]);
+        const alignedPixelDataI = Segmentation_4X_alignPixelDataWithSourceData(pixelDataI2D, ImageOrientationPatientI, validOrientations, tolerance);
+        if (!alignedPixelDataI) {
+          throw new Error("Individual Labelmap SEG frames are out of plane with respect to the first SEG frame. " + "This is not yet supported. Aborting segmentation loading.");
+        }
+        const imageId = findReferenceSourceImageId(multiframe, i, referencedImageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
+        if (!imageId) {
+          console.warn(`Image not present in stack, can't import frame : ${i}.`);
+          continue;
+        }
+        const sourceImageMetadata = imageIdMaps.metadata[imageId];
+        if (Rows !== sourceImageMetadata.Rows || Columns !== sourceImageMetadata.Columns) {
+          throw new Error("Individual Labelmap SEG frames have different geometry dimensions (Rows and Columns) " + "respect to the source image reference frame. This is not yet supported. " + "Aborting segmentation loading. ");
+        }
+        const imageIdIndex = imageIdMaps.indices[imageId];
+        const labelmapImage = labelMapImages[imageIdIndex];
+        const labelmap2DView = labelmapImage.getPixelData();
+        const data = alignedPixelDataI.data;
+        let segmentsOnFrameArr = segmentsOnFrame[imageIdIndex];
+        if (!segmentsOnFrameArr) {
+          segmentsOnFrameArr = [];
+          segmentsOnFrame[imageIdIndex] = segmentsOnFrameArr;
+        }
+        const segSet = new Set(segmentsOnFrameArr);
+        for (let k = 0, len = data.length; k < len; ++k) {
+          const segIdx = data[k];
+          if (segIdx !== 0) {
+            labelmap2DView[k] = segIdx;
+            if (!segSet.has(segIdx)) {
+              segmentsOnFrameArr.push(segIdx);
+              segSet.add(segIdx);
+            }
+            if (!segmentsPixelIndices.has(segIdx)) {
+              segmentsPixelIndices.set(segIdx, {});
+            }
+            const segmentPixelInfo = segmentsPixelIndices.get(segIdx);
+            if (!segmentPixelInfo[imageIdIndex]) {
+              segmentPixelInfo[imageIdIndex] = [];
+            }
+            segmentPixelInfo[imageIdIndex].push(k);
+          }
+        }
+      }
+      const percentComplete = Math.round(firstIndex / groupsLen * 100);
+      throttledTriggerLoadProgressEvent(percentComplete);
+      if (firstIndex < groupsLen) {
+        setTimeout(() => processLabelmapChunk(firstIndex + imagesPerChunk), 0);
+      } else {
+        resolve({
+          hasOverlappingSegments: false,
+          arrayOfLabelMapImages: [labelMapImages]
+        });
+      }
+    };
+    if (multiframe.SegmentationType === "LABELMAP") {
+      processLabelmapChunk(0);
+    } else {
+      processChunk(0);
+    }
   });
 }
 const getAlignedPixelData = _ref5 => {
@@ -5360,7 +6699,7 @@ const getArrayOfLabelMapImagesWithSegmentData = _ref7 => {
   return arrayOfSegmentData.map(arr => {
     const labelMapImages = referencedImageIds.map((referencedImageId, i) => {
       const hasEmptySegmentData = !arr[i];
-      const labelMapImage = dist_esm.imageLoader.createAndCacheDerivedLabelmapImage(referencedImageId);
+      const labelMapImage = esm.imageLoader.createAndCacheDerivedLabelmapImage(referencedImageId);
       const pixelData = labelMapImage.getPixelData();
       if (!hasEmptySegmentData) {
         for (let j = 0; j < pixelData.length; j++) {
@@ -5739,7 +7078,7 @@ function getStructureSetModule(contour, index) {
 const {
   generateContourSetsFromLabelmap,
   AnnotationToPointData
-} = tools_dist_esm.utilities.contours;
+} = dist_esm.utilities.contours;
 const {
   DicomMetaDictionary: RTSS_DicomMetaDictionary
 } = dcmjs_es/* default.data */.Ay.data;
@@ -5915,7 +7254,7 @@ function _initializeDataset(rtMetadata, imgMetadata, metadataProvider) {
 
 const {
   generateContourSetsFromLabelmap: RTStruct_generateContourSetsFromLabelmap
-} = tools_dist_esm.utilities.contours;
+} = dist_esm.utilities.contours;
 
 
 
@@ -6288,6 +7627,7 @@ function downloadDICOMData(bufferOrDataset, filename) {
 
 
 
+
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/adapters/dist/esm/index.js
 
 
@@ -6296,6 +7636,7 @@ function downloadDICOMData(bufferOrDataset, filename) {
 
 
 
+
 /***/ }),
 
 /***/ 75183:
@@ -6344,6 +7685,7 @@ var Events;
     Events["ANNOTATION_LOCK_CHANGE"] = "CORNERSTONE_TOOLS_ANNOTATION_LOCK_CHANGE";
     Events["ANNOTATION_VISIBILITY_CHANGE"] = "CORNERSTONE_TOOLS_ANNOTATION_VISIBILITY_CHANGE";
     Events["ANNOTATION_RENDERED"] = "CORNERSTONE_TOOLS_ANNOTATION_RENDERED";
+    Events["ANNOTATION_CUT_MERGE_PROCESS_COMPLETED"] = "CORNERSTONE_TOOLS_ANNOTATION_CUT_MERGE_PROCESS_COMPLETED";
     Events["ANNOTATION_INTERPOLATION_PROCESS_COMPLETED"] = "CORNERSTONE_TOOLS_ANNOTATION_INTERPOLATION_PROCESS_COMPLETED";
     Events["INTERPOLATED_ANNOTATIONS_REMOVED"] = "CORNERSTONE_TOOLS_INTERPOLATED_ANNOTATIONS_REMOVED";
     Events["SEGMENTATION_MODIFIED"] = "CORNERSTONE_TOOLS_SEGMENTATION_MODIFIED";