@cornerstonejs/adapters 4.0.0-beta.3 → 4.0.0-beta.5

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

@@ -1,19 +1,22 @@
-import { utilities, derivations, normalizers, data } from 'dcmjs';
-import { cache } from '@cornerstonejs/core';
+import { utilities as utilities$1, derivations, normalizers, data } from 'dcmjs';
+import { utilities, cache } from '@cornerstonejs/core';
 import CORNERSTONE_3D_TAG from './cornerstone3DTag.js';
 import { toArray } from '../helpers/toArray.js';
 import { codeMeaningEquals } from '../helpers/codeMeaningEquals.js';
 import 'buffer';
 import { copyStudyTags } from '../helpers/copyStudyTags.js';
 import { copySeriesTags } from '../helpers/copySeriesTags.js';
+import { scoordToWorld } from '../helpers/scoordToWorld.js';
+import { toPoint3 } from '../helpers/toPoint3.js';
 import CodingScheme from './CodingScheme.js';
-import { NO_IMAGE_ID } from './constants/index.js';
+import { COMMENT_CODE, TEXT_ANNOTATION_POSITION, NO_IMAGE_ID } from './constants/index.js';
+import LabelData from './LabelData.js';
 
 var _MeasurementReport;
 const {
   TID1500,
   addAccessors
-} = utilities;
+} = utilities$1;
 const {
   StructuredReport
 } = derivations;
@@ -31,6 +34,14 @@ const FINDING = {
   CodingSchemeDesignator: "DCM",
   CodeValue: "121071"
 };
