@cornerstonejs/adapters 3.0.0-beta.5 → 3.0.0-beta.6

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

@@ -1,277 +1,296 @@
-import { objectSpread2 as _objectSpread2, createClass as _createClass, classCallCheck as _classCallCheck } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import _defineProperty from '../../node_modules/@babel/runtime/helpers/esm/defineProperty.js';
 import { utilities, derivations, normalizers, data } from 'dcmjs';
 import CORNERSTONE_3D_TAG from './cornerstone3DTag.js';
 import { toArray } from '../helpers/toArray.js';
 import { codeMeaningEquals } from '../helpers/codeMeaningEquals.js';
-import '../helpers/downloadDICOMData.js';
+import 'buffer';
 import CodingScheme from './CodingScheme.js';
 
 var _MeasurementReport;
-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 = {
+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 {
+  TID1500,
+  addAccessors
+} = utilities;
+const {
+  StructuredReport
+} = derivations;
+const {
+  Normalizer
+} = normalizers;
+const {
+  TID1500MeasurementReport,
+  TID1501MeasurementGroup
+} = TID1500;
+const {
+  DicomMetaDictionary
+} = data;
+const FINDING = {
   CodingSchemeDesignator: "DCM",
   CodeValue: "121071"
 };
-var FINDING_SITE = {
+const FINDING_SITE = {
   CodingSchemeDesignator: "SCT",
   CodeValue: "363698007"
 };
-var FINDING_SITE_OLD = {
+const FINDING_SITE_OLD = {
   CodingSchemeDesignator: "SRT",
   CodeValue: "G-C0E3"
 };
-var codeValueMatch = function codeValueMatch(group, code, oldCode) {
-  var ConceptNameCodeSequence = group.ConceptNameCodeSequence;
-  if (!ConceptNameCodeSequence) {
-    return;
+class MeasurementReport {
+  static getTID300ContentItem(tool, ReferencedSOPSequence, toolClass, worldToImageCoords) {
+    const args = toolClass.getTID300RepresentationArguments(tool, worldToImageCoords);
+    args.ReferencedSOPSequence = ReferencedSOPSequence;
+    const TID300Measurement = new toolClass.TID300Representation(args);
+    return TID300Measurement;
   }
-  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, worldToImageCoords) {
-  var args = toolClass.getTID300RepresentationArguments(tool, worldToImageCoords);
-  args.ReferencedSOPSequence = ReferencedSOPSequence;
-  var TID300Measurement = new toolClass.TID300Representation(args);
-  return TID300Measurement;
-}
-function getMeasurementGroup(toolType, toolData, ReferencedSOPSequence, worldToImageCoords) {
-  var toolTypeData = toolData[toolType];
-  var toolClass = MeasurementReport.CORNERSTONE_TOOL_CLASSES_BY_TOOL_TYPE[toolType];
-  if (!toolTypeData || !toolTypeData.data || !toolTypeData.data.length || !toolClass) {
-    return;
+  static getMeasurementGroup(toolType, toolData, ReferencedSOPSequence, worldToImageCoords) {
+    const toolTypeData = toolData[toolType];
+    const toolClass = this.measurementAdapterByToolType.get(toolType);
+    if (!toolTypeData || !toolTypeData.data || !toolTypeData.data.length || !toolClass) {
+      return;
+    }
+    const Measurements = toolTypeData.data.map(tool => {
+      return this.getTID300ContentItem(tool, ReferencedSOPSequence, toolClass, worldToImageCoords);
+    });
+    return new TID1501MeasurementGroup(Measurements);
   }
-  var Measurements = toolTypeData.data.map(function (tool) {
-    return getTID300ContentItem(tool, toolType, ReferencedSOPSequence, toolClass, worldToImageCoords);
-  });
-  return new TID1501MeasurementGroup(Measurements);
-}
-var MeasurementReport = /*#__PURE__*/function () {
-  function MeasurementReport() {
-    _classCallCheck(this, MeasurementReport);
+  static getCornerstoneLabelFromDefaultState(defaultState) {
+    const {
+      findingSites = [],
+      finding
+    } = defaultState;
+    const cornersoneFreeTextCodingValue = CodingScheme.codeValues.CORNERSTONEFREETEXT;
+    const freeTextLabel = findingSites.find(fs => fs.CodeValue === cornersoneFreeTextCodingValue);
+    if (freeTextLabel) {
+      return freeTextLabel.CodeMeaning;
+    }
+    if (finding && finding.CodeValue === cornersoneFreeTextCodingValue) {
+      return finding.CodeMeaning;
+    }
   }
-  return _createClass(MeasurementReport, null, [{
-    key: "getCornerstoneLabelFromDefaultState",
-    value: function getCornerstoneLabelFromDefaultState(defaultState) {
-      var _defaultState$finding = defaultState.findingSites,
-        findingSites = _defaultState$finding === void 0 ? [] : _defaultState$finding,
-        finding = defaultState.finding;
-      var cornersoneFreeTextCodingValue = CodingScheme.codeValues.CORNERSTONEFREETEXT;
-      var freeTextLabel = findingSites.find(function (fs) {
-        return fs.CodeValue === cornersoneFreeTextCodingValue;
-      });
-      if (freeTextLabel) {
-        return freeTextLabel.CodeMeaning;
-      }
-      if (finding && finding.CodeValue === cornersoneFreeTextCodingValue) {
-        return finding.CodeMeaning;
+  static generateDatasetMeta() {
+    const fileMetaInformationVersionArray = new Uint8Array(2);
+    fileMetaInformationVersionArray[1] = 1;
+    const _meta = {
+      FileMetaInformationVersion: {
+        Value: [fileMetaInformationVersionArray.buffer],
+        vr: "OB"
+      },
+      TransferSyntaxUID: {
+        Value: ["1.2.840.10008.1.2.1"],
+        vr: "UI"
+      },
+      ImplementationClassUID: {
+        Value: [DicomMetaDictionary.uid()],
+        vr: "UI"
+      },
+      ImplementationVersionName: {
+        Value: ["dcmjs"],
+        vr: "SH"
       }
-    }
-  }, {
-    key: "generateDatasetMeta",
-    value: function generateDatasetMeta() {
-      var fileMetaInformationVersionArray = new Uint8Array(2);
-      fileMetaInformationVersionArray[1] = 1;
-      var _meta = {
-        FileMetaInformationVersion: {
-          Value: [fileMetaInformationVersionArray.buffer],
-          vr: "OB"
-        },
-        TransferSyntaxUID: {
-          Value: ["1.2.840.10008.1.2.1"],
-          vr: "UI"
-        },
-        ImplementationClassUID: {
-          Value: [DicomMetaDictionary.uid()],
-          vr: "UI"
+    };
+    return _meta;
+  }
+  static getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, toolType) {
+    const {
+      ContentSequence
+    } = MeasurementGroup;
+    const contentSequenceArr = toArray(ContentSequence);
+    const findingGroup = contentSequenceArr.find(group => this.codeValueMatch(group, FINDING));
+    const findingSiteGroups = contentSequenceArr.filter(group => this.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 referencedImageId = sopInstanceUIDToImageIdMap[ReferencedSOPInstanceUID];
+    const imagePlaneModule = metadata.get("imagePlaneModule", referencedImageId);
+    const finding = findingGroup ? addAccessors(findingGroup.ConceptCodeSequence) : undefined;
+    const findingSites = findingSiteGroups.map(fsg => {
+      return addAccessors(fsg.ConceptCodeSequence);
+    });
+    const defaultState = {
+      description: undefined,
+      sopInstanceUid: ReferencedSOPInstanceUID,
+      annotation: {
+        annotationUID: DicomMetaDictionary.uid(),
+        metadata: {
+          toolName: toolType,
+          referencedImageId,
+          FrameOfReferenceUID: imagePlaneModule.frameOfReferenceUID,
+          label: ""
         },
-        ImplementationVersionName: {
-          Value: ["dcmjs"],
-          vr: "SH"
-        }
-      };
-      return _meta;
+        data: undefined
+      },
+      finding,
+      findingSites
+    };
+    if (defaultState.finding) {
+      defaultState.description = defaultState.finding.CodeMeaning;
     }
-  }, {
-    key: "getSetupMeasurementData",
-    value: function getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, toolType) {
-      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 referencedImageId = sopInstanceUIDToImageIdMap[ReferencedSOPInstanceUID];
-      var imagePlaneModule = metadata.get("imagePlaneModule", referencedImageId);
-      var finding = findingGroup ? addAccessors(findingGroup.ConceptCodeSequence) : undefined;
-      var findingSites = findingSiteGroups.map(function (fsg) {
-        return addAccessors(fsg.ConceptCodeSequence);
-      });
-      var defaultState = {
-        description: undefined,
-        sopInstanceUid: ReferencedSOPInstanceUID,
-        annotation: {
-          annotationUID: DicomMetaDictionary.uid(),
-          metadata: {
-            toolName: toolType,
-            referencedImageId: referencedImageId,
-            FrameOfReferenceUID: imagePlaneModule.frameOfReferenceUID,
-            label: ""
-          },
-          data: undefined
-        },
-        finding: finding,
-        findingSites: findingSites
-      };
-      if (defaultState.finding) {
-        defaultState.description = defaultState.finding.CodeMeaning;
+    defaultState.annotation.metadata.label = MeasurementReport.getCornerstoneLabelFromDefaultState(defaultState);
+    return {
+      defaultState,
+      NUMGroup,
+      SCOORDGroup,
+      ReferencedSOPSequence,
+      ReferencedSOPInstanceUID,
+      ReferencedFrameNumber
+    };
+  }
+  static generateReport(toolState, metadataProvider, worldToImageCoords, options) {
+    let allMeasurementGroups = [];
+    const sopInstanceUIDsToSeriesInstanceUIDMap = {};
+    const derivationSourceDatasets = [];
+    const _meta = MeasurementReport.generateDatasetMeta();
+    Object.keys(toolState).forEach(imageId => {
+      const sopCommonModule = metadataProvider.get("sopCommonModule", imageId);
+      const instance = metadataProvider.get("instance", imageId);
+      const {
+        sopInstanceUID,
+        sopClassUID
+      } = sopCommonModule;
+      const {
+        SeriesInstanceUID: seriesInstanceUID
+      } = instance;
+      sopInstanceUIDsToSeriesInstanceUIDMap[sopInstanceUID] = seriesInstanceUID;
+      if (!derivationSourceDatasets.find(dsd => dsd.SeriesInstanceUID === seriesInstanceUID)) {
+        const derivationSourceDataset = MeasurementReport.generateDerivationSourceDataset(instance);
+        derivationSourceDatasets.push(derivationSourceDataset);
       }
-      defaultState.annotation.metadata.label = MeasurementReport.getCornerstoneLabelFromDefaultState(defaultState);
-      return {
-        defaultState: defaultState,
-        NUMGroup: NUMGroup,
-        SCOORDGroup: SCOORDGroup,
-        ReferencedSOPSequence: ReferencedSOPSequence,
-        ReferencedSOPInstanceUID: ReferencedSOPInstanceUID,
-        ReferencedFrameNumber: ReferencedFrameNumber
+      const frameNumber = metadataProvider.get("frameNumber", imageId);
+      const toolData = toolState[imageId];
+      const toolTypes = Object.keys(toolData);
+      const ReferencedSOPSequence = {
+        ReferencedSOPClassUID: sopClassUID,
+        ReferencedSOPInstanceUID: sopInstanceUID,
+        ReferencedFrameNumber: undefined
       };
-    }
-  }, {
-    key: "generateReport",
-    value: function generateReport(toolState, metadataProvider, worldToImageCoords, options) {
-      var allMeasurementGroups = [];
-      var sopInstanceUIDsToSeriesInstanceUIDMap = {};
-      var derivationSourceDatasets = [];
-      var _meta = MeasurementReport.generateDatasetMeta();
-      Object.keys(toolState).forEach(function (imageId) {
-        var sopCommonModule = metadataProvider.get("sopCommonModule", imageId);
-        var instance = metadataProvider.get("instance", imageId);
-        var sopInstanceUID = sopCommonModule.sopInstanceUID,
-          sopClassUID = sopCommonModule.sopClassUID;
-        var seriesInstanceUID = instance.SeriesInstanceUID;
-        sopInstanceUIDsToSeriesInstanceUIDMap[sopInstanceUID] = seriesInstanceUID;
-        if (!derivationSourceDatasets.find(function (dsd) {
-          return dsd.SeriesInstanceUID === seriesInstanceUID;
-        })) {
-          var derivationSourceDataset = MeasurementReport.generateDerivationSourceDataset(instance);
-          derivationSourceDatasets.push(derivationSourceDataset);
-        }
-        var frameNumber = metadataProvider.get("frameNumber", imageId);
-        var toolData = toolState[imageId];
-        var toolTypes = Object.keys(toolData);
-        var ReferencedSOPSequence = {
-          ReferencedSOPClassUID: sopClassUID,
-          ReferencedSOPInstanceUID: sopInstanceUID,
-          ReferencedFrameNumber: undefined
-        };
-        if (instance && instance.NumberOfFrames && instance.NumberOfFrames > 1 || Normalizer.isMultiframeSOPClassUID(sopClassUID)) {
-          ReferencedSOPSequence.ReferencedFrameNumber = frameNumber;
+      if (instance && instance.NumberOfFrames && instance.NumberOfFrames > 1 || Normalizer.isMultiframeSOPClassUID(sopClassUID)) {
+        ReferencedSOPSequence.ReferencedFrameNumber = frameNumber;
+      }
+      const measurementGroups = [];
+      toolTypes.forEach(toolType => {
+        const group = this.getMeasurementGroup(toolType, toolData, ReferencedSOPSequence, worldToImageCoords);
+        if (group) {
+          measurementGroups.push(group);
         }
-        var measurementGroups = [];
-        toolTypes.forEach(function (toolType) {
-          var group = getMeasurementGroup(toolType, toolData, ReferencedSOPSequence, worldToImageCoords);
-          if (group) {
-            measurementGroups.push(group);
-          }
-        });
-        allMeasurementGroups = allMeasurementGroups.concat(measurementGroups);
       });
-      var tid1500MeasurementReport = new TID1500MeasurementReport({
-        TID1501MeasurementGroups: allMeasurementGroups
-      }, options);
-      var report = new StructuredReport(derivationSourceDatasets, options);
-      var contentItem = tid1500MeasurementReport.contentItem(derivationSourceDatasets, _objectSpread2(_objectSpread2({}, options), {}, {
-        sopInstanceUIDsToSeriesInstanceUIDMap: sopInstanceUIDsToSeriesInstanceUIDMap
-      }));
-      report.dataset = Object.assign(report.dataset, contentItem);
-      report.dataset._meta = _meta;
-      report.SpecificCharacterSet = "ISO_IR 192";
-      return report;
+      allMeasurementGroups = allMeasurementGroups.concat(measurementGroups);
+    });
+    const tid1500MeasurementReport = new TID1500MeasurementReport({
+      TID1501MeasurementGroups: allMeasurementGroups
+    }, options);
+    const report = new StructuredReport(derivationSourceDatasets, options);
+    const contentItem = tid1500MeasurementReport.contentItem(derivationSourceDatasets, _objectSpread(_objectSpread({}, options), {}, {
+      sopInstanceUIDsToSeriesInstanceUIDMap
+    }));
+    report.dataset = Object.assign(report.dataset, contentItem);
+    report.dataset._meta = _meta;
+    report.SpecificCharacterSet = "ISO_IR 192";
+    return report;
+  }
+  static generateToolState(dataset, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata, hooks) {
+    if (dataset.ContentTemplateSequence.TemplateIdentifier !== "1500") {
+      throw new Error("This package can currently only interpret DICOM SR TID 1500");
     }
-  }, {
-    key: "generateToolState",
-    value: function generateToolState(dataset, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata, hooks) {
-      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";
-      var TRACKING_UNIQUE_IDENTIFIER = "Tracking Unique Identifier";
-      var imagingMeasurementContent = toArray(dataset.ContentSequence).find(codeMeaningEquals(REPORT));
-      var measurementGroups = toArray(imagingMeasurementContent.ContentSequence).filter(codeMeaningEquals(GROUP));
-      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) {
-        try {
-          var _hooks$getToolClass;
-          var measurementGroupContentSequence = toArray(measurementGroup.ContentSequence);
-          var TrackingIdentifierGroup = measurementGroupContentSequence.find(function (contentItem) {
-            return contentItem.ConceptNameCodeSequence.CodeMeaning === TRACKING_IDENTIFIER;
-          });
-          var TrackingIdentifierValue = TrackingIdentifierGroup.TextValue;
-          var TrackingUniqueIdentifierGroup = measurementGroupContentSequence.find(function (contentItem) {
-            return contentItem.ConceptNameCodeSequence.CodeMeaning === TRACKING_UNIQUE_IDENTIFIER;
-          });
-          var TrackingUniqueIdentifierValue = TrackingUniqueIdentifierGroup === null || TrackingUniqueIdentifierGroup === void 0 ? void 0 : TrackingUniqueIdentifierGroup.UID;
-          var toolClass = (hooks === null || hooks === void 0 || (_hooks$getToolClass = hooks.getToolClass) === null || _hooks$getToolClass === void 0 ? void 0 : _hooks$getToolClass.call(hooks, measurementGroup, dataset, registeredToolClasses)) || registeredToolClasses.find(function (tc) {
-            return tc.isValidCornerstoneTrackingIdentifier(TrackingIdentifierValue);
-          });
-          if (toolClass) {
-            var measurement = toolClass.getMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata);
-            measurement.TrackingUniqueIdentifier = TrackingUniqueIdentifierValue;
-            console.log("=== ".concat(toolClass.toolType, " ==="));
-            console.log(measurement);
-            measurementData[toolClass.toolType].push(measurement);
-          }
-        } catch (e) {
-          console.warn("Unable to generate tool state for", measurementGroup, e);
+    const REPORT = "Imaging Measurements";
+    const GROUP = "Measurement Group";
+    const TRACKING_IDENTIFIER = "Tracking Identifier";
+    const TRACKING_UNIQUE_IDENTIFIER = "Tracking Unique Identifier";
+    const imagingMeasurementContent = toArray(dataset.ContentSequence).find(codeMeaningEquals(REPORT));
+    const measurementGroups = toArray(imagingMeasurementContent.ContentSequence).filter(codeMeaningEquals(GROUP));
+    const measurementData = {};
+    measurementGroups.forEach(measurementGroup => {
+      try {
+        var _hooks$getToolClass;
+        const measurementGroupContentSequence = toArray(measurementGroup.ContentSequence);
+        const trackingIdentifierGroup = measurementGroupContentSequence.find(contentItem => contentItem.ConceptNameCodeSequence.CodeMeaning === TRACKING_IDENTIFIER);
+        const {
+          TextValue: trackingIdentifierValue
+        } = trackingIdentifierGroup;
+        const trackingUniqueIdentifierGroup = measurementGroupContentSequence.find(contentItem => contentItem.ConceptNameCodeSequence.CodeMeaning === TRACKING_UNIQUE_IDENTIFIER);
+        const trackingUniqueIdentifierValue = trackingUniqueIdentifierGroup === null || trackingUniqueIdentifierGroup === void 0 ? void 0 : trackingUniqueIdentifierGroup.UID;
+        const toolAdapter = (hooks === null || hooks === void 0 || (_hooks$getToolClass = hooks.getToolClass) === null || _hooks$getToolClass === void 0 ? void 0 : _hooks$getToolClass.call(hooks, measurementGroup, dataset, this.measurementAdapterByToolType)) || this.getAdapterForTrackingIdentifier(trackingIdentifierValue);
+        if (toolAdapter) {
+          var _toolAdapter$toolType;
+          const measurement = toolAdapter.getMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata, trackingIdentifierValue);
+          measurement.TrackingUniqueIdentifier = trackingUniqueIdentifierValue;
+          console.log("=== ".concat(toolAdapter.toolType, " ==="));
+          console.log(measurement);
+          measurementData[_toolAdapter$toolType = toolAdapter.toolType] || (measurementData[_toolAdapter$toolType] = []);
+          measurementData[toolAdapter.toolType].push(measurement);
         }
-      });
-      return measurementData;
+      } catch (e) {
+        console.warn("Unable to generate tool state for", measurementGroup, e);
+      }
+    });
+    return measurementData;
+  }
+  static registerTool(toolAdapter) {
+    let replace = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    const registerName = toolAdapter.toolType;
+    if (this.measurementAdapterByToolType.has(registerName)) {
+      if (!replace) {
+        throw new Error("The registered tool name ".concat(registerName, " already exists in adapters, use a different toolType or use replace"));
+      }
+      if (typeof replace === "function") {
+        replace(this.measurementAdapterByToolType.get(registerName));
+      }
     }
-  }, {
-    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;
+    this.measurementAdapterByToolType.set(toolAdapter.toolType, toolAdapter);
+    this.measurementAdapterByTrackingIdentifier.set(toolAdapter.trackingIdentifierTextValue, toolAdapter);
+  }
+  static registerTrackingIdentifier(toolClass) {
+    for (var _len = arguments.length, trackingIdentifiers = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      trackingIdentifiers[_key - 1] = arguments[_key];
     }
-  }]);
-}();
+    for (const identifier of trackingIdentifiers) {
+      this.measurementAdapterByTrackingIdentifier.set(identifier, toolClass);
+    }
+  }
+  static getAdapterForTrackingIdentifier(trackingIdentifier) {
+    const adapter = this.measurementAdapterByTrackingIdentifier.get(trackingIdentifier);
+    if (adapter) {
+      return adapter;
+    }
+    for (const adapterTest of [...this.measurementAdapterByToolType.values()]) {
+      if (adapterTest.isValidCornerstoneTrackingIdentifier(trackingIdentifier)) {
+        this.measurementAdapterByTrackingIdentifier.set(trackingIdentifier, adapterTest);
+        return adapterTest;
+      }
+    }
+  }
+}
 _MeasurementReport = MeasurementReport;
 _MeasurementReport.CORNERSTONE_3D_TAG = CORNERSTONE_3D_TAG;
-_MeasurementReport.MEASUREMENT_BY_TOOLTYPE = {};
-_MeasurementReport.CORNERSTONE_TOOL_CLASSES_BY_UTILITY_TYPE = {};
-_MeasurementReport.CORNERSTONE_TOOL_CLASSES_BY_TOOL_TYPE = {};
-_MeasurementReport.generateDerivationSourceDataset = function (instance) {
-  var _vrMap = {
+_MeasurementReport.measurementAdapterByToolType = new Map();
+_MeasurementReport.measurementAdapterByTrackingIdentifier = new Map();
+_MeasurementReport.codeValueMatch = (group, code, oldCode) => {
+  const {
+    ConceptNameCodeSequence
+  } = group;
+  if (!ConceptNameCodeSequence) {
+    return;
+  }
+  const {
+    CodingSchemeDesignator,
+    CodeValue
+  } = ConceptNameCodeSequence;
+  return CodingSchemeDesignator == code.CodingSchemeDesignator && CodeValue == code.CodeValue || oldCode && CodingSchemeDesignator == oldCode.CodingSchemeDesignator && CodeValue == oldCode.CodeValue;
+};
+_MeasurementReport.generateDerivationSourceDataset = instance => {
+  const _vrMap = {
     PixelData: "OW"
   };
-  var _meta = _MeasurementReport.generateDatasetMeta();
-  var derivationSourceDataset = _objectSpread2(_objectSpread2({}, instance), {}, {
+  const _meta = _MeasurementReport.generateDatasetMeta();
+  const derivationSourceDataset = _objectSpread(_objectSpread({}, instance), {}, {
     _meta: _meta,
     _vrMap: _vrMap
   });

package/dist/esm/adapters/Cornerstone3D/ParametricMap/generateToolState.js

@@ -1,10 +1,14 @@
 import { CornerstonePMAP } from '../../Cornerstone/index.js';
 
-var ParametricMap = CornerstonePMAP.ParametricMap;
-var generateToolStateCornerstone = ParametricMap.generateToolState;
+const {
+  ParametricMap
+} = CornerstonePMAP;
+const {
+  generateToolState: generateToolStateCornerstone
+} = ParametricMap;
 function generateToolState(imageIds, arrayBuffer, metadataProvider) {
-  var skipOverlapping = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-  var tolerance = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1e-3;
+  let skipOverlapping = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  let tolerance = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1e-3;
   return generateToolStateCornerstone(imageIds, arrayBuffer, metadataProvider, skipOverlapping, tolerance);
 }
 

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

@@ -1,8 +1,6 @@
-declare class PlanarFreehandROI {
-    static toolType: string;
-    static utilityToolType: string;
-    static TID300Representation: any;
-    static isValidCornerstoneTrackingIdentifier: (TrackingIdentifier: any) => boolean;
+import BaseAdapter3D from "./BaseAdapter3D";
+declare class PlanarFreehandROI extends BaseAdapter3D {
+    static closedContourThreshold: number;
     static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any): {
         description: any;
         sopInstanceUid: any;