@cornerstonejs/adapters 5.0.0-beta.1 → 5.0.1

package/dist/esm/adapters/Cornerstone3D/Segmentation/labelmapImagesFromBuffer.d.ts

@@ -8,7 +8,7 @@ declare function createLabelmapsFromBufferInternal(referencedImageIds: any, arra
     centroids: Map<any, any>;
     overlappingSegments: any;
 }>;
-export declare function insertPixelDataPlanar({ segmentsOnFrame, labelMapImages, pixelDataChunks, multiframe, referencedImageIds, validOrientations, metadataProvider, tolerance, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps }: {
+export declare function insertPixelDataPlanar({ segmentsOnFrame, labelMapImages, pixelDataChunks, multiframe, referencedImageIds, validOrientations, metadataProvider, tolerance, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps, }: {
     segmentsOnFrame: any;
     labelMapImages: any;
     pixelDataChunks: any;
@@ -21,7 +21,7 @@ export declare function insertPixelDataPlanar({ segmentsOnFrame, labelMapImages,
     sopUIDImageIdIndexMap: any;
     imageIdMaps: any;
 }): Promise<unknown>;
-export declare function insertOverlappingPixelDataPlanar({ segmentsOnFrame, labelMapImages, pixelDataChunks, multiframe, referencedImageIds, validOrientations, metadataProvider, tolerance, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps }: {
+export declare function insertOverlappingPixelDataPlanar({ segmentsOnFrame, labelMapImages, pixelDataChunks, multiframe, referencedImageIds, validOrientations, metadataProvider, tolerance, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps, }: {
     segmentsOnFrame: any;
     labelMapImages: any;
     pixelDataChunks: any;

package/dist/esm/adapters/Cornerstone3D/Segmentation/labelmapImagesFromBuffer.js

@@ -1,40 +1,30 @@
 import { triggerEvent, eventTarget, imageLoader } from '@cornerstonejs/core';
 import { utilities as utilities$1 } from '@cornerstonejs/tools';
-import { utilities, data, normalizers } from 'dcmjs';
+import { data, normalizers, utilities } from 'dcmjs';
 import ndarray from 'ndarray';
 import checkOrientation from '../../helpers/checkOrientation.js';
 import { getValidOrientations, getSegmentMetadata, unpackPixelData, calculateCentroid, readFromUnpackedChunks, alignPixelDataWithSourceData, getSegmentIndex, findReferenceSourceImageId } from '../../Cornerstone/Segmentation_4X.js';
 import { compactMergeSegmentDataWithoutInformationLoss } from './compactMergeSegData.js';
 import { Events } from '../../enums/Events.js';
 
-const {
-  DicomMessage,
-  DicomMetaDictionary
-} = data;
-const {
-  Normalizer
-} = normalizers;
-const {
-  decode
-} = utilities.compression;
+const DicomMessage = data.DicomMessage,
+  DicomMetaDictionary = data.DicomMetaDictionary;
+const Normalizer = normalizers.Normalizer;
+const decode = utilities.compression.decode;
 const updateSegmentsOnFrame = _ref => {
-  let {
-    segmentsOnFrame,
-    imageIdIndex,
-    segmentIndex
-  } = _ref;
+  let segmentsOnFrame = _ref.segmentsOnFrame,
+    imageIdIndex = _ref.imageIdIndex,
+    segmentIndex = _ref.segmentIndex;
   if (!segmentsOnFrame[imageIdIndex]) {
     segmentsOnFrame[imageIdIndex] = [];
   }
   segmentsOnFrame[imageIdIndex].push(segmentIndex);
 };
 const updateSegmentsPixelIndices = _ref2 => {
-  let {
-    segmentsPixelIndices,
-    segmentIndex,
-    imageIdIndex,
-    indexCache
-  } = _ref2;
+  let segmentsPixelIndices = _ref2.segmentsPixelIndices,
+    segmentIndex = _ref2.segmentIndex,
+    imageIdIndex = _ref2.imageIdIndex,
+    indexCache = _ref2.indexCache;
   if (!segmentsPixelIndices.has(segmentIndex)) {
     segmentsPixelIndices.set(segmentIndex, {});
   }
@@ -43,12 +33,10 @@ const updateSegmentsPixelIndices = _ref2 => {
   segmentsPixelIndices.set(segmentIndex, segmentIndexObject);
 };
 const extractInfoFromPerFrameFunctionalGroups = _ref3 => {
-  let {
-    PerFrameFunctionalGroups,
-    sequenceIndex,
-    sopUIDImageIdIndexMap,
-    multiframe
-  } = _ref3;
+  let PerFrameFunctionalGroups = _ref3.PerFrameFunctionalGroups,
+    sequenceIndex = _ref3.sequenceIndex,
+    sopUIDImageIdIndexMap = _ref3.sopUIDImageIdIndexMap,
+    multiframe = _ref3.multiframe;
   const referencedSOPInstanceUid = PerFrameFunctionalGroups.DerivationImageSequence[0].SourceImageSequence[0].ReferencedSOPInstanceUID;
   const referencedImageId = sopUIDImageIdIndexMap[referencedSOPInstanceUid];
   const segmentIndex = getSegmentIndex(multiframe, sequenceIndex);
@@ -59,20 +47,21 @@ const extractInfoFromPerFrameFunctionalGroups = _ref3 => {
   };
 };
 async function createLabelmapsFromBufferInternal(referencedImageIds, arrayBuffer, metadataProvider, options) {
-  const {
-    tolerance = 1e-3,
-    TypedArrayConstructor = Uint8Array,
-    maxBytesPerChunk = 199000000
-  } = options;
+  const _options$tolerance = options.tolerance,
+    tolerance = _options$tolerance === void 0 ? 1e-3 : _options$tolerance,
+    _options$TypedArrayCo = options.TypedArrayConstructor,
+    TypedArrayConstructor = _options$TypedArrayCo === void 0 ? Uint8Array : _options$TypedArrayCo,
+    _options$maxBytesPerC = options.maxBytesPerChunk,
+    maxBytesPerChunk = _options$maxBytesPerC === void 0 ? 199000000 : _options$maxBytesPerC;
   const dicomData = DicomMessage.readFile(arrayBuffer);
   const dataset = DicomMetaDictionary.naturalizeDataset(dicomData.dict);
   dataset._meta = DicomMetaDictionary.namifyDataset(dicomData.meta);
   const multiframe = Normalizer.normalizeToDataset([dataset]);
-  const imagePlaneModule = metadataProvider.get("imagePlaneModule", referencedImageIds[0]);
-  const generalSeriesModule = metadataProvider.get("generalSeriesModule", referencedImageIds[0]);
+  const imagePlaneModule = metadataProvider.get('imagePlaneModule', referencedImageIds[0]);
+  const generalSeriesModule = metadataProvider.get('generalSeriesModule', referencedImageIds[0]);
   const SeriesInstanceUID = generalSeriesModule.seriesInstanceUID;
   if (!imagePlaneModule) {
-    console.warn("Insufficient metadata, imagePlaneModule missing.");
+    console.warn('Insufficient metadata, imagePlaneModule missing.');
   }
   const ImageOrientationPatient = Array.isArray(imagePlaneModule.rowCosines) ? [...imagePlaneModule.rowCosines, ...imagePlaneModule.columnCosines] : [imagePlaneModule.rowCosines.x, imagePlaneModule.rowCosines.y, imagePlaneModule.rowCosines.z, imagePlaneModule.columnCosines.x, imagePlaneModule.columnCosines.y, imagePlaneModule.columnCosines.z];
   const validOrientations = getValidOrientations(ImageOrientationPatient);
@@ -80,11 +69,11 @@ async function createLabelmapsFromBufferInternal(referencedImageIds, arrayBuffer
   const TransferSyntaxUID = multiframe._meta.TransferSyntaxUID.Value[0];
   let pixelData;
   let pixelDataChunks;
-  if (TransferSyntaxUID === "1.2.840.10008.1.2.5") {
+  if (TransferSyntaxUID === '1.2.840.10008.1.2.5') {
     const rleEncodedFrames = Array.isArray(multiframe.PixelData) ? multiframe.PixelData : [multiframe.PixelData];
     pixelData = decode(rleEncodedFrames, multiframe.Rows, multiframe.Columns);
     if (multiframe.BitsStored === 1) {
-      console.warn("No implementation for rle + bit packing.");
+      console.warn('No implementation for rle + bit packing.');
       return;
     }
     pixelDataChunks = [pixelData];
@@ -93,26 +82,25 @@ async function createLabelmapsFromBufferInternal(referencedImageIds, arrayBuffer
       maxBytesPerChunk
     });
     if (!pixelDataChunks) {
-      throw new Error("Fractional segmentations are not yet supported");
+      throw new Error('Fractional segmentations are not yet supported');
     }
   }
   const orientation = checkOrientation(multiframe, validOrientations, [imagePlaneModule.rows, imagePlaneModule.columns, referencedImageIds.length], tolerance);
   const sopUIDImageIdIndexMap = referencedImageIds.reduce((acc, imageId) => {
-    const {
-      sopInstanceUID
-    } = metadataProvider.get("generalImageModule", imageId);
+    const _metadataProvider$get = metadataProvider.get('generalImageModule', imageId),
+      sopInstanceUID = _metadataProvider$get.sopInstanceUID;
     acc[sopInstanceUID] = imageId;
     return acc;
   }, {});
   let insertFunction;
   switch (orientation) {
-    case "Planar":
+    case 'Planar':
       insertFunction = insertPixelDataPlanar;
       break;
-    case "Perpendicular":
-      throw new Error("Segmentations orthogonal to the acquisition plane of the source data are not yet supported.");
-    case "Oblique":
-      throw new Error("Segmentations oblique to the acquisition plane of the source data are not yet supported.");
+    case 'Perpendicular':
+      throw new Error('Segmentations orthogonal to the acquisition plane of the source data are not yet supported.');
+    case 'Oblique':
+      throw new Error('Segmentations oblique to the acquisition plane of the source data are not yet supported.');
   }
   const segmentsOnFrame = [];
   const imageIdMaps = {
@@ -123,28 +111,27 @@ async function createLabelmapsFromBufferInternal(referencedImageIds, arrayBuffer
   for (let i = 0; i < referencedImageIds.length; i++) {
     const referenceImageId = referencedImageIds[i];
     imageIdMaps.indices[referenceImageId] = i;
-    imageIdMaps.metadata[referenceImageId] = metadataProvider.get("instance", referenceImageId);
+    imageIdMaps.metadata[referenceImageId] = metadataProvider.get('instance', referenceImageId);
     const labelMapImage = imageLoader.createAndCacheDerivedLabelmapImage(referenceImageId);
     labelMapImages.push(labelMapImage);
   }
   const segmentsPixelIndices = new Map();
-  const {
-    hasOverlappingSegments,
-    arrayOfLabelMapImages
-  } = await insertFunction({
-    segmentsOnFrame,
-    labelMapImages,
-    pixelDataChunks,
-    multiframe,
-    referencedImageIds,
-    validOrientations,
-    metadataProvider,
-    tolerance,
-    segmentsPixelIndices,
-    sopUIDImageIdIndexMap,
-    imageIdMaps,
-    TypedArrayConstructor
-  });
+  const _await$insertFunction = await insertFunction({
+      segmentsOnFrame,
+      labelMapImages,
+      pixelDataChunks,
+      multiframe,
+      referencedImageIds,
+      validOrientations,
+      metadataProvider,
+      tolerance,
+      segmentsPixelIndices,
+      sopUIDImageIdIndexMap,
+      imageIdMaps,
+      TypedArrayConstructor
+    }),
+    hasOverlappingSegments = _await$insertFunction.hasOverlappingSegments,
+    arrayOfLabelMapImages = _await$insertFunction.arrayOfLabelMapImages;
   const centroidXYZ = new Map();
   segmentsPixelIndices.forEach((imageIdIndexBufferIndex, segmentIndex) => {
     const centroids = calculateCentroid(imageIdIndexBufferIndex, multiframe, metadataProvider, referencedImageIds);
@@ -164,25 +151,21 @@ const throttledTriggerLoadProgressEvent = utilities$1.throttle(percentComplete =
   });
 }, 200);
 function insertPixelDataPlanar(_ref4) {
-  let {
-    segmentsOnFrame,
-    labelMapImages,
-    pixelDataChunks,
-    multiframe,
-    referencedImageIds,
-    validOrientations,
-    metadataProvider,
-    tolerance,
-    segmentsPixelIndices,
-    sopUIDImageIdIndexMap,
-    imageIdMaps
-  } = _ref4;
-  const {
-    SharedFunctionalGroupsSequence,
-    PerFrameFunctionalGroupsSequence,
-    Rows,
-    Columns
-  } = multiframe;
+  let segmentsOnFrame = _ref4.segmentsOnFrame,
+    labelMapImages = _ref4.labelMapImages,
+    pixelDataChunks = _ref4.pixelDataChunks,
+    multiframe = _ref4.multiframe,
+    referencedImageIds = _ref4.referencedImageIds,
+    validOrientations = _ref4.validOrientations,
+    metadataProvider = _ref4.metadataProvider,
+    tolerance = _ref4.tolerance,
+    segmentsPixelIndices = _ref4.segmentsPixelIndices,
+    sopUIDImageIdIndexMap = _ref4.sopUIDImageIdIndexMap,
+    imageIdMaps = _ref4.imageIdMaps;
+  const SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence,
+    PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
+    Rows = multiframe.Rows,
+    Columns = multiframe.Columns;
   const sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence ? SharedFunctionalGroupsSequence.PlaneOrientationSequence.ImageOrientationPatient : undefined;
   const sliceLength = Columns * Rows;
   const groupsLen = PerFrameFunctionalGroupsSequence.length;
@@ -198,23 +181,23 @@ function insertPixelDataPlanar(_ref4) {
         const pixelDataI2D = ndarray(view, [Rows, Columns]);
         const alignedPixelDataI = alignPixelDataWithSourceData(pixelDataI2D, ImageOrientationPatientI, validOrientations, tolerance);
         if (!alignedPixelDataI) {
-          throw new Error("Individual SEG frames are out of plane with respect to the first SEG frame. " + "This is not yet supported. Aborting segmentation loading.");
+          throw new Error('Individual SEG frames are out of plane with respect to the first SEG frame. ' + 'This is not yet supported. Aborting segmentation loading.');
         }
         const segmentIndex = getSegmentIndex(multiframe, i);
         if (segmentIndex === undefined) {
-          throw new Error("Could not retrieve the segment index. Aborting segmentation loading.");
+          throw new Error('Could not retrieve the segment index. Aborting segmentation loading.');
         }
         if (!segmentsPixelIndices.has(segmentIndex)) {
           segmentsPixelIndices.set(segmentIndex, {});
         }
         const imageId = findReferenceSourceImageId(multiframe, i, referencedImageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
         if (!imageId) {
-          console.warn("Image not present in stack, can't import frame : " + i + ".");
+          console.warn("Image not present in stack, can't import frame : " + i + '.');
           return;
         }
         const sourceImageMetadata = imageIdMaps.metadata[imageId];
         if (Rows !== sourceImageMetadata.Rows || Columns !== sourceImageMetadata.Columns) {
-          throw new Error("Individual SEG frames have different geometry dimensions (Rows and Columns) " + "respect to the source image reference frame. This is not yet supported. " + "Aborting segmentation loading. ");
+          throw new Error('Individual SEG frames have different geometry dimensions (Rows and Columns) ' + 'respect to the source image reference frame. This is not yet supported. ' + 'Aborting segmentation loading. ');
         }
         const imageIdIndex = imageIdMaps.indices[imageId];
         const labelmapImage = labelMapImages[imageIdIndex];
@@ -283,7 +266,7 @@ function insertPixelDataPlanar(_ref4) {
         const pixelDataI2D = ndarray(view, [Rows, Columns]);
         const alignedPixelDataI = 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.");
+          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) {
@@ -292,7 +275,7 @@ function insertPixelDataPlanar(_ref4) {
         }
         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. ");
+          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];
@@ -334,7 +317,7 @@ function insertPixelDataPlanar(_ref4) {
         });
       }
     };
-    if (multiframe.SegmentationType === "LABELMAP") {
+    if (multiframe.SegmentationType === 'LABELMAP') {
       processLabelmapChunk(0);
     } else {
       processChunk(0);
@@ -342,43 +325,37 @@ function insertPixelDataPlanar(_ref4) {
   });
 }
 const getAlignedPixelData = _ref5 => {
-  let {
-    sharedImageOrientationPatient,
-    PerFrameFunctionalGroups,
-    pixelDataChunks,
-    sequenceIndex,
-    sliceLength,
-    Rows,
-    Columns,
-    validOrientations,
-    tolerance
-  } = _ref5;
+  let sharedImageOrientationPatient = _ref5.sharedImageOrientationPatient,
+    PerFrameFunctionalGroups = _ref5.PerFrameFunctionalGroups,
+    pixelDataChunks = _ref5.pixelDataChunks,
+    sequenceIndex = _ref5.sequenceIndex,
+    sliceLength = _ref5.sliceLength,
+    Rows = _ref5.Rows,
+    Columns = _ref5.Columns,
+    validOrientations = _ref5.validOrientations,
+    tolerance = _ref5.tolerance;
   const ImageOrientationPatientI = sharedImageOrientationPatient || PerFrameFunctionalGroups.PlaneOrientationSequence.ImageOrientationPatient;
   const view = readFromUnpackedChunks(pixelDataChunks, sequenceIndex * sliceLength, sliceLength);
   const pixelDataI2D = ndarray(view, [Rows, Columns]);
   const alignedPixelDataI = alignPixelDataWithSourceData(pixelDataI2D, ImageOrientationPatientI, validOrientations, tolerance);
   if (!alignedPixelDataI) {
-    throw new Error("Individual SEG frames are out of plane with respect to the first SEG frame. " + "This is not yet supported. Aborting segmentation loading.");
+    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.');
   }
   return alignedPixelDataI;
 };
 const checkImageDimensions = _ref6 => {
-  let {
-    metadataProvider,
-    imageId,
-    Rows,
-    Columns
-  } = _ref6;
-  const sourceImageMetadata = metadataProvider.get("instance", imageId);
+  let metadataProvider = _ref6.metadataProvider,
+    imageId = _ref6.imageId,
+    Rows = _ref6.Rows,
+    Columns = _ref6.Columns;
+  const sourceImageMetadata = metadataProvider.get('instance', imageId);
   if (Rows !== sourceImageMetadata.Rows || Columns !== sourceImageMetadata.Columns) {
-    throw new Error("Individual SEG frames have different geometry dimensions (Rows and Columns) " + "respect to the source image reference frame. This is not yet supported. " + "Aborting segmentation loading. ");
+    throw new Error('Individual SEG frames have different geometry dimensions (Rows and Columns) ' + 'respect to the source image reference frame. This is not yet supported. ' + 'Aborting segmentation loading. ');
   }
 };
 const getArrayOfLabelMapImagesWithSegmentData = _ref7 => {
-  let {
-    arrayOfSegmentData,
-    referencedImageIds
-  } = _ref7;
+  let arrayOfSegmentData = _ref7.arrayOfSegmentData,
+    referencedImageIds = _ref7.referencedImageIds;
   let largestArray = [];
   for (let i = 0; i < arrayOfSegmentData.length; i++) {
     const segmentData = arrayOfSegmentData[i];
@@ -402,25 +379,21 @@ const getArrayOfLabelMapImagesWithSegmentData = _ref7 => {
   });
 };
 function insertOverlappingPixelDataPlanar(_ref8) {
-  let {
-    segmentsOnFrame,
-    labelMapImages,
-    pixelDataChunks,
-    multiframe,
-    referencedImageIds,
-    validOrientations,
-    metadataProvider,
-    tolerance,
-    segmentsPixelIndices,
-    sopUIDImageIdIndexMap,
-    imageIdMaps
-  } = _ref8;
-  const {
-    SharedFunctionalGroupsSequence,
-    PerFrameFunctionalGroupsSequence,
-    Rows,
-    Columns
-  } = multiframe;
+  let segmentsOnFrame = _ref8.segmentsOnFrame,
+    labelMapImages = _ref8.labelMapImages,
+    pixelDataChunks = _ref8.pixelDataChunks,
+    multiframe = _ref8.multiframe,
+    referencedImageIds = _ref8.referencedImageIds,
+    validOrientations = _ref8.validOrientations,
+    metadataProvider = _ref8.metadataProvider,
+    tolerance = _ref8.tolerance,
+    segmentsPixelIndices = _ref8.segmentsPixelIndices,
+    sopUIDImageIdIndexMap = _ref8.sopUIDImageIdIndexMap,
+    imageIdMaps = _ref8.imageIdMaps;
+  const SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence,
+    PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
+    Rows = multiframe.Rows,
+    Columns = multiframe.Columns;
   const sharedImageOrientationPatient = SharedFunctionalGroupsSequence.PlaneOrientationSequence ? SharedFunctionalGroupsSequence.PlaneOrientationSequence.ImageOrientationPatient : undefined;
   const sliceLength = Columns * Rows;
   const arrayOfSegmentData = getArrayOfSegmentData({
@@ -450,23 +423,21 @@ function insertOverlappingPixelDataPlanar(_ref8) {
   };
 }
 const getArrayOfSegmentData = _ref9 => {
-  let {
-    sliceLength,
-    Rows,
-    Columns,
-    validOrientations,
-    metadataProvider,
-    imageIdMaps,
-    segmentsOnFrame,
-    tolerance,
-    pixelDataChunks,
-    PerFrameFunctionalGroupsSequence,
-    labelMapImages,
-    sopUIDImageIdIndexMap,
-    multiframe,
-    sharedImageOrientationPatient,
-    segmentsPixelIndices
-  } = _ref9;
+  let sliceLength = _ref9.sliceLength,
+    Rows = _ref9.Rows,
+    Columns = _ref9.Columns,
+    validOrientations = _ref9.validOrientations,
+    metadataProvider = _ref9.metadataProvider,
+    imageIdMaps = _ref9.imageIdMaps,
+    segmentsOnFrame = _ref9.segmentsOnFrame,
+    tolerance = _ref9.tolerance,
+    pixelDataChunks = _ref9.pixelDataChunks,
+    PerFrameFunctionalGroupsSequence = _ref9.PerFrameFunctionalGroupsSequence,
+    labelMapImages = _ref9.labelMapImages,
+    sopUIDImageIdIndexMap = _ref9.sopUIDImageIdIndexMap,
+    multiframe = _ref9.multiframe,
+    sharedImageOrientationPatient = _ref9.sharedImageOrientationPatient,
+    segmentsPixelIndices = _ref9.segmentsPixelIndices;
   const arrayOfSegmentData = [];
   const numberOfSegments = multiframe.SegmentSequence.length;
   for (let currentSegmentIndex = 1; currentSegmentIndex <= numberOfSegments; ++currentSegmentIndex) {
@@ -495,39 +466,36 @@ const getArrayOfSegmentData = _ref9 => {
   }
   return arrayOfSegmentData;
 };
-const getSegmentData = _ref10 => {
-  let {
-    PerFrameFunctionalGroupsSequence,
-    labelMapImages,
-    sopUIDImageIdIndexMap,
-    multiframe,
-    segmentIndex,
-    sliceLength,
-    Rows,
-    Columns,
-    validOrientations,
-    tolerance,
-    pixelDataChunks,
-    sharedImageOrientationPatient,
-    metadataProvider,
-    imageIdMaps,
-    segmentsOnFrame,
-    segmentsPixelIndices
-  } = _ref10;
+const getSegmentData = _ref0 => {
+  let PerFrameFunctionalGroupsSequence = _ref0.PerFrameFunctionalGroupsSequence,
+    labelMapImages = _ref0.labelMapImages,
+    sopUIDImageIdIndexMap = _ref0.sopUIDImageIdIndexMap,
+    multiframe = _ref0.multiframe,
+    segmentIndex = _ref0.segmentIndex,
+    sliceLength = _ref0.sliceLength,
+    Rows = _ref0.Rows,
+    Columns = _ref0.Columns,
+    validOrientations = _ref0.validOrientations,
+    tolerance = _ref0.tolerance,
+    pixelDataChunks = _ref0.pixelDataChunks,
+    sharedImageOrientationPatient = _ref0.sharedImageOrientationPatient,
+    metadataProvider = _ref0.metadataProvider,
+    imageIdMaps = _ref0.imageIdMaps,
+    segmentsOnFrame = _ref0.segmentsOnFrame,
+    segmentsPixelIndices = _ref0.segmentsPixelIndices;
   const segmentData = [];
   for (let currentLabelMapImageIndex = 0; currentLabelMapImageIndex < labelMapImages.length; currentLabelMapImageIndex++) {
     const currentLabelMapImage = labelMapImages[currentLabelMapImageIndex];
     const referencedImageId = currentLabelMapImage.referencedImageId;
     const PerFrameFunctionalGroupsIndex = PerFrameFunctionalGroupsSequence.findIndex((PerFrameFunctionalGroups, currentSequenceIndex) => {
-      const {
-        segmentIndex: groupsSegmentIndex,
-        referencedImageId: groupsReferenceImageId
-      } = extractInfoFromPerFrameFunctionalGroups({
-        PerFrameFunctionalGroups,
-        sequenceIndex: currentSequenceIndex,
-        sopUIDImageIdIndexMap,
-        multiframe
-      });
+      const _extractInfoFromPerFr = extractInfoFromPerFrameFunctionalGroups({
+          PerFrameFunctionalGroups,
+          sequenceIndex: currentSequenceIndex,
+          sopUIDImageIdIndexMap,
+          multiframe
+        }),
+        groupsSegmentIndex = _extractInfoFromPerFr.segmentIndex,
+        groupsReferenceImageId = _extractInfoFromPerFr.referencedImageId;
       const isCorrectPerFrameFunctionalGroup = groupsSegmentIndex === segmentIndex && groupsReferenceImageId === currentLabelMapImage.referencedImageId;
       return isCorrectPerFrameFunctionalGroup;
     });

package/dist/esm/adapters/Cornerstone3D/UltrasoundDirectional.d.ts

@@ -1,4 +1,4 @@
-import BaseAdapter3D from "./BaseAdapter3D";
+import BaseAdapter3D from './BaseAdapter3D';
 declare class UltrasoundDirectional extends BaseAdapter3D {
     static getMeasurementData(measurementGroup: any, sopInstanceUIDToImageIdMap: any, metadata: any): {
         description?: string;

package/dist/esm/adapters/Cornerstone3D/UltrasoundDirectional.js

@@ -1,4 +1,4 @@
-import _defineProperty from '../../node_modules/@babel/runtime/helpers/esm/defineProperty.js';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { utilities } from 'dcmjs';
 import { utilities as utilities$1 } from '@cornerstonejs/core';
 import MeasurementReport from './MeasurementReport.js';
@@ -7,19 +7,14 @@ import BaseAdapter3D from './BaseAdapter3D.js';
 var _UltrasoundDirectional;
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(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 e; }
-const {
-  Length: TID300Length
-} = utilities.TID300;
-const {
-  worldToImageCoords
-} = utilities$1;
+const TID300Length = utilities.TID300.Length;
+const worldToImageCoords = utilities$1.worldToImageCoords;
 class UltrasoundDirectional extends BaseAdapter3D {
   static getMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, metadata) {
-    const {
-      state,
-      worldCoords,
-      ReferencedFrameNumber
-    } = MeasurementReport.getSetupMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
+    const _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType),
+      state = _MeasurementReport$ge.state,
+      worldCoords = _MeasurementReport$ge.worldCoords,
+      ReferencedFrameNumber = _MeasurementReport$ge.ReferencedFrameNumber;
     state.annotation.data = _objectSpread(_objectSpread({}, state.annotation.data), {}, {
       handles: _objectSpread(_objectSpread({}, state.annotation.data.handles), {}, {
         points: worldCoords
@@ -29,20 +24,14 @@ class UltrasoundDirectional extends BaseAdapter3D {
     return state;
   }
   static getTID300RepresentationArguments(tool, is3DMeasurement) {
-    const {
-      data,
-      finding,
-      findingSites,
-      metadata
-    } = tool;
-    const {
-      handles
-    } = data;
-    const {
-      referencedImageId
-    } = metadata;
+    const data = tool.data,
+      finding = tool.finding,
+      findingSites = tool.findingSites,
+      metadata = tool.metadata;
+    const handles = data.handles;
+    const referencedImageId = metadata.referencedImageId;
     if (!referencedImageId) {
-      throw new Error("UltrasoundDirectionalTool.getTID300RepresentationArguments: referencedImageId is not defined");
+      throw new Error('UltrasoundDirectionalTool.getTID300RepresentationArguments: referencedImageId is not defined');
     }
     const start = worldToImageCoords(referencedImageId, handles.points[0]);
     const end = worldToImageCoords(referencedImageId, handles.points[1]);
@@ -64,6 +53,6 @@ class UltrasoundDirectional extends BaseAdapter3D {
   }
 }
 _UltrasoundDirectional = UltrasoundDirectional;
-_UltrasoundDirectional.init("UltrasoundDirectionalTool", TID300Length);
+_UltrasoundDirectional.init('UltrasoundDirectionalTool', TID300Length);
 
 export { UltrasoundDirectional as default };

package/dist/esm/adapters/Cornerstone3D/constants/index.d.ts

@@ -5,6 +5,16 @@ export declare const TEXT_ANNOTATION_POSITION: {
     meaning: string;
     value: string;
 };
+export declare const CONTROL_POINTS_CODE: {
+    schemeDesignator: string;
+    meaning: string;
+    value: string;
+};
+export declare const SPLINE_TYPE_CODE: {
+    schemeDesignator: string;
+    meaning: string;
+    value: string;
+};
 export declare const COMMENT_CODE: {
     schemeDesignator: string;
     meaning: string;

package/dist/esm/adapters/Cornerstone3D/constants/index.js

@@ -1,4 +1,4 @@
-import _defineProperty from '../../../node_modules/@babel/runtime/helpers/esm/defineProperty.js';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
 
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(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 e; }
@@ -9,6 +9,16 @@ const TEXT_ANNOTATION_POSITION = {
   meaning: 'Text Annotation Position',
   value: 'TextPosition'
 };
+const CONTROL_POINTS_CODE = {
+  schemeDesignator: CS3D_DESIGNATOR,
+  meaning: 'Control Points',
+  value: 'ControlPoints'
+};
+const SPLINE_TYPE_CODE = {
+  schemeDesignator: CS3D_DESIGNATOR,
+  meaning: 'Spline Type',
+  value: 'SplineType'
+};
 const COMMENT_CODE = {
   schemeDesignator: 'DCM',
   meaning: 'Comment',
@@ -47,4 +57,4 @@ const metaRTSSContour = _objectSpread(_objectSpread({}, metaSRAnnotation), {}, {
   }
 });
 
-export { COMMENT_CODE, CS3D_DESIGNATOR, ImplementationClassRtssContours, ImplementationClassUidSRAnnotation, NO_IMAGE_ID, TEXT_ANNOTATION_POSITION, fileMetaInformationVersionArray1, fileMetaInformationVersionArray2, metaRTSSContour, metaSRAnnotation };
+export { COMMENT_CODE, CONTROL_POINTS_CODE, CS3D_DESIGNATOR, ImplementationClassRtssContours, ImplementationClassUidSRAnnotation, NO_IMAGE_ID, SPLINE_TYPE_CODE, TEXT_ANNOTATION_POSITION, fileMetaInformationVersionArray1, fileMetaInformationVersionArray2, metaRTSSContour, metaSRAnnotation };