+const COMMENT = {
+  CodingSchemeDesignator: COMMENT_CODE.schemeDesignator,
+  CodeValue: COMMENT_CODE.value
+};
+const COMMENT_POSITION = {
+  CodingSchemeDesignator: TEXT_ANNOTATION_POSITION.schemeDesignator,
+  CodeValue: TEXT_ANNOTATION_POSITION.value
+};
 const FINDING_SITE = {
   CodingSchemeDesignator: "SCT",
   CodeValue: "363698007"
@@ -40,28 +51,36 @@ const FINDING_SITE_OLD = {
   CodeValue: "G-C0E3"
 };
 class MeasurementReport {
-  static getTID300ContentItem(tool, ReferencedSOPSequence, toolClass, worldToImageCoords) {
-    const args = toolClass.getTID300RepresentationArguments(tool, worldToImageCoords);
+  static getTID300ContentItem(tool, ReferencedSOPSequence, toolClass, is3DMeasurement) {
+    const args = toolClass.getTID300RepresentationArguments(tool, is3DMeasurement);
     args.ReferencedSOPSequence = ReferencedSOPSequence;
-    const TID300Measurement = new toolClass.TID300Representation(args);
-    return TID300Measurement;
+    if (args.use3DSpatialCoordinates) {
+      args.ReferencedFrameOfReferenceUID = tool.metadata.FrameOfReferenceUID;
+    }
+    const tid300Measurement = new toolClass.TID300Representation(args);
+    const labelMeasurement = new LabelData(tid300Measurement, tool);
+    return labelMeasurement;
   }
-  static getMeasurementGroup(toolType, toolData, ReferencedSOPSequence, worldToImageCoords) {
+  static getMeasurementGroup(toolType, toolData, ReferencedSOPSequence, is3DMeasurement) {
     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 this.getTID300ContentItem(tool, ReferencedSOPSequence, toolClass, is3DMeasurement);
     });
     return new TID1501MeasurementGroup(Measurements);
   }
   static getCornerstoneLabelFromDefaultState(defaultState) {
     const {
       findingSites = [],
-      finding
+      finding,
+      commentGroup
     } = defaultState;
+    if (commentGroup?.TextValue) {
+      return commentGroup.TextValue;
+    }
     const cornersoneFreeTextCodingValue = CodingScheme.codeValues.CORNERSTONEFREETEXT;
     const freeTextLabel = findingSites.find(fs => fs.CodeValue === cornersoneFreeTextCodingValue);
     if (freeTextLabel) {
@@ -110,21 +129,32 @@ class MeasurementReport {
     } = ReferencedSOPSequence;
     const referencedImageId = sopInstanceUIDToImageIdMap[ReferencedSOPInstanceUID];
     const imagePlaneModule = metadata.get("imagePlaneModule", referencedImageId);
+    const annotationUID = DicomMetaDictionary.uid();
     return {
       SCOORDGroup,
       ReferencedSOPSequence,
       ReferencedSOPInstanceUID,
       ReferencedFrameNumber,
+      referencedImageId,
       state: {
         description: undefined,
         sopInstanceUid: ReferencedSOPInstanceUID,
         annotation: {
-          annotationUID: DicomMetaDictionary.uid(),
+          data: {
+            annotationUID,
+            cachedStats: {},
+            handles: {
+              activeHandleIndex: 0,
+              textBox: {
+                hasMoved: false
+              }
+            }
+          },
+          annotationUID,
           metadata: {
             toolName: toolType,
             referencedImageId,
-            FrameOfReferenceUID: imagePlaneModule.frameOfReferenceUID,
-            label: ""
+            FrameOfReferenceUID: imagePlaneModule.frameOfReferenceUID
           }
         }
       }
@@ -135,21 +165,33 @@ class MeasurementReport {
       SCOORD3DGroup,
       toolType
     } = _ref2;
-    return {
+    const annotationUID = DicomMetaDictionary.uid();
+    const toolData = {
       SCOORD3DGroup,
       FrameOfReferenceUID: SCOORD3DGroup.ReferencedFrameOfReferenceUID,
       state: {
         description: undefined,
         annotation: {
-          annotationUID: DicomMetaDictionary.uid(),
+          annotationUID,
+          data: {
+            annotationUID,
+            cachedStats: {},
+            handles: {
+              activeHandleIndex: 0,
+              textBox: {
+                hasMoved: false
+              }
+            }
+          },
           metadata: {
             toolName: toolType,
-            FrameOfReferenceUID: SCOORD3DGroup.ReferencedFrameOfReferenceUID,
-            label: ""
+            FrameOfReferenceUID: SCOORD3DGroup.ReferencedFrameOfReferenceUID
           }
         }
       }
     };
+    utilities.updatePlaneRestriction(toPoint3(SCOORD3DGroup.GraphicData), toolData.state.annotation.metadata);
+    return toolData;
   }
   static getSpatialCoordinatesState(_ref3) {
     let {
@@ -158,23 +200,22 @@ class MeasurementReport {
       metadata,
       toolType
     } = _ref3;
-    const SCOORDGroup = toArray(NUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD");
-    const SCOORD3DGroup = toArray(NUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD3D");
-    if (SCOORDGroup) {
-      return this.processSCOORDGroup({
-        SCOORDGroup,
-        toolType,
-        metadata,
-        sopInstanceUIDToImageIdMap
-      });
-    } else if (SCOORD3DGroup) {
-      return this.processSCOORD3DGroup({
-        SCOORD3DGroup,
-        toolType
-      });
-    } else {
+    const contentSequenceArr = toArray(NUMGroup.ContentSequence);
+    const SCOORDGroup = contentSequenceArr.find(group => group.ValueType === "SCOORD");
+    const SCOORD3DGroup = contentSequenceArr.find(group => group.ValueType === "SCOORD3D");
+    const result = SCOORD3DGroup && this.processSCOORD3DGroup({
+      SCOORD3DGroup,
+      toolType
+    }) || SCOORDGroup && this.processSCOORDGroup({
+      SCOORDGroup,
+      toolType,
+      metadata,
+      sopInstanceUIDToImageIdMap
+    });
+    if (!result) {
       throw new Error("No spatial coordinates group found.");
     }
+    return result;
   }
   static processSpatialCoordinatesGroup(_ref4) {
     let {
@@ -183,6 +224,8 @@ class MeasurementReport {
       metadata,
       findingGroup,
       findingSiteGroups,
+      commentGroup,
+      commentPositionGroup,
       toolType
     } = _ref4;
     const {
@@ -192,7 +235,9 @@ class MeasurementReport {
       ReferencedSOPInstanceUID,
       ReferencedFrameNumber,
       SCOORD3DGroup,
-      FrameOfReferenceUID
+      FrameOfReferenceUID,
+      referencedImageId,
+      textBoxPosition
     } = this.getSpatialCoordinatesState({
       NUMGroup,
       sopInstanceUIDToImageIdMap,
@@ -203,21 +248,35 @@ class MeasurementReport {
     const findingSites = findingSiteGroups.map(fsg => {
       return addAccessors(fsg.ConceptCodeSequence);
     });
-    const defaultState = {
-      ...state,
-      finding,
-      findingSites
-    };
-    if (defaultState.finding) {
-      defaultState.description = defaultState.finding.CodeMeaning;
+    if (commentPositionGroup) {
+      state.commentPositionGroup = commentPositionGroup;
+      const textBoxCoords = scoordToWorld({
+        is3DMeasurement: !referencedImageId,
+        referencedImageId
+      }, commentPositionGroup);
+      state.annotation.data.handles.textBox = {
+        hasMoved: true,
+        worldPosition: textBoxCoords[0]
+      };
     }
-    defaultState.annotation.metadata.label = MeasurementReport.getCornerstoneLabelFromDefaultState(defaultState);
+    state.finding = finding;
+    state.findingSites = findingSites;
+    state.commentGroup = commentGroup;
+    state.commentPositionGroup = commentPositionGroup;
+    if (finding) {
+      state.description = finding.CodeMeaning;
+    }
+    state.annotation.data.label = this.getCornerstoneLabelFromDefaultState(state);
     return {
-      defaultState,
+      defaultState: state,
+      state,
       NUMGroup,
+      scoord: SCOORD3DGroup || SCOORDGroup,
       SCOORDGroup,
       ReferencedSOPSequence,
       ReferencedSOPInstanceUID,
+      referencedImageId,
+      textBoxPosition,
       ReferencedFrameNumber,
       SCOORD3DGroup,
       FrameOfReferenceUID
@@ -229,16 +288,39 @@ class MeasurementReport {
     } = MeasurementGroup;
     const contentSequenceArr = toArray(ContentSequence);
     const findingGroup = contentSequenceArr.find(group => this.codeValueMatch(group, FINDING));
+    const commentGroup = contentSequenceArr.find(group => this.codeValueMatch(group, COMMENT));
+    const commentPositionGroup = contentSequenceArr.find(group => this.codeValueMatch(group, COMMENT_POSITION));
     const findingSiteGroups = contentSequenceArr.filter(group => this.codeValueMatch(group, FINDING_SITE, FINDING_SITE_OLD)) || [];
-    const NUMGroup = contentSequenceArr.find(group => group.ValueType === "NUM");
-    return this.processSpatialCoordinatesGroup({
+    const NUMGroup = contentSequenceArr.find(group => group.ValueType === "NUM") || {
+      ContentSequence: contentSequenceArr.filter(group => group.ValueType === "SCOORD" || group.ValueType === "SCOORD3D")
+    };
+    const spatialGroup = this.processSpatialCoordinatesGroup({
       NUMGroup,
       sopInstanceUIDToImageIdMap,
       metadata,
       findingGroup,
       findingSiteGroups,
+      commentGroup,
+      commentPositionGroup,
       toolType
     });
+    const {
+      referencedImageId
+    } = spatialGroup.state.annotation.metadata;
+    const is3DMeasurement = !!spatialGroup.SCOORD3DGroup;
+    const scoordArgs = {
+      referencedImageId,
+      is3DMeasurement
+    };
+    const scoord = spatialGroup.SCOORD3DGroup || spatialGroup.SCOORDGroup;
+    const worldCoords = scoordToWorld(scoordArgs, scoord);
+    return {
+      ...spatialGroup,
+      is3DMeasurement,
+      scoordArgs,
+      scoord,
+      worldCoords
+    };
   }
   static generateReferencedSOPSequence(_ref5) {
     let {
@@ -286,10 +368,13 @@ class MeasurementReport {
     const referenceToolData = toolData?.[toolTypes?.[0]]?.data?.[0];
     const volumeId = referenceToolData?.metadata?.volumeId;
     const volume = cache.getVolume(volumeId);
+    if (!volume) {
+      throw new Error(`No volume found for ${volumeId}`);
+    }
     const imageId = volume.imageIds[0];
     return imageId;
   }
-  static generateReport(toolState, metadataProvider, worldToImageCoords, options) {
+  static generateReport(toolState, metadataProvider, options) {
     let allMeasurementGroups = [];
     const sopInstanceUIDsToSeriesInstanceUIDMap = {};
     const derivationSourceDatasets = [];
@@ -298,6 +383,7 @@ class MeasurementReport {
     Object.keys(toolState).forEach(imageId => {
       const toolData = toolState[imageId];
       const toolTypes = Object.keys(toolData);
+      const is3DMeasurement = imageId === NO_IMAGE_ID;
       const ReferencedSOPSequence = this.generateReferencedSOPSequence({
         toolData,
         toolTypes,
@@ -306,12 +392,12 @@ class MeasurementReport {
         sopInstanceUIDsToSeriesInstanceUIDMap,
         derivationSourceDatasets
       });
-      if (imageId === NO_IMAGE_ID) {
+      if (is3DMeasurement) {
         is3DSR = true;
       }
       const measurementGroups = [];
       toolTypes.forEach(toolType => {
-        const group = this.getMeasurementGroup(toolType, toolData, ReferencedSOPSequence, worldToImageCoords);
+        const group = this.getMeasurementGroup(toolType, toolData, ReferencedSOPSequence, is3DMeasurement);
         if (group) {
           measurementGroups.push(group);
         }
@@ -331,10 +417,13 @@ class MeasurementReport {
     report.SpecificCharacterSet = "ISO_IR 192";
     if (is3DSR) {
       report.dataset.SOPClassUID = DicomMetaDictionary.sopClassUIDsByName.Comprehensive3DSR;
+      if (!report.dataset.SOPClassUID) {
+        throw new Error(`NO sop class defined for Comprehensive3DSR in ${JSON.stringify(DicomMetaDictionary.sopClassUIDsByName)}`);
+      }
     }
     return report;
   }
-  static generateToolState(dataset, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata, hooks) {
+  static generateToolState(dataset, sopInstanceUIDToImageIdMap, metadata, hooks) {
     if (dataset.ContentTemplateSequence.TemplateIdentifier !== "1500") {
       throw new Error("This package can currently only interpret DICOM SR TID 1500");
     }
@@ -354,9 +443,9 @@ class MeasurementReport {
         } = trackingIdentifierGroup;
         const trackingUniqueIdentifierGroup = measurementGroupContentSequence.find(contentItem => contentItem.ConceptNameCodeSequence.CodeMeaning === TRACKING_UNIQUE_IDENTIFIER);
         const trackingUniqueIdentifierValue = trackingUniqueIdentifierGroup?.UID;
-        const toolAdapter = hooks?.getToolClass?.(measurementGroup, dataset, this.measurementAdapterByToolType) || this.getAdapterForTrackingIdentifier(trackingIdentifierValue);
+        const toolAdapter = hooks?.getToolClass?.(measurementGroup, dataset, this.measurementAdapterByToolType) || this.getAdapterForTrackingIdentifier(trackingIdentifierValue) || this.getAdapterForCodeType(measurementGroup);
         if (toolAdapter) {
-          const measurement = toolAdapter.getMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata, trackingIdentifierValue);
+          const measurement = toolAdapter.getMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, metadata, trackingIdentifierValue);
           measurement.TrackingUniqueIdentifier = trackingUniqueIdentifierValue;
           console.log(`=== ${toolAdapter.toolType} ===`);
           console.log(measurement);
@@ -403,10 +492,40 @@ class MeasurementReport {
       }
     }
   }
+  static getAdapterForCodeType(measurementGroup) {
+    for (const adapter of this.measurementAdapterByTrackingIdentifier.values()) {
+      if (adapter.isValidMeasurement(measurementGroup)) {
+        return adapter;
+      }
+    }
+  }
+  static registerAdapterTypes(adapter) {
+    for (var _len2 = arguments.length, types = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+      types[_key2 - 1] = arguments[_key2];
+    }
+    for (const type of types) {
+      if (!this.measurementAdaptersByType.has(type)) {
+        this.measurementAdaptersByType.set(type, []);
+      }
+      const adapters = this.measurementAdaptersByType.get(type);
+      if (adapters.indexOf(adapter) === -1) {
+        adapters.push(adapter);
+      }
+    }
+  }
+  static getAdaptersForTypes(graphicCode, graphicType, pointCount) {
+    const adapters = [];
+    appendList(adapters, this.measurementAdaptersByType.get(`${graphicCode}-${graphicType}-${pointCount}`));
+    appendList(adapters, this.measurementAdaptersByType.get(`${graphicCode}-${graphicType}`));
+    appendList(adapters, this.measurementAdaptersByType.get(graphicCode));
+    appendList(adapters, this.measurementAdaptersByType.get(graphicType));
+    return adapters;
+  }
 }
 _MeasurementReport = MeasurementReport;
 _MeasurementReport.CORNERSTONE_3D_TAG = CORNERSTONE_3D_TAG;
 _MeasurementReport.measurementAdapterByToolType = new Map();
+_MeasurementReport.measurementAdaptersByType = new Map();
 _MeasurementReport.measurementAdapterByTrackingIdentifier = new Map();
 _MeasurementReport.codeValueMatch = (group, code, oldCode) => {
   const {
@@ -429,5 +548,11 @@ _MeasurementReport.generateDerivationSourceDataset = instance => {
     ...seriesTags
   };
 };
+function appendList(list, appendList) {
+  if (!appendList?.length) {
+    return;
+  }
+  list.push(...appendList);
+}
 
 export { MeasurementReport as default };

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

@@ -1,48 +1,25 @@
 import BaseAdapter3D from "./BaseAdapter3D";
 declare class PlanarFreehandROI extends BaseAdapter3D {
     static closedContourThreshold: number;
-    static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any): any;
-    static getMeasurementDataFromScoord({ defaultState, SCOORDGroup, imageToWorldCoords, NUMGroup, ReferencedFrameNumber }: {
-        defaultState: any;
-        SCOORDGroup: any;
-        imageToWorldCoords: any;
-        NUMGroup: any;
-        ReferencedFrameNumber: any;
-    }): any;
-    static getMeasurementDataFromScoord3D({ defaultState, SCOORD3DGroup }: {
-        defaultState: any;
-        SCOORD3DGroup: any;
-    }): any;
-    static getTID300RepresentationArguments(tool: any, worldToImageCoords: any): {
-        points: any;
-        area: any;
-        areaUnit: any;
-        perimeter: any;
-        modalityUnit: any;
-        mean: any;
-        max: any;
-        stdDev: any;
-        trackingIdentifierTextValue: string;
-        finding: any;
-        findingSites: any;
-        ReferencedFrameOfReferenceUID: any;
-        use3DSpatialCoordinates: boolean;
-    } | {
-        points: any;
-        area: any;
-        areaUnit: any;
-        perimeter: any;
-        modalityUnit: any;
-        mean: any;
-        max: any;
-        stdDev: any;
-        trackingIdentifierTextValue: string;
-        finding: any;
-        findingSites: any;
-        use3DSpatialCoordinates: boolean;
+    static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, metadata: any): {
+        description?: string;
+        sopInstanceUid?: string;
+        annotation: import("packages/tools/dist/esm/types").Annotation;
+        finding?: unknown;
+        findingSites?: unknown;
+        commentGroup?: any;
+        commentPositionGroup?: any;
     };
-    static getTID300RepresentationArgumentsSCOORD3D(tool: any): {
-        points: any;
+    static getTID300RepresentationArguments(tool: any, is3DMeasurement?: boolean): {
+        points: ({
+            x: any;
+            y: any;
+            z: any;
+        } | {
+            x: number;
+            y: number;
+            z?: undefined;
+        })[];
         area: any;
         areaUnit: any;
         perimeter: any;