@cornerstonejs/adapters 5.0.0-beta.1 → 5.0.1

package/dist/esm/adapters/Cornerstone/Segmentation_4X.js

@@ -1,31 +1,24 @@
-import { utilities, log, data, normalizers, derivations } from 'dcmjs';
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import { utilities, data, normalizers, derivations, log } from 'dcmjs';
 import ndarray from 'ndarray';
 import getDatasetsFromImages from '../helpers/getDatasetsFromImages.js';
 import checkOrientation from '../helpers/checkOrientation.js';
 import { utilities as utilities$1 } from '@cornerstonejs/core';
 import { Events } from '../enums/Events.js';
 
-const {
-  rotateDirectionCosinesInPlane,
-  flipImageOrientationPatient: flipIOP,
-  flipMatrix2D,
-  rotateMatrix902D
-} = utilities.orientation;
-const {
-  BitArray,
-  DicomMessage,
-  DicomMetaDictionary
-} = data;
-const {
-  Normalizer
-} = normalizers;
-const {
-  Segmentation: SegmentationDerivation
-} = derivations;
-const {
-  encode,
-  decode
-} = utilities.compression;
+const _utilities$orientatio = utilities.orientation,
+  rotateDirectionCosinesInPlane = _utilities$orientatio.rotateDirectionCosinesInPlane,
+  flipIOP = _utilities$orientatio.flipImageOrientationPatient,
+  flipMatrix2D = _utilities$orientatio.flipMatrix2D,
+  rotateMatrix902D = _utilities$orientatio.rotateMatrix902D;
+const BitArray = data.BitArray,
+  DicomMessage = data.DicomMessage,
+  DicomMetaDictionary = data.DicomMetaDictionary;
+const Normalizer = normalizers.Normalizer;
+const SegmentationDerivation = derivations.Segmentation;
+const _utilities$compressio = utilities.compression,
+  encode = _utilities$compressio.encode,
+  decode = _utilities$compressio.decode;
 
 /**
  *
@@ -75,10 +68,8 @@ function fillSegmentation(segmentation, inputLabelmaps3D) {
   const referencedFramesPerLabelmap = [];
   for (let labelmapIndex = 0; labelmapIndex < labelmaps3D.length; labelmapIndex++) {
     const labelmap3D = labelmaps3D[labelmapIndex];
-    const {
-      labelmaps2D,
-      metadata
-    } = labelmap3D;
+    const labelmaps2D = labelmap3D.labelmaps2D,
+      metadata = labelmap3D.metadata;
     const referencedFramesPerSegment = [];
     for (let i = 1; i < metadata.length; i++) {
       if (metadata[i]) {
@@ -88,9 +79,7 @@ function fillSegmentation(segmentation, inputLabelmaps3D) {
     for (let i = 0; i < labelmaps2D.length; i++) {
       const labelmap2D = labelmaps2D[i];
       if (labelmaps2D[i]) {
-        const {
-          segmentsOnLabelmap
-        } = labelmap2D;
+        const segmentsOnLabelmap = labelmap2D.segmentsOnLabelmap;
         segmentsOnLabelmap.forEach(segmentIndex => {
           if (segmentIndex !== 0) {
             referencedFramesPerSegment[segmentIndex].push(i);
@@ -105,9 +94,7 @@ function fillSegmentation(segmentation, inputLabelmaps3D) {
   for (let labelmapIndex = 0; labelmapIndex < labelmaps3D.length; labelmapIndex++) {
     const referencedFramesPerSegment = referencedFramesPerLabelmap[labelmapIndex];
     const labelmap3D = labelmaps3D[labelmapIndex];
-    const {
-      metadata
-    } = labelmap3D;
+    const metadata = labelmap3D.metadata;
     for (let segmentIndex = 1; segmentIndex < referencedFramesPerSegment.length; segmentIndex++) {
       const referencedFrameIndicies = referencedFramesPerSegment[segmentIndex];
       if (referencedFrameIndicies) {
@@ -149,9 +136,7 @@ function fillSegmentation(segmentation, inputLabelmaps3D) {
   return segmentation;
 }
 function _getLabelmapsFromReferencedFrameIndicies(labelmap3D, referencedFrameIndicies) {
-  const {
-    labelmaps2D
-  } = labelmap3D;
+  const labelmaps2D = labelmap3D.labelmaps2D;
   const labelmaps = [];
   for (let i = 0; i < referencedFrameIndicies.length; i++) {
     const frame = referencedFrameIndicies[i];
@@ -188,14 +173,18 @@ function _createSegFromImages(images, isMultiframe, options) {
  *                  (available only for the overlapping case).
  */
 async function generateToolState(referencedImageIds, arrayBuffer, metadataProvider, options) {
-  const {
-    skipOverlapping = false,
-    tolerance = 1e-3,
-    TypedArrayConstructor = Uint8Array,
-    maxBytesPerChunk = 199000000,
-    eventTarget = null,
-    triggerEvent = null
-  } = options;
+  const _options$skipOverlapp = options.skipOverlapping,
+    skipOverlapping = _options$skipOverlapp === void 0 ? false : _options$skipOverlapp,
+    _options$tolerance = options.tolerance,
+    tolerance = _options$tolerance === void 0 ? 1e-3 : _options$tolerance,
+    _options$TypedArrayCo = options.TypedArrayConstructor,
+    TypedArrayConstructor = _options$TypedArrayCo === void 0 ? Uint8Array : _options$TypedArrayCo,
+    _options$maxBytesPerC = options.maxBytesPerChunk,
+    maxBytesPerChunk = _options$maxBytesPerC === void 0 ? 199000000 : _options$maxBytesPerC,
+    _options$eventTarget = options.eventTarget,
+    eventTarget = _options$eventTarget === void 0 ? null : _options$eventTarget,
+    _options$triggerEvent = options.triggerEvent,
+    triggerEvent = _options$triggerEvent === void 0 ? null : _options$triggerEvent;
   const dicomData = DicomMessage.readFile(arrayBuffer);
   const dataset = DicomMetaDictionary.naturalizeDataset(dicomData.dict);
   dataset._meta = DicomMetaDictionary.namifyDataset(dicomData.meta);
@@ -239,9 +228,8 @@ async function generateToolState(referencedImageIds, arrayBuffer, metadataProvid
   // we don't have to call metadataProvider.get() for each imageId over
   // and over again.
   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;
   }, {});
