@cornerstonejs/adapters 2.0.0-beta.8 → 2.0.1

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

@@ -0,0 +1,276 @@
+import { createClass as _createClass, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { utilities, derivations, normalizers, data } from 'dcmjs';
+import { toArray } from '../helpers/toArray.js';
+import { codeMeaningEquals } from '../helpers/codeMeaningEquals.js';
+import '../helpers/downloadDICOMData.js';
+
+var TID1500 = utilities.TID1500,
+  addAccessors = utilities.addAccessors;
+var StructuredReport = derivations.StructuredReport;
+var Normalizer = normalizers.Normalizer;
+var TID1500MeasurementReport = TID1500.TID1500MeasurementReport,
+  TID1501MeasurementGroup = TID1500.TID1501MeasurementGroup;
+var DicomMetaDictionary = data.DicomMetaDictionary;
+var FINDING = {
+  CodingSchemeDesignator: "DCM",
+  CodeValue: "121071"
+};
+var FINDING_SITE = {
+  CodingSchemeDesignator: "SCT",
+  CodeValue: "363698007"
+};
+var FINDING_SITE_OLD = {
+  CodingSchemeDesignator: "SRT",
+  CodeValue: "G-C0E3"
+};
+var codeValueMatch = function codeValueMatch(group, code, oldCode) {
+  var ConceptNameCodeSequence = group.ConceptNameCodeSequence;
+  if (!ConceptNameCodeSequence) {
+    return;
+  }
+  var CodingSchemeDesignator = ConceptNameCodeSequence.CodingSchemeDesignator,
+    CodeValue = ConceptNameCodeSequence.CodeValue;
+  return CodingSchemeDesignator == code.CodingSchemeDesignator && CodeValue == code.CodeValue || oldCode && CodingSchemeDesignator == oldCode.CodingSchemeDesignator && CodeValue == oldCode.CodeValue;
+};
+function getTID300ContentItem(tool, toolType, ReferencedSOPSequence, toolClass) {
+  var args = toolClass.getTID300RepresentationArguments(tool);
+  args.ReferencedSOPSequence = ReferencedSOPSequence;
+  var TID300Measurement = new toolClass.TID300Representation(args);
+  return TID300Measurement;
+}
+function getMeasurementGroup(toolType, toolData, ReferencedSOPSequence) {
+  var toolTypeData = toolData[toolType];
+  var toolClass = MeasurementReport.CORNERSTONE_TOOL_CLASSES_BY_TOOL_TYPE[toolType];
+  if (!toolTypeData || !toolTypeData.data || !toolTypeData.data.length || !toolClass) {
+    return;
+  }
+
+  // Loop through the array of tool instances
+  // for this tool
+  var Measurements = toolTypeData.data.map(function (tool) {
+    return getTID300ContentItem(tool, toolType, ReferencedSOPSequence, toolClass);
+  });
+  return new TID1501MeasurementGroup(Measurements);
+}
+var MeasurementReport = /*#__PURE__*/function () {
+  function MeasurementReport() {
+    _classCallCheck(this, MeasurementReport);
+  }
+  return _createClass(MeasurementReport, null, [{
+    key: "getSetupMeasurementData",
+    value: function getSetupMeasurementData(MeasurementGroup) {
+      var ContentSequence = MeasurementGroup.ContentSequence;
+      var contentSequenceArr = toArray(ContentSequence);
+      var findingGroup = contentSequenceArr.find(function (group) {
+        return codeValueMatch(group, FINDING);
+      });
+      var findingSiteGroups = contentSequenceArr.filter(function (group) {
+        return codeValueMatch(group, FINDING_SITE, FINDING_SITE_OLD);
+      }) || [];
+      var NUMGroup = contentSequenceArr.find(function (group) {
+        return group.ValueType === "NUM";
+      });
+      var SCOORDGroup = toArray(NUMGroup.ContentSequence).find(function (group) {
+        return group.ValueType === "SCOORD";
+      });
+      var ReferencedSOPSequence = SCOORDGroup.ContentSequence.ReferencedSOPSequence;
+      var ReferencedSOPInstanceUID = ReferencedSOPSequence.ReferencedSOPInstanceUID,
+        ReferencedFrameNumber = ReferencedSOPSequence.ReferencedFrameNumber;
+      var defaultState = {
+        sopInstanceUid: ReferencedSOPInstanceUID,
+        frameIndex: ReferencedFrameNumber || 1,
+        complete: true,
+        finding: findingGroup ? addAccessors(findingGroup.ConceptCodeSequence) : undefined,
+        findingSites: findingSiteGroups.map(function (fsg) {
+          return addAccessors(fsg.ConceptCodeSequence);
+        })
+      };
+      if (defaultState.finding) {
+        defaultState.description = defaultState.finding.CodeMeaning;
+      }
+      var findingSite = defaultState.findingSites && defaultState.findingSites[0];
+      if (findingSite) {
+        defaultState.location = findingSite[0] && findingSite[0].CodeMeaning || findingSite.CodeMeaning;
+      }
+      return {
+        defaultState: defaultState,
+        findingGroup: findingGroup,
+        findingSiteGroups: findingSiteGroups,
+        NUMGroup: NUMGroup,
+        SCOORDGroup: SCOORDGroup,
+        ReferencedSOPSequence: ReferencedSOPSequence,
+        ReferencedSOPInstanceUID: ReferencedSOPInstanceUID,
+        ReferencedFrameNumber: ReferencedFrameNumber
+      };
+    }
+  }, {
+    key: "generateReport",
+    value: function generateReport(toolState, metadataProvider, options) {
+      // ToolState for array of imageIDs to a Report
+      // Assume Cornerstone metadata provider has access to Study / Series / Sop Instance UID
+
+      var allMeasurementGroups = [];
+      var firstImageId = Object.keys(toolState)[0];
+      if (!firstImageId) {
+        throw new Error("No measurements provided.");
+      }
+
+      /* Patient ID
+      Warning - Missing attribute or value that would be needed to build DICOMDIR - Patient ID
+      Warning - Missing attribute or value that would be needed to build DICOMDIR - Study Date
+      Warning - Missing attribute or value that would be needed to build DICOMDIR - Study Time
+      Warning - Missing attribute or value that would be needed to build DICOMDIR - Study ID
+       */
+      var generalSeriesModule = metadataProvider.get("generalSeriesModule", firstImageId);
+
+      //const sopCommonModule = metadataProvider.get('sopCommonModule', firstImageId);
+
+      // 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
+      var studyInstanceUID = generalSeriesModule.studyInstanceUID,
+        seriesInstanceUID = generalSeriesModule.seriesInstanceUID;
+
+      // Loop through each image in the toolData
+      Object.keys(toolState).forEach(function (imageId) {
+        var sopCommonModule = metadataProvider.get("sopCommonModule", imageId);
+        var frameNumber = metadataProvider.get("frameNumber", imageId);
+        var toolData = toolState[imageId];
+        var toolTypes = Object.keys(toolData);
+        var ReferencedSOPSequence = {
+          ReferencedSOPClassUID: sopCommonModule.sopClassUID,
+          ReferencedSOPInstanceUID: sopCommonModule.sopInstanceUID
+        };
+        if (Normalizer.isMultiframeSOPClassUID(sopCommonModule.sopClassUID)) {
+          ReferencedSOPSequence.ReferencedFrameNumber = frameNumber;
+        }
+
+        // Loop through each tool type for the image
+        var measurementGroups = [];
+        toolTypes.forEach(function (toolType) {
+          var group = getMeasurementGroup(toolType, toolData, ReferencedSOPSequence);
+          if (group) {
+            measurementGroups.push(group);
+          }
+        });
+        allMeasurementGroups = allMeasurementGroups.concat(measurementGroups);
+      });
+      var _MeasurementReport = new TID1500MeasurementReport({
+        TID1501MeasurementGroups: allMeasurementGroups
+      }, options);
+
+      // TODO: what is the correct metaheader
+      // http://dicom.nema.org/medical/Dicom/current/output/chtml/part10/chapter_7.html
+      // TODO: move meta creation to happen in derivations.js
+      var fileMetaInformationVersionArray = new Uint8Array(2);
+      fileMetaInformationVersionArray[1] = 1;
+      var derivationSourceDataset = {
+        StudyInstanceUID: studyInstanceUID,
+        SeriesInstanceUID: seriesInstanceUID
+        //SOPInstanceUID: sopInstanceUID, // TODO: Necessary?
+        //SOPClassUID: sopClassUID,
+      };
+      var _meta = {
+        FileMetaInformationVersion: {
+          Value: [fileMetaInformationVersionArray.buffer],
+          vr: "OB"
+        },
+        //MediaStorageSOPClassUID
+        //MediaStorageSOPInstanceUID: sopCommonModule.sopInstanceUID,
+        TransferSyntaxUID: {
+          Value: ["1.2.840.10008.1.2.1"],
+          vr: "UI"
+        },
+        ImplementationClassUID: {
+          Value: [DicomMetaDictionary.uid()],
+          // TODO: could be git hash or other valid id
+          vr: "UI"
+        },
+        ImplementationVersionName: {
+          Value: ["dcmjs"],
+          vr: "SH"
+        }
+      };
+      var _vrMap = {
+        PixelData: "OW"
+      };
+      derivationSourceDataset._meta = _meta;
+      derivationSourceDataset._vrMap = _vrMap;
+      var report = new StructuredReport([derivationSourceDataset]);
+      var contentItem = _MeasurementReport.contentItem(derivationSourceDataset);
+
+      // Merge the derived dataset with the content from the Measurement Report
+      report.dataset = Object.assign(report.dataset, contentItem);
+      report.dataset._meta = _meta;
+      report.dataset.SpecificCharacterSet = "ISO_IR 192";
+      return report;
+    }
+
+    /**
+     * Generate Cornerstone tool state from dataset
+     * @param {object} dataset dataset
+     * @param {object} hooks
+     * @param {function} hooks.getToolClass Function to map dataset to a tool class
+     * @returns
+     */
+  }, {
+    key: "generateToolState",
+    value: function generateToolState(dataset) {
+      var hooks = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      // For now, bail out if the dataset is not a TID1500 SR with length measurements
+      if (dataset.ContentTemplateSequence.TemplateIdentifier !== "1500") {
+        throw new Error("This package can currently only interpret DICOM SR TID 1500");
+      }
+      var REPORT = "Imaging Measurements";
+      var GROUP = "Measurement Group";
+      var TRACKING_IDENTIFIER = "Tracking Identifier";
+
+      // Identify the Imaging Measurements
+      var imagingMeasurementContent = toArray(dataset.ContentSequence).find(codeMeaningEquals(REPORT));
+
+      // Retrieve the Measurements themselves
+      var measurementGroups = toArray(imagingMeasurementContent.ContentSequence).filter(codeMeaningEquals(GROUP));
+
+      // For each of the supported measurement types, compute the measurement data
+      var measurementData = {};
+      var cornerstoneToolClasses = MeasurementReport.CORNERSTONE_TOOL_CLASSES_BY_UTILITY_TYPE;
+      var registeredToolClasses = [];
+      Object.keys(cornerstoneToolClasses).forEach(function (key) {
+        registeredToolClasses.push(cornerstoneToolClasses[key]);
+        measurementData[key] = [];
+      });
+      measurementGroups.forEach(function (measurementGroup) {
+        var measurementGroupContentSequence = toArray(measurementGroup.ContentSequence);
+        var TrackingIdentifierGroup = measurementGroupContentSequence.find(function (contentItem) {
+          return contentItem.ConceptNameCodeSequence.CodeMeaning === TRACKING_IDENTIFIER;
+        });
+        var TrackingIdentifierValue = TrackingIdentifierGroup.TextValue;
+        var toolClass = hooks.getToolClass ? hooks.getToolClass(measurementGroup, dataset, registeredToolClasses) : registeredToolClasses.find(function (tc) {
+          return tc.isValidCornerstoneTrackingIdentifier(TrackingIdentifierValue);
+        });
+        if (toolClass) {
+          var measurement = toolClass.getMeasurementData(measurementGroup);
+          console.log("=== ".concat(toolClass.toolType, " ==="));
+          console.log(measurement);
+          measurementData[toolClass.toolType].push(measurement);
+        }
+      });
+
+      // NOTE: There is no way of knowing the cornerstone imageIds as that could be anything.
+      // That is up to the consumer to derive from the SOPInstanceUIDs.
+      return measurementData;
+    }
+  }, {
+    key: "registerTool",
+    value: function registerTool(toolClass) {
+      MeasurementReport.CORNERSTONE_TOOL_CLASSES_BY_UTILITY_TYPE[toolClass.utilityToolType] = toolClass;
+      MeasurementReport.CORNERSTONE_TOOL_CLASSES_BY_TOOL_TYPE[toolClass.toolType] = toolClass;
+      MeasurementReport.MEASUREMENT_BY_TOOLTYPE[toolClass.toolType] = toolClass.utilityToolType;
+    }
+  }]);
+}();
+MeasurementReport.MEASUREMENT_BY_TOOLTYPE = {};
+MeasurementReport.CORNERSTONE_TOOL_CLASSES_BY_UTILITY_TYPE = {};
+MeasurementReport.CORNERSTONE_TOOL_CLASSES_BY_TOOL_TYPE = {};
+
+export { MeasurementReport as default };

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

@@ -0,0 +1,7 @@
+declare function generateToolState(imageIds: any, arrayBuffer: any, metadataProvider: any, tolerance?: number): Promise<{
+    pixelData: any;
+}>;
+declare const ParametricMapObj: {
+    generateToolState: typeof generateToolState;
+};
+export { ParametricMapObj as default, ParametricMapObj as ParametricMap };

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

@@ -0,0 +1,210 @@
+import { asyncToGenerator as _asyncToGenerator, regeneratorRuntime as _regeneratorRuntime, toConsumableArray as _toConsumableArray } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { data, normalizers, log } from 'dcmjs';
+import checkOrientation from '../helpers/checkOrientation.js';
+import compareArrays from '../helpers/compareArrays.js';
+
+var DicomMessage = data.DicomMessage,
+  DicomMetaDictionary = data.DicomMetaDictionary;
+var Normalizer = normalizers.Normalizer;
+function generateToolState(_x, _x2, _x3) {
+  return _generateToolState.apply(this, arguments);
+}
+function _generateToolState() {
+  _generateToolState = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(imageIds, arrayBuffer, metadataProvider) {
+    var tolerance,
+      dicomData,
+      dataset,
+      multiframe,
+      imagePlaneModule,
+      ImageOrientationPatient,
+      validOrientations,
+      pixelData,
+      orientation,
+      sopUIDImageIdIndexMap,
+      orientationText,
+      imageIdMaps,
+      _args = arguments;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          tolerance = _args.length > 3 && _args[3] !== undefined ? _args[3] : 1e-3;
+          dicomData = DicomMessage.readFile(arrayBuffer);
+          dataset = DicomMetaDictionary.naturalizeDataset(dicomData.dict);
+          dataset._meta = DicomMetaDictionary.namifyDataset(dicomData.meta);
+          multiframe = Normalizer.normalizeToDataset([dataset]);
+          imagePlaneModule = metadataProvider.get("imagePlaneModule", imageIds[0]);
+          if (!imagePlaneModule) {
+            console.warn("Insufficient metadata, imagePlaneModule missing.");
+          }
+          ImageOrientationPatient = Array.isArray(imagePlaneModule.rowCosines) ? [].concat(_toConsumableArray(imagePlaneModule.rowCosines), _toConsumableArray(imagePlaneModule.columnCosines)) : [imagePlaneModule.rowCosines.x, imagePlaneModule.rowCosines.y, imagePlaneModule.rowCosines.z, imagePlaneModule.columnCosines.x, imagePlaneModule.columnCosines.y, imagePlaneModule.columnCosines.z];
+          validOrientations = [ImageOrientationPatient];
+          pixelData = getPixelData(multiframe);
+          orientation = checkOrientation(multiframe, validOrientations, [imagePlaneModule.rows, imagePlaneModule.columns, imageIds.length], tolerance);
+          sopUIDImageIdIndexMap = imageIds.reduce(function (acc, imageId) {
+            var _metadataProvider$get = metadataProvider.get("generalImageModule", imageId),
+              sopInstanceUID = _metadataProvider$get.sopInstanceUID;
+            acc[sopInstanceUID] = imageId;
+            return acc;
+          }, {});
+          if (!(orientation !== "Planar")) {
+            _context.next = 15;
+            break;
+          }
+          orientationText = {
+            Perpendicular: "orthogonal",
+            Oblique: "oblique"
+          };
+          throw new Error("Parametric maps ".concat(orientationText[orientation], " to the acquisition plane of the source data are not yet supported."));
+        case 15:
+          imageIdMaps = imageIds.reduce(function (acc, curr, index) {
+            acc.indices[curr] = index;
+            acc.metadata[curr] = metadataProvider.get("instance", curr);
+            return acc;
+          }, {
+            indices: {},
+            metadata: {}
+          });
+          _context.next = 18;
+          return insertPixelDataPlanar(pixelData, multiframe, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap, imageIdMaps);
+        case 18:
+          return _context.abrupt("return", {
+            pixelData: pixelData
+          });
+        case 19:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _generateToolState.apply(this, arguments);
+}
+function insertPixelDataPlanar(sourcePixelData, multiframe, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap, imageIdMaps) {
+  var targetPixelData = new sourcePixelData.constructor(sourcePixelData.length);
+  var PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
+    Rows = multiframe.Rows,
+    Columns = multiframe.Columns;
+  var sliceLength = Columns * Rows;
+  var numSlices = PerFrameFunctionalGroupsSequence.length;
+  for (var i = 0; i < numSlices; i++) {
+    var sourceSliceDataView = new sourcePixelData.constructor(sourcePixelData.buffer, i * sliceLength, sliceLength);
+    var imageId = findReferenceSourceImageId(multiframe, i, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap);
+    if (!imageId) {
+      console.warn("Image not present in stack, can't import frame : " + i + ".");
+      continue;
+    }
+    var 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.");
+    }
+    var imageIdIndex = imageIdMaps.indices[imageId];
+    var byteOffset = sliceLength * imageIdIndex * targetPixelData.BYTES_PER_ELEMENT;
+    var targetSliceDataView = new targetPixelData.constructor(targetPixelData.buffer, byteOffset, sliceLength);
+    targetSliceDataView.set(sourceSliceDataView);
+  }
+  return targetPixelData;
+}
+function getPixelData(multiframe) {
+  var TypedArrayClass;
+  var data;
+  if (multiframe.PixelData) {
+    var _multiframe$PixelRepr;
+    var validTypedArrays = multiframe.BitsAllocated === 16 ? [Uint16Array, Int16Array] : [Uint32Array, Int32Array];
+    TypedArrayClass = validTypedArrays[(_multiframe$PixelRepr = multiframe.PixelRepresentation) !== null && _multiframe$PixelRepr !== void 0 ? _multiframe$PixelRepr : 0];
+    data = multiframe.PixelData;
+  } else if (multiframe.FloatPixelData) {
+    TypedArrayClass = Float32Array;
+    data = multiframe.FloatPixelData;
+  } else if (multiframe.DoubleFloatPixelData) {
+    TypedArrayClass = Float64Array;
+    data = multiframe.DoubleFloatPixelData;
+  }
+  if (data === undefined) {
+    log.error("This parametric map pixel data is undefined.");
+  }
+  if (Array.isArray(data)) {
+    data = data[0];
+  }
+  return new TypedArrayClass(data);
+}
+function findReferenceSourceImageId(multiframe, frameSegment, imageIds, metadataProvider, tolerance, sopUIDImageIdIndexMap) {
+  var imageId = undefined;
+  if (!multiframe) {
+    return imageId;
+  }
+  var FrameOfReferenceUID = multiframe.FrameOfReferenceUID,
+    PerFrameFunctionalGroupsSequence = multiframe.PerFrameFunctionalGroupsSequence,
+    SourceImageSequence = multiframe.SourceImageSequence,
+    ReferencedSeriesSequence = multiframe.ReferencedSeriesSequence;
+  if (!PerFrameFunctionalGroupsSequence || PerFrameFunctionalGroupsSequence.length === 0) {
+    return imageId;
+  }
+  var PerFrameFunctionalGroup = PerFrameFunctionalGroupsSequence[frameSegment];
+  if (!PerFrameFunctionalGroup) {
+    return imageId;
+  }
+  var frameSourceImageSequence = undefined;
+  if (PerFrameFunctionalGroup.DerivationImageSequence) {
+    var DerivationImageSequence = PerFrameFunctionalGroup.DerivationImageSequence;
+    if (Array.isArray(DerivationImageSequence)) {
+      if (DerivationImageSequence.length !== 0) {
+        DerivationImageSequence = DerivationImageSequence[0];
+      } else {
+        DerivationImageSequence = undefined;
+      }
+    }
+    if (DerivationImageSequence) {
+      frameSourceImageSequence = DerivationImageSequence.SourceImageSequence;
+      if (Array.isArray(frameSourceImageSequence)) {
+        if (frameSourceImageSequence.length !== 0) {
+          frameSourceImageSequence = frameSourceImageSequence[0];
+        } else {
+          frameSourceImageSequence = undefined;
+        }
+      }
+    }
+  } else if (SourceImageSequence && SourceImageSequence.length !== 0) {
+    console.warn("DerivationImageSequence not present, using SourceImageSequence assuming SEG has the same geometry as the source image.");
+    frameSourceImageSequence = SourceImageSequence[frameSegment];
+  }
+  if (frameSourceImageSequence) {
+    imageId = getImageIdOfSourceImageBySourceImageSequence(frameSourceImageSequence, sopUIDImageIdIndexMap);
+  }
+  if (imageId === undefined && ReferencedSeriesSequence) {
+    var referencedSeriesSequence = Array.isArray(ReferencedSeriesSequence) ? ReferencedSeriesSequence[0] : ReferencedSeriesSequence;
+    var ReferencedSeriesInstanceUID = referencedSeriesSequence.SeriesInstanceUID;
+    imageId = getImageIdOfSourceImagebyGeometry(ReferencedSeriesInstanceUID, FrameOfReferenceUID, PerFrameFunctionalGroup, imageIds, metadataProvider, tolerance);
+  }
+  return imageId;
+}
+function getImageIdOfSourceImageBySourceImageSequence(SourceImageSequence, sopUIDImageIdIndexMap) {
+  var ReferencedSOPInstanceUID = SourceImageSequence.ReferencedSOPInstanceUID,
+    ReferencedFrameNumber = SourceImageSequence.ReferencedFrameNumber;
+  return ReferencedFrameNumber ? getImageIdOfReferencedFrame(ReferencedSOPInstanceUID, ReferencedFrameNumber, sopUIDImageIdIndexMap) : sopUIDImageIdIndexMap[ReferencedSOPInstanceUID];
+}
+function getImageIdOfSourceImagebyGeometry(ReferencedSeriesInstanceUID, FrameOfReferenceUID, PerFrameFunctionalGroup, imageIds, metadataProvider, tolerance) {
+  if (ReferencedSeriesInstanceUID === undefined || PerFrameFunctionalGroup.PlanePositionSequence === undefined || PerFrameFunctionalGroup.PlanePositionSequence[0] === undefined || PerFrameFunctionalGroup.PlanePositionSequence[0].ImagePositionPatient === undefined) {
+    return undefined;
+  }
+  for (var imageIdsIndex = 0; imageIdsIndex < imageIds.length; ++imageIdsIndex) {
+    var sourceImageMetadata = metadataProvider.get("instance", imageIds[imageIdsIndex]);
+    if (sourceImageMetadata === undefined || sourceImageMetadata.ImagePositionPatient === undefined || sourceImageMetadata.FrameOfReferenceUID !== FrameOfReferenceUID || sourceImageMetadata.SeriesInstanceUID !== ReferencedSeriesInstanceUID) {
+      continue;
+    }
+    if (compareArrays(PerFrameFunctionalGroup.PlanePositionSequence[0].ImagePositionPatient, sourceImageMetadata.ImagePositionPatient, tolerance)) {
+      return imageIds[imageIdsIndex];
+    }
+  }
+}
+function getImageIdOfReferencedFrame(sopInstanceUid, frameNumber, sopUIDImageIdIndexMap) {
+  var imageId = sopUIDImageIdIndexMap[sopInstanceUid];
+  if (!imageId) {
+    return;
+  }
+  var imageIdFrameNumber = Number(imageId.split("frame=")[1]);
+  return imageIdFrameNumber === frameNumber - 1 ? imageId : undefined;
+}
+var ParametricMapObj = {
+  generateToolState: generateToolState
+};
+
+export { ParametricMapObj as ParametricMap, ParametricMapObj as default };

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

@@ -0,0 +1,44 @@
+export default RectangleRoi;
+declare class RectangleRoi {
+    static getMeasurementData(MeasurementGroup: any): {
+        toolType: string;
+        handles: {
+            start: {};
+            end: {};
+            textBox: {
+                active: boolean;
+                hasMoved: boolean;
+                movesIndependently: boolean;
+                drawnIndependently: boolean;
+                allowedOutsideImage: boolean;
+                hasBoundingBox: boolean;
+            };
+            initialRotation: number;
+        };
+        cachedStats: {
+            area: any;
+        };
+        color: any;
+        invalidated: boolean;
+        sopInstanceUid: any;
+        frameIndex: any;
+        complete: boolean;
+        finding: any;
+        findingSites: any[];
+    };
+    static getTID300RepresentationArguments(tool: any): {
+        points: any[];
+        area: any;
+        perimeter: any;
+        trackingIdentifierTextValue: string;
+        finding: any;
+        findingSites: any;
+    };
+}
+declare namespace RectangleRoi {
+    export let toolType: string;
+    export let utilityToolType: string;
+    export { TID300Polyline as TID300Representation };
+    export function isValidCornerstoneTrackingIdentifier(TrackingIdentifier: any): boolean;
+}
+declare const TID300Polyline: any;

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

@@ -0,0 +1,97 @@
+import { slicedToArray as _slicedToArray, createClass as _createClass, objectSpread2 as _objectSpread2, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { utilities } from 'dcmjs';
+import MeasurementReport from './MeasurementReport.js';
+import CORNERSTONE_4_TAG from './cornerstone4Tag.js';
+
+var TID300Polyline = utilities.TID300.Polyline;
+var RectangleRoi = /*#__PURE__*/function () {
+  function RectangleRoi() {
+    _classCallCheck(this, RectangleRoi);
+  }
+  return _createClass(RectangleRoi, null, [{
+    key: "getMeasurementData",
+    value: function getMeasurementData(MeasurementGroup) {
+      var _MeasurementReport$ge = MeasurementReport.getSetupMeasurementData(MeasurementGroup),
+        defaultState = _MeasurementReport$ge.defaultState,
+        SCOORDGroup = _MeasurementReport$ge.SCOORDGroup,
+        NUMGroup = _MeasurementReport$ge.NUMGroup;
+      var state = _objectSpread2(_objectSpread2({}, defaultState), {}, {
+        toolType: RectangleRoi.toolType,
+        handles: {
+          start: {},
+          end: {},
+          textBox: {
+            active: false,
+            hasMoved: false,
+            movesIndependently: false,
+            drawnIndependently: true,
+            allowedOutsideImage: true,
+            hasBoundingBox: true
+          },
+          initialRotation: 0
+        },
+        cachedStats: {
+          area: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : 0
+        },
+        color: undefined,
+        invalidated: true
+      });
+      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;
+    }
+  }, {
+    key: "getTID300RepresentationArguments",
+    value: function getTID300RepresentationArguments(tool) {
+      var finding = tool.finding,
+        findingSites = tool.findingSites,
+        _tool$cachedStats = tool.cachedStats,
+        cachedStats = _tool$cachedStats === void 0 ? {} : _tool$cachedStats,
+        handles = tool.handles;
+      var start = handles.start,
+        end = handles.end;
+      var points = [start, {
+        x: start.x,
+        y: end.y
+      }, end, {
+        x: end.x,
+        y: start.y
+      }];
+      var area = cachedStats.area,
+        perimeter = cachedStats.perimeter;
+      var trackingIdentifierTextValue = "cornerstoneTools@^4.0.0:RectangleRoi";
+      return {
+        points: points,
+        area: area,
+        perimeter: perimeter,
+        trackingIdentifierTextValue: trackingIdentifierTextValue,
+        finding: finding,
+        findingSites: findingSites || []
+      };
+    }
+  }]);
+}();
+RectangleRoi.toolType = "RectangleRoi";
+RectangleRoi.utilityToolType = "RectangleRoi";
+RectangleRoi.TID300Representation = TID300Polyline;
+RectangleRoi.isValidCornerstoneTrackingIdentifier = function (TrackingIdentifier) {
+  if (!TrackingIdentifier.includes(":")) {
+    return false;
+  }
+  var _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;
+  }
+  return toolType === RectangleRoi.toolType;
+};
+MeasurementReport.registerTool(RectangleRoi);
+
+export { RectangleRoi as default };

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

@@ -0,0 +1,7 @@
+export function generateSegmentation(images: object[], labelmaps3DorBrushData: any | any[], options?: {
+    includeSliceSpacing: boolean;
+}, cornerstoneToolsVersion?: number): any;
+export function generateToolState(imageIds: string[], arrayBuffer: ArrayBuffer, metadataProvider: any, skipOverlapping?: boolean, tolerance?: number, cornerstoneToolsVersion?: number): any;
+export function fillSegmentation(segmentation: object[], inputLabelmaps3D: any | any[], options?: {
+    includeSliceSpacing: boolean;
+}, cornerstoneToolsVersion?: number): Blob;