@cornerstonejs/adapters 5.0.0-beta.1 → 5.0.0

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

@@ -1,25 +1,17 @@
 import { utilities, derivations, normalizers, data } from 'dcmjs';
 import { toArray } from '../helpers/toArray.js';
 import { codeMeaningEquals } from '../helpers/codeMeaningEquals.js';
-import '@cornerstonejs/core';
-
-const {
-  TID1500,
-  addAccessors
-} = utilities;
-const {
-  StructuredReport
-} = derivations;
-const {
-  Normalizer
-} = normalizers;
-const {
-  TID1500MeasurementReport,
-  TID1501MeasurementGroup
-} = TID1500;
-const {
-  DicomMetaDictionary
-} = data;
+import '../helpers/downloadDICOMData.js';
+import '../helpers/toScoordType.js';
+import '../helpers/scoordToWorld.js';
+
+const TID1500 = utilities.TID1500,
+  addAccessors = utilities.addAccessors;
+const StructuredReport = derivations.StructuredReport;
+const Normalizer = normalizers.Normalizer;
+const TID1500MeasurementReport = TID1500.TID1500MeasurementReport,
+  TID1501MeasurementGroup = TID1500.TID1501MeasurementGroup;
+const DicomMetaDictionary = data.DicomMetaDictionary;
 const FINDING = {
   CodingSchemeDesignator: 'DCM',
   CodeValue: '121071'
@@ -33,16 +25,12 @@ const FINDING_SITE_OLD = {
   CodeValue: 'G-C0E3'
 };
 const codeValueMatch = (group, code, oldCode) => {
-  const {
-    ConceptNameCodeSequence
-  } = group;
+  const ConceptNameCodeSequence = group.ConceptNameCodeSequence;
   if (!ConceptNameCodeSequence) {
     return;
   }
-  const {
-    CodingSchemeDesignator,
-    CodeValue
-  } = ConceptNameCodeSequence;
+  const CodingSchemeDesignator = ConceptNameCodeSequence.CodingSchemeDesignator,
+    CodeValue = ConceptNameCodeSequence.CodeValue;
   return CodingSchemeDesignator == code.CodingSchemeDesignator && CodeValue == code.CodeValue || oldCode && CodingSchemeDesignator == oldCode.CodingSchemeDesignator && CodeValue == oldCode.CodeValue;
 };
 function getTID300ContentItem(tool, ReferencedSOPSequence, adapterClass) {
@@ -68,21 +56,15 @@ function getMeasurementGroup(toolType, toolData, ReferencedSOPSequence) {
 }
 class MeasurementReport {
   static getSetupMeasurementData(MeasurementGroup) {
-    const {
-      ContentSequence
-    } = MeasurementGroup;
+    const ContentSequence = MeasurementGroup.ContentSequence;
     const contentSequenceArr = toArray(ContentSequence);
     const findingGroup = contentSequenceArr.find(group => codeValueMatch(group, FINDING));
     const findingSiteGroups = contentSequenceArr.filter(group => codeValueMatch(group, FINDING_SITE, FINDING_SITE_OLD)) || [];
     const NUMGroup = contentSequenceArr.find(group => group.ValueType === 'NUM');
     const SCOORDGroup = toArray(NUMGroup.ContentSequence).find(group => group.ValueType === 'SCOORD');
-    const {
-      ReferencedSOPSequence
-    } = SCOORDGroup.ContentSequence;
-    const {
-      ReferencedSOPInstanceUID,
-      ReferencedFrameNumber
-    } = ReferencedSOPSequence;
+    const ReferencedSOPSequence = SCOORDGroup.ContentSequence.ReferencedSOPSequence;
+    const ReferencedSOPInstanceUID = ReferencedSOPSequence.ReferencedSOPInstanceUID,
+      ReferencedFrameNumber = ReferencedSOPSequence.ReferencedFrameNumber;
     const defaultState = {
       sopInstanceUid: ReferencedSOPInstanceUID,
       frameIndex: ReferencedFrameNumber || 1,
@@ -133,10 +115,8 @@ class MeasurementReport {
     // NOTE: We are getting the Series and Study UIDs from the first imageId of the toolState
     // which means that if the toolState is for multiple series, the report will have the incorrect
     // SeriesInstanceUIDs
-    const {
-      studyInstanceUID,
-      seriesInstanceUID
-    } = generalSeriesModule;
+    const studyInstanceUID = generalSeriesModule.studyInstanceUID,
+      seriesInstanceUID = generalSeriesModule.seriesInstanceUID;
 
     // Loop through each image in the toolData
     Object.keys(toolState).forEach(imageId => {

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

@@ -1,45 +1,40 @@
-import { log, data, normalizers } from 'dcmjs';
+import { data, normalizers, log } from 'dcmjs';
 import checkOrientation from '../helpers/checkOrientation.js';
 import { utilities } from '@cornerstonejs/core';
 
-const {
-  DicomMessage,
-  DicomMetaDictionary
-} = data;
-const {
-  Normalizer
-} = normalizers;
+const DicomMessage = data.DicomMessage,
+  DicomMetaDictionary = data.DicomMetaDictionary;
+const Normalizer = normalizers.Normalizer;
 async function generateToolState(imageIds, arrayBuffer, metadataProvider) {
   let tolerance = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1e-3;
   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", imageIds[0]);
+  const imagePlaneModule = metadataProvider.get('imagePlaneModule', imageIds[0]);
   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 = [ImageOrientationPatient];
   const pixelData = getPixelData(multiframe);
   const orientation = checkOrientation(multiframe, validOrientations, [imagePlaneModule.rows, imagePlaneModule.columns, imageIds.length], tolerance);
   const sopUIDImageIdIndexMap = imageIds.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;
   }, {});
-  if (orientation !== "Planar") {
+  if (orientation !== 'Planar') {
     const orientationText = {
-      Perpendicular: "orthogonal",
-      Oblique: "oblique"
+      Perpendicular: 'orthogonal',
+      Oblique: 'oblique'
     };
     throw new Error("Parametric maps ".concat(orientationText[orientation], " to the acquisition plane of the source data are not yet supported."));
   }
   const imageIdMaps = imageIds.reduce((acc, curr, index) => {
     acc.indices[curr] = index;
-    acc.metadata[curr] = metadataProvider.get("instance", curr);
+    acc.metadata[curr] = metadataProvider.get('instance', curr);
     return acc;
   }, {
     indices: {},
@@ -52,23 +47,21 @@ async function generateToolState(imageIds, arrayBuffer, metadataProvider) {
 }
 function insertPixelDataPlanar(sourcePixelData, multiframe, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap, imageIdMaps) {
   const targetPixelData = new sourcePixelData.constructor(sourcePixelData.length);
-  const {
-    PerFrameFunctionalGroupsSequence,
-    Rows,
-    Columns
-  } = multiframe;
+  const PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
+    Rows = multiframe.Rows,
+    Columns = multiframe.Columns;
   const sliceLength = Columns * Rows;
   const numSlices = PerFrameFunctionalGroupsSequence.length;
   for (let i = 0; i < numSlices; i++) {
     const sourceSliceDataView = new sourcePixelData.constructor(sourcePixelData.buffer, i * sliceLength, sliceLength);
     const imageId = findReferenceSourceImageId(multiframe, i, imageIds, 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 + '.');
       continue;
     }
     const sourceImageMetadata = imageIdMaps.metadata[imageId];
     if (Rows !== sourceImageMetadata.Rows || Columns !== sourceImageMetadata.Columns) {
-      throw new Error("Parametric map have different geometry dimensions (Rows and Columns) " + "respect to the source image reference frame. This is not yet supported.");
+      throw new Error('Parametric map have different geometry dimensions (Rows and Columns) ' + 'respect to the source image reference frame. This is not yet supported.');
     }
     const imageIdIndex = imageIdMaps.indices[imageId];
     const byteOffset = sliceLength * imageIdIndex * targetPixelData.BYTES_PER_ELEMENT;
@@ -93,7 +86,7 @@ function getPixelData(multiframe) {
     data = multiframe.DoubleFloatPixelData;
   }
   if (data === undefined) {
-    log.error("This parametric map pixel data is undefined.");
+    log.error('This parametric map pixel data is undefined.');
   }
   if (Array.isArray(data)) {
     data = data[0];
@@ -105,12 +98,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;
   }
@@ -139,7 +130,7 @@ function findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadata
       }
     }
   } else if (SourceImageSequence && SourceImageSequence.length !== 0) {
-    console.warn("DerivationImageSequence not present, using SourceImageSequence assuming SEG has the same geometry as the source image.");
+    console.warn('DerivationImageSequence not present, using SourceImageSequence assuming SEG has the same geometry as the source image.');
     frameSourceImageSequence = SourceImageSequence[frameSegment];
   }
   if (frameSourceImageSequence) {
@@ -153,10 +144,8 @@ function findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadata
   return imageId;
 }
 function getImageIdOfSourceImageBySourceImageSequence(SourceImageSequence, sopUIDImageIdIndexMap) {
-  const {
-    ReferencedSOPInstanceUID,
-    ReferencedFrameNumber
-  } = SourceImageSequence;
+  const ReferencedSOPInstanceUID = SourceImageSequence.ReferencedSOPInstanceUID,
+    ReferencedFrameNumber = SourceImageSequence.ReferencedFrameNumber;
   return ReferencedFrameNumber ? getImageIdOfReferencedFrame(ReferencedSOPInstanceUID, ReferencedFrameNumber, sopUIDImageIdIndexMap) : sopUIDImageIdIndexMap[ReferencedSOPInstanceUID];
 }
 function getImageIdOfSourceImagebyGeometry(ReferencedSeriesInstanceUID, FrameOfReferenceUID, PerFrameFunctionalGroup, imageIds, metadataProvider, tolerance) {
@@ -164,7 +153,7 @@ function getImageIdOfSourceImagebyGeometry(ReferencedSeriesInstanceUID, FrameOfR
     return undefined;
   }
   for (let imageIdsIndex = 0; imageIdsIndex < imageIds.length; ++imageIdsIndex) {
-    const sourceImageMetadata = metadataProvider.get("instance", imageIds[imageIdsIndex]);
+    const sourceImageMetadata = metadataProvider.get('instance', imageIds[imageIdsIndex]);
     if (sourceImageMetadata === undefined || sourceImageMetadata.ImagePositionPatient === undefined || sourceImageMetadata.FrameOfReferenceUID !== FrameOfReferenceUID || sourceImageMetadata.SeriesInstanceUID !== ReferencedSeriesInstanceUID) {
       continue;
     }
@@ -178,7 +167,7 @@ function getImageIdOfReferencedFrame(sopInstanceUid, frameNumber, sopUIDImageIdI
   if (!imageId) {
     return;
   }
-  const imageIdFrameNumber = Number(imageId.split("frame=")[1]);
+  const imageIdFrameNumber = Number(imageId.split('frame=')[1]);
   return imageIdFrameNumber === frameNumber - 1 ? imageId : undefined;
 }
 const ParametricMapObj = {

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

@@ -1,20 +1,18 @@
-import _defineProperty from '../../node_modules/@babel/runtime/helpers/esm/defineProperty.js';
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { utilities } from 'dcmjs';
 import MeasurementReport from './MeasurementReport.js';
 import CORNERSTONE_4_TAG from './cornerstone4Tag.js';
 
 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 {
-  Polyline: TID300Polyline
-} = utilities.TID300;
+const TID300Polyline = utilities.TID300.Polyline;
 class RectangleRoi {
   static getMeasurementData(MeasurementGroup) {
-    const {
-      defaultState,
-      SCOORDGroup,
-      NUMGroup
-    } = MeasurementReport.getSetupMeasurementData(MeasurementGroup);
+    const _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(MeasurementGroup),
+      defaultState = _MeasurementReport$ge.defaultState,
+      SCOORDGroup = _MeasurementReport$ge.SCOORDGroup,
+      NUMGroup = _MeasurementReport$ge.NUMGroup;
     const state = _objectSpread(_objectSpread({}, defaultState), {}, {
       toolType: RectangleRoi.toolType,
       handles: {
@@ -36,21 +34,23 @@ class RectangleRoi {
       color: undefined,
       invalidated: true
     });
-    const intermediate = {};
-    [state.handles.start.x, state.handles.start.y, intermediate.x, intermediate.y, state.handles.end.x, state.handles.end.y] = SCOORDGroup.GraphicData;
+    var _SCOORDGroup$GraphicD = _slicedToArray(SCOORDGroup.GraphicData, 6);
+    state.handles.start.x = _SCOORDGroup$GraphicD[0];
+    state.handles.start.y = _SCOORDGroup$GraphicD[1];
+    _SCOORDGroup$GraphicD[2];
+    _SCOORDGroup$GraphicD[3];
+    state.handles.end.x = _SCOORDGroup$GraphicD[4];
+    state.handles.end.y = _SCOORDGroup$GraphicD[5];
     return state;
   }
   static getTID300RepresentationArguments(tool) {
-    const {
-      finding,
-      findingSites,
-      cachedStats = {},
-      handles
-    } = tool;
-    const {
-      start,
-      end
-    } = handles;
+    const finding = tool.finding,
+      findingSites = tool.findingSites,
+      _tool$cachedStats = tool.cachedStats,
+      cachedStats = _tool$cachedStats === void 0 ? {} : _tool$cachedStats,
+      handles = tool.handles;
+    const start = handles.start,
+      end = handles.end;
     const points = [start, {
       x: start.x,
       y: end.y
@@ -58,10 +58,8 @@ class RectangleRoi {
       x: end.x,
       y: start.y
     }];
-    const {
-      area,
-      perimeter
-    } = cachedStats;
+    const area = cachedStats.area,
+      perimeter = cachedStats.perimeter;
     const trackingIdentifierTextValue = 'cornerstoneTools@^4.0.0:RectangleRoi';
     return {
       points,
@@ -80,7 +78,10 @@ RectangleRoi.isValidCornerstoneTrackingIdentifier = TrackingIdentifier => {
   if (!TrackingIdentifier.includes(':')) {
     return false;
   }
-  const [cornerstone4Tag, toolType] = TrackingIdentifier.split(':');
+  const _TrackingIdentifier$s = TrackingIdentifier.split(':'),
+    _TrackingIdentifier$s2 = _slicedToArray(_TrackingIdentifier$s, 2),
+    cornerstone4Tag = _TrackingIdentifier$s2[0],
+    toolType = _TrackingIdentifier$s2[1];
   if (cornerstone4Tag !== CORNERSTONE_4_TAG) {
     return false;
   }

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

@@ -1,25 +1,18 @@
-import { utilities, log, normalizers, derivations } from 'dcmjs';
+import { utilities, normalizers, derivations, log } from 'dcmjs';
 import ndarray from 'ndarray';
 import getDatasetsFromImages from '../helpers/getDatasetsFromImages.js';
 
-const {
-  rotateDirectionCosinesInPlane,
-  flipImageOrientationPatient: flipIOP,
-  flipMatrix2D,
-  rotateMatrix902D
-} = utilities.orientation;
-const {
-  datasetToBlob,
-  BitArray,
-  DicomMessage,
-  DicomMetaDictionary
-} = utilities;
-const {
-  Normalizer
-} = normalizers;
-const {
-  Segmentation: SegmentationDerivation
-} = derivations;
+const _utilities$orientatio = utilities.orientation,
+  rotateDirectionCosinesInPlane = _utilities$orientatio.rotateDirectionCosinesInPlane,
+  flipIOP = _utilities$orientatio.flipImageOrientationPatient,
+  flipMatrix2D = _utilities$orientatio.flipMatrix2D,
+  rotateMatrix902D = _utilities$orientatio.rotateMatrix902D;
+const datasetToBlob = utilities.datasetToBlob,
+  BitArray = utilities.BitArray,
+  DicomMessage = utilities.DicomMessage,
+  DicomMetaDictionary = utilities.DicomMetaDictionary;
+const Normalizer = normalizers.Normalizer;
+const SegmentationDerivation = derivations.Segmentation;
 const Segmentation = {
   generateSegmentation,
   generateToolState
@@ -45,10 +38,8 @@ function generateSegmentation(images, brushData) {
   let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
     includeSliceSpacing: true
   };
-  const {
-    toolState,
-    segments
-  } = brushData;
+  const toolState = brushData.toolState,
+    segments = brushData.segments;
 
   // Calculate the dimensions of the data cube.
   const image0 = images[0];
@@ -64,10 +55,9 @@ function generateSegmentation(images, brushData) {
   }
   const isMultiframe = image0.imageId.includes('?frame');
   const seg = _createSegFromImages(images, isMultiframe, options);
-  const {
-    referencedFramesPerSegment,
-    segmentIndicies
-  } = _getNumberOfFramesPerSegment(toolState, images, segments);
+  const _getNumberOfFramesPer = _getNumberOfFramesPerSegment(toolState, images, segments),
+    referencedFramesPerSegment = _getNumberOfFramesPer.referencedFramesPerSegment,
+    segmentIndicies = _getNumberOfFramesPer.segmentIndicies;
   let NumberOfFrames = 0;
   for (let i = 0; i < referencedFramesPerSegment.length; i++) {
     NumberOfFrames += referencedFramesPerSegment[i].length;
@@ -274,10 +264,8 @@ function addImageIdSpecificBrushToolState(toolState, imageId, segmentIndex, pixe
  * @return {String}                     The corresponding imageId.
  */
 function getImageIdOfSourceImage(SourceImageSequence, imageIds, metadataProvider) {
-  const {
-    ReferencedSOPInstanceUID,
-    ReferencedFrameNumber
-  } = SourceImageSequence;
+  const ReferencedSOPInstanceUID = SourceImageSequence.ReferencedSOPInstanceUID,
+    ReferencedFrameNumber = SourceImageSequence.ReferencedFrameNumber;
   return ReferencedFrameNumber ? getImageIdOfReferencedFrame(ReferencedSOPInstanceUID, ReferencedFrameNumber, imageIds, metadataProvider) : getImageIdOfReferencedSingleFramedSOPInstance(ReferencedSOPInstanceUID, imageIds, metadataProvider);
 }