@@ -499,12 +487,10 @@ function findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadata
   if (!multiframe) {
     return imageId;
   }
-  const {
-    FrameOfReferenceUID,
-    PerFrameFunctionalGroupsSequence,
-    SourceImageSequence,
-    ReferencedSeriesSequence
-  } = multiframe;
+  const FrameOfReferenceUID = multiframe.FrameOfReferenceUID,
+    PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
+    SourceImageSequence = multiframe.SourceImageSequence,
+    ReferencedSeriesSequence = multiframe.ReferencedSeriesSequence;
   if (!PerFrameFunctionalGroupsSequence || PerFrameFunctionalGroupsSequence.length === 0) {
     return imageId;
   }
@@ -553,13 +539,11 @@ function findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadata
  */
 
 function checkSEGsOverlapping(pixelData, multiframe, imageIds, validOrientations, metadataProvider, tolerance, TypedArrayConstructor, sopUIDImageIdIndexMap) {
-  const {
-    SharedFunctionalGroupsSequence,
-    PerFrameFunctionalGroupsSequence,
-    SegmentSequence,
-    Rows,
-    Columns
-  } = multiframe;
+  const SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence,
+    PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
+    SegmentSequence = multiframe.SegmentSequence,
+    Rows = multiframe.Rows,
+    Columns = multiframe.Columns;
   let numberOfSegs = SegmentSequence.length;
   if (numberOfSegs < 2) {
     return false;
@@ -597,7 +581,9 @@ function checkSEGsOverlapping(pixelData, multiframe, imageIds, validOrientations
       frameSegmentsMapping.set(imageIdIndex, [frameSegment]);
     }
   }
-  for (let [, role] of frameSegmentsMapping.entries()) {
+  for (let _ref of frameSegmentsMapping.entries()) {
+    var _ref2 = _slicedToArray(_ref, 2);
+    let role = _ref2[1];
     let temp2DArray = new TypedArrayConstructor(sliceLength).fill(0);
     for (let i = 0; i < role.length; ++i) {
       const frameSegment = role[i];
@@ -624,12 +610,10 @@ function checkSEGsOverlapping(pixelData, multiframe, imageIds, validOrientations
   return false;
 }
 function insertOverlappingPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray, labelmapBufferArray, pixelData, multiframe, imageIds, validOrientations, metadataProvider, tolerance, TypedArrayConstructor, segmentsPixelIndices, sopUIDImageIdIndexMap) {
-  const {
-    SharedFunctionalGroupsSequence,
-    PerFrameFunctionalGroupsSequence,
-    Rows,
-    Columns
-  } = multiframe;
+  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 arrayBufferLength = sliceLength * imageIds.length * TypedArrayConstructor.BYTES_PER_ELEMENT;
@@ -728,20 +712,16 @@ function insertOverlappingPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray,
   }
 }
 const getSegmentIndex = (multiframe, frame) => {
-  const {
-    PerFrameFunctionalGroupsSequence,
-    SharedFunctionalGroupsSequence
-  } = multiframe;
+  const PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
+    SharedFunctionalGroupsSequence = multiframe.SharedFunctionalGroupsSequence;
   const PerFrameFunctionalGroups = PerFrameFunctionalGroupsSequence[frame];
   return PerFrameFunctionalGroups && PerFrameFunctionalGroups.SegmentIdentificationSequence ? PerFrameFunctionalGroups.SegmentIdentificationSequence.ReferencedSegmentNumber : SharedFunctionalGroupsSequence.SegmentIdentificationSequence ? SharedFunctionalGroupsSequence.SegmentIdentificationSequence.ReferencedSegmentNumber : undefined;
 };
 function insertPixelDataPlanar(segmentsOnFrame, segmentsOnFrameArray, labelmapBufferArray, pixelData, multiframe, imageIds, validOrientations, metadataProvider, tolerance, TypedArrayConstructor, segmentsPixelIndices, sopUIDImageIdIndexMap, imageIdMaps, eventTarget, triggerEvent) {
-  const {
-    SharedFunctionalGroupsSequence,
-    PerFrameFunctionalGroupsSequence,
-    Rows,
-    Columns
-  } = multiframe;
+  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;
   let i = 0;
@@ -901,10 +881,8 @@ function getUnpackedChunks(data, maxBytesPerChunk) {
  * @return {String}                        The corresponding imageId.
  */
 function getImageIdOfSourceImageBySourceImageSequence(SourceImageSequence, sopUIDImageIdIndexMap) {
-  const {
-    ReferencedSOPInstanceUID,
-    ReferencedFrameNumber
-  } = SourceImageSequence;
+  const ReferencedSOPInstanceUID = SourceImageSequence.ReferencedSOPInstanceUID,
+    ReferencedFrameNumber = SourceImageSequence.ReferencedFrameNumber;
   const baseImageId = sopUIDImageIdIndexMap[ReferencedSOPInstanceUID];
   if (!baseImageId) {
     console.warn("No imageId found for SOPInstanceUID: ".concat(ReferencedSOPInstanceUID));
@@ -970,8 +948,8 @@ function getImageIdOfSourceImagebyGeometry(ReferencedSeriesInstanceUID, FrameOfR
 
     // For multiframe images, check each frame's position
     if (isMultiframe) {
-      var _metadataProvider$get;
-      const framePosition = (_metadataProvider$get = metadataProvider.get('imagePlaneModule', imageId)) === null || _metadataProvider$get === void 0 ? void 0 : _metadataProvider$get.imagePositionPatient;
+      var _metadataProvider$get2;
+      const framePosition = (_metadataProvider$get2 = metadataProvider.get('imagePlaneModule', imageId)) === null || _metadataProvider$get2 === void 0 ? void 0 : _metadataProvider$get2.imagePositionPatient;
       if (framePosition && utilities$1.isEqual(segFramePosition, framePosition, tolerance)) {
         return imageId;
       }
@@ -1134,7 +1112,10 @@ function calculateCentroid(imageIdIndexBufferIndex, multiframe, metadataProvider
   let worldYAcc = 0;
   let worldZAcc = 0;
   let count = 0;
-  for (const [imageIdIndex, bufferIndices] of Object.entries(imageIdIndexBufferIndex)) {
+  for (const _ref3 of Object.entries(imageIdIndexBufferIndex)) {
+    var _ref4 = _slicedToArray(_ref3, 2);
+    const imageIdIndex = _ref4[0];
+    const bufferIndices = _ref4[1];
     const z = Number(imageIdIndex);
     if (!bufferIndices || bufferIndices.length === 0) {
       continue;
@@ -1147,13 +1128,11 @@ function calculateCentroid(imageIdIndexBufferIndex, multiframe, metadataProvider
       console.debug('Missing imagePlaneModule metadata for centroid calculation');
       continue;
     }
-    const {
-      imagePositionPatient,
-      rowCosines,
-      columnCosines,
-      rowPixelSpacing,
-      columnPixelSpacing
-    } = imagePlaneModule;
+    const imagePositionPatient = imagePlaneModule.imagePositionPatient,
+      rowCosines = imagePlaneModule.rowCosines,
+      columnCosines = imagePlaneModule.columnCosines,
+      rowPixelSpacing = imagePlaneModule.rowPixelSpacing,
+      columnPixelSpacing = imagePlaneModule.columnPixelSpacing;
     for (const bufferIndex of bufferIndices) {
       const y = Math.floor(bufferIndex / multiframe.Rows);
       const x = bufferIndex % multiframe.Rows;

package/dist/esm/adapters/Cornerstone/index.d.ts

@@ -1,14 +1,14 @@
-import MeasurementReport from "./MeasurementReport";
-import Length from "./Length";
-import FreehandRoi from "./FreehandRoi";
-import Bidirectional from "./Bidirectional";
-import EllipticalRoi from "./EllipticalRoi";
-import CircleRoi from "./CircleRoi";
-import ArrowAnnotate from "./ArrowAnnotate";
-import CobbAngle from "./CobbAngle";
-import Angle from "./Angle";
-import RectangleRoi from "./RectangleRoi";
-import * as Segmentation from "./Segmentation";
+import MeasurementReport from './MeasurementReport';
+import Length from './Length';
+import FreehandRoi from './FreehandRoi';
+import Bidirectional from './Bidirectional';
+import EllipticalRoi from './EllipticalRoi';
+import CircleRoi from './CircleRoi';
+import ArrowAnnotate from './ArrowAnnotate';
+import CobbAngle from './CobbAngle';
+import Angle from './Angle';
+import RectangleRoi from './RectangleRoi';
+import * as Segmentation from './Segmentation';
 declare const CornerstoneSR: {
     Length: typeof Length;
     FreehandRoi: typeof FreehandRoi;

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

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

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

@@ -1,25 +1,23 @@
-import _defineProperty from '../../node_modules/@babel/runtime/helpers/esm/defineProperty.js';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { utilities } from 'dcmjs';
 import MeasurementReport from './MeasurementReport.js';
 import BaseAdapter3D from './BaseAdapter3D.js';
+import '../helpers/downloadDICOMData.js';
 import { toScoord } from '../helpers/toScoordType.js';
-import '@cornerstonejs/core';
+import '../helpers/scoordToWorld.js';
 
 var _Angle;
 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 {
-  CobbAngle: TID300CobbAngle
-} = utilities.TID300;
+const TID300CobbAngle = utilities.TID300.CobbAngle;
 class Angle extends BaseAdapter3D {
   static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata) {
-    const {
-      state,
-      NUMGroup,
-      worldCoords,
-      referencedImageId,
-      ReferencedFrameNumber
-    } = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
+    const _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType),
+      state = _MeasurementReport$ge.state,
+      NUMGroup = _MeasurementReport$ge.NUMGroup,
+      worldCoords = _MeasurementReport$ge.worldCoords,
+      referencedImageId = _MeasurementReport$ge.referencedImageId,
+      ReferencedFrameNumber = _MeasurementReport$ge.ReferencedFrameNumber;
     const cachedStats = referencedImageId ? {
       ["imageId:".concat(referencedImageId)]: {
         angle: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : null
@@ -37,19 +35,14 @@ class Angle extends BaseAdapter3D {
   static getTID300RepresentationArguments(tool) {
     var _cachedStats;
     let is3DMeasurement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    const {
-      data,
-      finding,
-      findingSites,
-      metadata
-    } = tool;
-    const {
-      cachedStats = {},
-      handles
-    } = data;
-    const {
-      referencedImageId
-    } = metadata;
+    const data = tool.data,
+      finding = tool.finding,
+      findingSites = tool.findingSites,
+      metadata = tool.metadata;
+    const _data$cachedStats = data.cachedStats,
+      cachedStats = _data$cachedStats === void 0 ? {} : _data$cachedStats,
+      handles = data.handles;
+    const referencedImageId = metadata.referencedImageId;
     const scoordProps = {
       is3DMeasurement,
       referencedImageId
@@ -75,7 +68,7 @@ class Angle extends BaseAdapter3D {
 }
 _Angle = Angle;
 (() => {
-  _Angle.init("Angle", TID300CobbAngle);
+  _Angle.init('Angle', TID300CobbAngle);
   _Angle.registerLegacy();
 })();
 

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

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

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

@@ -1,44 +1,37 @@
-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';
 import BaseAdapter3D from './BaseAdapter3D.js';
+import '../helpers/downloadDICOMData.js';
 import { toScoord } from '../helpers/toScoordType.js';
+import '../helpers/scoordToWorld.js';
 
 var _ArrowAnnotate;
 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 {
-  ArrowAnnotate: TID300ArrowAnnotate
-} = utilities.TID300;
-const {
-  imageToWorldCoords
-} = utilities$1;
+const TID300ArrowAnnotate = utilities.TID300.ArrowAnnotate;
+const imageToWorldCoords = utilities$1.imageToWorldCoords;
 class ArrowAnnotate extends BaseAdapter3D {
   static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, _trackingIdentifier) {
-    const {
-      state,
-      SCOORDGroup,
-      worldCoords,
-      referencedImageId,
-      ReferencedFrameNumber
-    } = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
+    const _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType),
+      state = _MeasurementReport$ge.state,
+      SCOORDGroup = _MeasurementReport$ge.SCOORDGroup,
+      worldCoords = _MeasurementReport$ge.worldCoords,
+      referencedImageId = _MeasurementReport$ge.referencedImageId,
+      ReferencedFrameNumber = _MeasurementReport$ge.ReferencedFrameNumber;
     const text = state.annotation.data.label;
     if (worldCoords.length === 1 && SCOORDGroup) {
-      const imagePixelModule = metadata.get("imagePixelModule", referencedImageId);
+      const imagePixelModule = metadata.get('imagePixelModule', referencedImageId);
       let xOffset = 10;
       let yOffset = 10;
       if (imagePixelModule) {
-        const {
-          columns,
-          rows
-        } = imagePixelModule;
+        const columns = imagePixelModule.columns,
+          rows = imagePixelModule.rows;
         xOffset = columns / 10;
         yOffset = rows / 10;
       }
-      const {
-        GraphicData
-      } = SCOORDGroup;
+      const GraphicData = SCOORDGroup.GraphicData;
       const secondPoint = imageToWorldCoords(referencedImageId, [GraphicData[0] + xOffset, GraphicData[1] + yOffset]);
       worldCoords.push(secondPoint);
     }
@@ -54,25 +47,18 @@ class ArrowAnnotate extends BaseAdapter3D {
   }
   static getTID300RepresentationArguments(tool) {
     let is3DMeasurement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    const {
-      data,
-      metadata,
-      findingSites
-    } = tool;
-    const {
-      finding
-    } = tool;
-    const {
-      referencedImageId
-    } = metadata;
+    const data = tool.data,
+      metadata = tool.metadata,
+      findingSites = tool.findingSites;
+    const finding = tool.finding;
+    const referencedImageId = metadata.referencedImageId;
     const scoordProps = {
       is3DMeasurement,
       referencedImageId
     };
-    const {
-      points,
-      arrowFirst
-    } = data.handles;
+    const _data$handles = data.handles,
+      points = _data$handles.points,
+      arrowFirst = _data$handles.arrowFirst;
     const point = arrowFirst ? points[0] : points[1];
     const point2 = arrowFirst ? points[1] : points[0];
     const pointImage = toScoord(scoordProps, point);
@@ -90,7 +76,7 @@ class ArrowAnnotate extends BaseAdapter3D {
 }
 _ArrowAnnotate = ArrowAnnotate;
 (() => {
-  _ArrowAnnotate.init("ArrowAnnotate", TID300ArrowAnnotate);
+  _ArrowAnnotate.init('ArrowAnnotate', TID300ArrowAnnotate);
   _ArrowAnnotate.registerLegacy();
 })();
 

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

@@ -1,4 +1,4 @@
-import { type AdapterOptions, type MeasurementAdapter } from "./MeasurementReport";
+import { type AdapterOptions, type MeasurementAdapter } from './MeasurementReport';
 export type Point = {
     x: number;
     y: number;

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

@@ -1,30 +1,30 @@
 import CORNERSTONE_3D_TAG from './cornerstone3DTag.js';
 import MeasurementReport from './MeasurementReport.js';
-import 'dcmjs';
+import '../helpers/downloadDICOMData.js';
 import { toScoords } from '../helpers/toScoordType.js';
-import '@cornerstonejs/core';
+import '../helpers/scoordToWorld.js';
 
 class BaseAdapter3D {
   static registerType() {
-    let code = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
-    let type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
+    let code = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+    let type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
     let count = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
     let key = code;
     if (type) {
-      key = "".concat(key).concat(key.length ? "-" : "").concat(type);
+      key = "".concat(key).concat(key.length ? '-' : '').concat(type);
     }
     if (count) {
-      key = "".concat(key).concat(key.length ? "-" : "").concat(count);
+      key = "".concat(key).concat(key.length ? '-' : '').concat(count);
     }
     MeasurementReport.registerAdapterTypes(this, key);
   }
   static getPointsCount(graphicItem) {
-    const is3DMeasurement = graphicItem.ValueType === "SCOORD3D";
+    const is3DMeasurement = graphicItem.ValueType === 'SCOORD3D';
     const pointSize = is3DMeasurement ? 3 : 2;
     return graphicItem.GraphicData.length / pointSize;
   }
   static getGraphicItems(measurementGroup, filter) {
-    const items = measurementGroup.ContentSequence.filter(group => group.ValueType === "SCOORD" || group.ValueType === "SCOORD3D");
+    const items = measurementGroup.ContentSequence.filter(group => group.ValueType === 'SCOORD' || group.ValueType === 'SCOORD3D');
     return filter ? items.filter(filter) : items;
   }
   static getGraphicItem(measurementGroup) {
@@ -34,13 +34,9 @@ class BaseAdapter3D {
     return items[offset];
   }
   static getGraphicCode(graphicItem) {
-    const {
-      ConceptNameCodeSequence: conceptNameItem
-    } = graphicItem;
-    const {
-      CodeValue: graphicValue,
-      CodingSchemeDesignator: graphicDesignator
-    } = conceptNameItem;
+    const conceptNameItem = graphicItem.ConceptNameCodeSequence;
+    const graphicValue = conceptNameItem.CodeValue,
+      graphicDesignator = conceptNameItem.CodingSchemeDesignator;
     return "".concat(graphicDesignator, ":").concat(graphicValue);
   }
   static getGraphicType(graphicItem) {
@@ -82,35 +78,28 @@ class BaseAdapter3D {
     if (this.trackingIdentifiers.has(trackingIdentifier)) {
       return true;
     }
-    if (!trackingIdentifier.includes(":")) {
+    if (!trackingIdentifier.includes(':')) {
       return false;
     }
     return trackingIdentifier.startsWith(this.trackingIdentifierTextValue);
   }
   static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, trackingIdentifier) {
-    const {
-      defaultState: state,
-      ReferencedFrameNumber
-    } = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
+    const _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType),
+      state = _MeasurementReport$ge.defaultState,
+      ReferencedFrameNumber = _MeasurementReport$ge.ReferencedFrameNumber;
     state.annotation.data = {
       cachedStats: {},
       frameNumber: ReferencedFrameNumber,
-      seriesLevel: (trackingIdentifier === null || trackingIdentifier === void 0 ? void 0 : trackingIdentifier.indexOf(":Series")) > 0
+      seriesLevel: (trackingIdentifier === null || trackingIdentifier === void 0 ? void 0 : trackingIdentifier.indexOf(':Series')) > 0
     };
     return state;
   }
   static getTID300RepresentationArguments(tool) {
     let is3DMeasurement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    const {
-      metadata
-    } = tool;
-    const {
-      finding,
-      findingSites
-    } = tool;
-    const {
-      referencedImageId
-    } = metadata;
+    const metadata = tool.metadata;
+    const finding = tool.finding,
+      findingSites = tool.findingSites;
+    const referencedImageId = metadata.referencedImageId;
     const scoordProps = {
       is3DMeasurement,
       referencedImageId

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

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