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

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

@@ -0,0 +1,102 @@
+import { COMMENT_CODE, TEXT_ANNOTATION_POSITION } from './constants/index.js';
+import dcmjs from 'dcmjs';
+import 'buffer';
+import { toScoord } from '../helpers/toScoordType.js';
+import '@cornerstonejs/core';
+
+const {
+  sr: {
+    valueTypes,
+    coding
+  }
+} = dcmjs;
+const CORNERSTONEFREETEXT = "CORNERSTONEFREETEXT";
+class LabelData {
+  constructor(tid300Item, annotation) {
+    this.tid300Item = tid300Item;
+    this.annotation = annotation;
+    this.ReferencedSOPSequence = tid300Item.ReferencedSOPSequence;
+  }
+  contentItem() {
+    const contentEntries = this.tid300Item.contentItem();
+    const {
+      label,
+      handles
+    } = this.annotation.data;
+    if (label) {
+      contentEntries.push(this.createQualitativeLabel(label));
+      this.filterCornerstoneFreeText(contentEntries);
+    }
+    if (handles?.textBox?.hasMoved) {
+      contentEntries.push(this.createQualitativeLabelPosition(this.annotation));
+    }
+    return contentEntries;
+  }
+  filterCornerstoneFreeText(contentEntries) {
+    for (let i = 0; i < contentEntries.length; i++) {
+      const group = contentEntries[i];
+      if (!group.ConceptCodeSequence) {
+        continue;
+      }
+      const csLabel = group.ConceptCodeSequence.find(item => item.CodeValue === CORNERSTONEFREETEXT);
+      if (csLabel !== -1) {
+        group.ConceptCodeSequence.splice(csLabel, 1);
+        if (group.ConceptCodeSequence.length === 0) {
+          contentEntries.splice(i, 1);
+        }
+        return;
+      }
+    }
+  }
+  createQualitativeLabel(label) {
+    const relationshipType = valueTypes.RelationshipTypes.CONTAINS;
+    return new valueTypes.TextContentItem({
+      name: new coding.CodedConcept(COMMENT_CODE),
+      relationshipType,
+      value: label
+    });
+  }
+  createQualitativeLabelPosition(annotation) {
+    const {
+      textBox
+    } = annotation.data.handles;
+    const {
+      referencedImageId,
+      FrameOfReferenceUID: frameOfReferenceUID
+    } = annotation.metadata;
+    const is3DMeasurement = !referencedImageId;
+    const {
+      worldPosition
+    } = textBox;
+    const {
+      x,
+      y,
+      z
+    } = toScoord({
+      is3DMeasurement,
+      referencedImageId
+    }, worldPosition);
+    const graphicType = valueTypes.GraphicTypes.POINT;
+    const relationshipType = valueTypes.RelationshipTypes.CONTAINS;
+    const name = new coding.CodedConcept(TEXT_ANNOTATION_POSITION);
+    if (is3DMeasurement) {
+      const graphicData = [x, y, z];
+      return new valueTypes.Scoord3DContentItem({
+        name,
+        relationshipType,
+        graphicType,
+        frameOfReferenceUID,
+        graphicData
+      });
+    }
+    const graphicData = [x, y];
+    return new valueTypes.ScoordContentItem({
+      name,
+      relationshipType,
+      graphicType,
+      graphicData
+    });
+  }
+}
+
+export { LabelData as default };

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

@@ -1,65 +1,37 @@
 import BaseAdapter3D from "./BaseAdapter3D";
 export default class Length extends BaseAdapter3D {
-    static getMeasurementDataFromScoord({ defaultState, NUMGroup, SCOORDGroup, ReferencedFrameNumber, imageToWorldCoords }: {
-        defaultState: any;
-        NUMGroup: any;
-        SCOORDGroup: any;
-        ReferencedFrameNumber: any;
-        imageToWorldCoords: any;
-    }): any;
-    static getMeasurementDataFromScoord3d({ defaultState, SCOORD3DGroup }: {
-        defaultState: any;
-        SCOORD3DGroup: any;
-    }): any;
-    static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any): any;
-    static getTID300RepresentationArguments(tool: any, worldToImageCoords: any): {
-        point1: {
-            x: any;
-            y: any;
-            z: any;
-        };
-        point2: {
-            x: any;
-            y: any;
-            z: any;
-        };
-        distance: any;
-        trackingIdentifierTextValue: string;
-        finding: any;
-        findingSites: any;
-        ReferencedFrameOfReferenceUID: any;
-        use3DSpatialCoordinates: boolean;
-    } | {
-        point1: {
-            x: any;
-            y: any;
-        };
-        point2: {
-            x: any;
-            y: any;
-        };
-        distance: 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): {
+    static getTID300RepresentationArguments(tool: any, is3DMeasurement?: boolean): {
         point1: {
             x: any;
             y: any;
             z: any;
+        } | {
+            x: number;
+            y: number;
+            z?: undefined;
         };
         point2: {
             x: any;
             y: any;
             z: any;
+        } | {
+            x: number;
+            y: number;
+            z?: undefined;
         };
         distance: any;
         trackingIdentifierTextValue: string;
         finding: any;
         findingSites: any;
-        ReferencedFrameOfReferenceUID: any;
         use3DSpatialCoordinates: boolean;
     };
 }

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

@@ -1,6 +1,9 @@
 import { utilities } from 'dcmjs';
 import MeasurementReport from './MeasurementReport.js';
 import BaseAdapter3D from './BaseAdapter3D.js';
+import 'buffer';
+import { toScoord } from '../helpers/toScoordType.js';
+import '@cornerstonejs/core';
 
 var _Length;
 const {
@@ -8,89 +11,33 @@ const {
 } = utilities.TID300;
 const LENGTH = "Length";
 class Length extends BaseAdapter3D {
-  static getMeasurementDataFromScoord(_ref) {
-    let {
-      defaultState,
-      NUMGroup,
-      SCOORDGroup,
-      ReferencedFrameNumber,
-      imageToWorldCoords
-    } = _ref;
-    const referencedImageId = defaultState.annotation.metadata.referencedImageId;
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata) {
     const {
-      GraphicData
-    } = SCOORDGroup;
-    const worldCoords = [];
-    for (let i = 0; i < GraphicData.length; i += 2) {
-      const point = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
-      worldCoords.push(point);
-    }
-    const state = defaultState;
+      state,
+      NUMGroup,
+      worldCoords,
+      referencedImageId,
+      ReferencedFrameNumber
+    } = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
+    const cachedStats = referencedImageId ? {
+      [`imageId:${referencedImageId}`]: {
+        length: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : 0
+      }
+    } : {};
     state.annotation.data = {
+      ...state.annotation.data,
       handles: {
+        ...state.annotation.data.handles,
         points: [worldCoords[0], worldCoords[1]],
-        activeHandleIndex: 0,
-        textBox: {
-          hasMoved: false
-        }
-      },
-      cachedStats: {
-        [`imageId:${referencedImageId}`]: {
-          length: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : 0
-        }
+        activeHandleIndex: 0
       },
+      cachedStats,
       frameNumber: ReferencedFrameNumber
     };
     return state;
   }
-  static getMeasurementDataFromScoord3d(_ref2) {
-    let {
-      defaultState,
-      SCOORD3DGroup
-    } = _ref2;
-    const {
-      GraphicData
-    } = SCOORD3DGroup;
-    const worldCoords = GraphicData;
-    const state = defaultState;
-    state.annotation.data = {
-      handles: {
-        points: [worldCoords.slice(0, 3), worldCoords.slice(3, 6)],
-        activeHandleIndex: 0,
-        textBox: {
-          hasMoved: false
-        }
-      },
-      cachedStats: {}
-    };
-    return state;
-  }
-  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
-    const {
-      defaultState,
-      NUMGroup,
-      SCOORDGroup,
-      SCOORD3DGroup,
-      ReferencedFrameNumber
-    } = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
-    if (SCOORDGroup) {
-      return this.getMeasurementDataFromScoord({
-        defaultState,
-        NUMGroup,
-        SCOORDGroup,
-        ReferencedFrameNumber,
-        imageToWorldCoords
-      });
-    } else if (SCOORD3DGroup) {
-      return this.getMeasurementDataFromScoord3d({
-        defaultState,
-        SCOORD3DGroup
-      });
-    } else {
-      throw new Error("Can't get measurement data with missing SCOORD and SCOORD3D groups.");
-    }
-  }
-  static getTID300RepresentationArguments(tool, worldToImageCoords) {
+  static getTID300RepresentationArguments(tool) {
+    let is3DMeasurement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     const {
       data,
       finding,
@@ -104,19 +51,12 @@ class Length extends BaseAdapter3D {
     const {
       referencedImageId
     } = metadata;
-    if (!referencedImageId) {
-      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
-    }
-    const start = worldToImageCoords(referencedImageId, handles.points[0]);
-    const end = worldToImageCoords(referencedImageId, handles.points[1]);
-    const point1 = {
-      x: start[0],
-      y: start[1]
-    };
-    const point2 = {
-      x: end[0],
-      y: end[1]
+    const scoordProps = {
+      is3DMeasurement,
+      referencedImageId
     };
+    const point1 = toScoord(scoordProps, handles.points[0]);
+    const point2 = toScoord(scoordProps, handles.points[1]);
     const {
       length: distance
     } = cachedStats[`imageId:${referencedImageId}`] || {};
@@ -127,45 +67,7 @@ class Length extends BaseAdapter3D {
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding,
       findingSites: findingSites || [],
-      use3DSpatialCoordinates: false
-    };
-  }
-  static getTID300RepresentationArgumentsSCOORD3D(tool) {
-    const {
-      data,
-      finding,
-      findingSites,
-      metadata
-    } = tool;
-    const {
-      cachedStats = {},
-      handles
-    } = data;
-    const start = handles.points[0];
-    const end = handles.points[1];
-    const point1 = {
-      x: start[0],
-      y: start[1],
-      z: start[2]
-    };
-    const point2 = {
-      x: end[0],
-      y: end[1],
-      z: end[2]
-    };
-    const cachedStatsKeys = Object.keys(cachedStats)[0];
-    const {
-      length: distance
-    } = cachedStatsKeys ? cachedStats[cachedStatsKeys] : {};
-    return {
-      point1,
-      point2,
-      distance,
-      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
-      finding,
-      findingSites: findingSites || [],
-      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
-      use3DSpatialCoordinates: true
+      use3DSpatialCoordinates: is3DMeasurement
     };
   }
 }

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

@@ -1,26 +1,41 @@
+import { type Types as CSTypes } from "@cornerstonejs/core";
+import type { Types } from "@cornerstonejs/tools";
+import LabelData from "./LabelData";
+type Annotation = Types.Annotation;
 type SpatialCoordinatesState = {
     description?: string;
     sopInstanceUid?: string;
-    annotation: {
-        annotationUID: string;
-        metadata: {
-            toolName: string;
-            referencedImageId?: string;
-            FrameOfReferenceUID: string;
-            label: string;
-        };
-    };
+    annotation: Annotation;
     finding?: unknown;
     findingSites?: unknown;
+    commentGroup?: any;
+    commentPositionGroup?: any;
+};
+type ScoordType = {
+    GraphicData: number[];
 };
 type SetupMeasurementData = {
     defaultState: SpatialCoordinatesState;
-    NUMGroup: Record<string, unknown>;
-    SCOORDGroup?: Record<string, unknown>;
+    state?: SpatialCoordinatesState;
+    is3DMeasurement?: boolean;
+    scoord?: ScoordType;
+    worldCoords?: CSTypes.Point3[];
+    scoordArgs?: {
+        referencedImageId: string;
+        is3DMeasurement: boolean;
+    };
+    NUMGroup: {
+        MeasuredValueSequence: {
+            NumericValue: number;
+        };
+    };
+    SCOORDGroup?: ScoordType;
     ReferencedSOPSequence?: Record<string, unknown>;
     ReferencedSOPInstanceUID?: string;
+    referencedImageId?: string;
+    textBoxPosition?: ScoordType;
     ReferencedFrameNumber?: string;
-    SCOORD3DGroup?: Record<string, unknown>;
+    SCOORD3DGroup?: ScoordType;
     FrameOfReferenceUID?: string;
 };
 type SpatialCoordinatesData = Omit<SetupMeasurementData, "defaultState" | "NUMGroup"> & {
@@ -37,17 +52,19 @@ export interface MeasurementAdapter {
     trackingIdentifiers: Set<string>;
     parentType: string;
     init(toolType: string, representation: any, options?: AdapterOptions): any;
-    getMeasurementData(measurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any, trackingIdentifier: string): any;
+    getMeasurementData(measurementGroup: any, sopInstanceUIDToImageIdMap: any, metadata: any, trackingIdentifier: string): any;
     isValidCornerstoneTrackingIdentifier(trackingIdentifier: string): boolean;
-    getTID300RepresentationArguments(tool: any, worldToImageCoords: any): Record<string, unknown>;
+    isValidMeasurement(measurementGroup: any): boolean;
+    getTID300RepresentationArguments(tool: any, is3DMeasurement: any): Record<string, unknown>;
 }
 export default class MeasurementReport {
     static CORNERSTONE_3D_TAG: string;
     static measurementAdapterByToolType: Map<string, MeasurementAdapter>;
+    static measurementAdaptersByType: Map<string, MeasurementAdapter[]>;
     static measurementAdapterByTrackingIdentifier: Map<string, MeasurementAdapter>;
-    static getTID300ContentItem(tool: any, ReferencedSOPSequence: any, toolClass: any, worldToImageCoords: any): any;
+    static getTID300ContentItem(tool: any, ReferencedSOPSequence: any, toolClass: any, is3DMeasurement: any): LabelData;
     static codeValueMatch: (group: any, code: any, oldCode?: any) => boolean;
-    static getMeasurementGroup(toolType: any, toolData: any, ReferencedSOPSequence: any, worldToImageCoords: any): any;
+    static getMeasurementGroup(toolType: any, toolData: any, ReferencedSOPSequence: any, is3DMeasurement: any): any;
     static getCornerstoneLabelFromDefaultState(defaultState: any): any;
     static generateDatasetMeta(): {
         FileMetaInformationVersion: {
@@ -76,7 +93,35 @@ export default class MeasurementReport {
         toolType: any;
         sopInstanceUIDToImageIdMap: any;
         metadata: any;
-    }): SpatialCoordinatesData;
+    }): {
+        SCOORDGroup: any;
+        ReferencedSOPSequence: any;
+        ReferencedSOPInstanceUID: any;
+        ReferencedFrameNumber: any;
+        referencedImageId: any;
+        state: {
+            description: any;
+            sopInstanceUid: any;
+            annotation: {
+                data: {
+                    annotationUID: any;
+                    cachedStats: {};
+                    handles: {
+                        activeHandleIndex: number;
+                        textBox: {
+                            hasMoved: boolean;
+                        };
+                    };
+                };
+                annotationUID: any;
+                metadata: {
+                    toolName: any;
+                    referencedImageId: any;
+                    FrameOfReferenceUID: any;
+                };
+            };
+        };
+    };
     static processSCOORD3DGroup({ SCOORD3DGroup, toolType }: {
         SCOORD3DGroup: any;
         toolType: any;
@@ -87,35 +132,27 @@ export default class MeasurementReport {
         metadata: any;
         toolType: any;
     }): SpatialCoordinatesData;
-    static processSpatialCoordinatesGroup({ NUMGroup, sopInstanceUIDToImageIdMap, metadata, findingGroup, findingSiteGroups, toolType }: {
+    static processSpatialCoordinatesGroup({ NUMGroup, sopInstanceUIDToImageIdMap, metadata, findingGroup, findingSiteGroups, commentGroup, commentPositionGroup, toolType }: {
         NUMGroup: any;
         sopInstanceUIDToImageIdMap: any;
         metadata: any;
         findingGroup: any;
         findingSiteGroups: any;
+        commentGroup: any;
+        commentPositionGroup: any;
         toolType: any;
     }): {
-        defaultState: {
-            finding: any;
-            findingSites: any;
-            description?: string;
-            sopInstanceUid?: string;
-            annotation: {
-                annotationUID: string;
-                metadata: {
-                    toolName: string;
-                    referencedImageId?: string;
-                    FrameOfReferenceUID: string;
-                    label: string;
-                };
-            };
-        };
+        defaultState: SpatialCoordinatesState;
+        state: SpatialCoordinatesState;
         NUMGroup: any;
-        SCOORDGroup: Record<string, unknown>;
+        scoord: ScoordType;
+        SCOORDGroup: ScoordType;
         ReferencedSOPSequence: Record<string, unknown>;
         ReferencedSOPInstanceUID: string;
+        referencedImageId: string;
+        textBoxPosition: ScoordType;
         ReferencedFrameNumber: string;
-        SCOORD3DGroup: Record<string, unknown>;
+        SCOORD3DGroup: ScoordType;
         FrameOfReferenceUID: string;
     };
     static getSetupMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, metadata: any, toolType: any): SetupMeasurementData;
@@ -135,10 +172,13 @@ export default class MeasurementReport {
         toolData: any;
         toolTypes: any;
     }): string;
-    static generateReport(toolState: any, metadataProvider: any, worldToImageCoords: any, options: any): any;
-    static generateToolState(dataset: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any, hooks: any): {};
+    static generateReport(toolState: any, metadataProvider: any, options: any): any;
+    static generateToolState(dataset: any, sopInstanceUIDToImageIdMap: any, metadata: any, hooks: any): {};
     static registerTool(toolAdapter: MeasurementAdapter, replace?: boolean | ((original: any) => void)): void;
     static registerTrackingIdentifier(toolClass: any, ...trackingIdentifiers: string[]): void;
     static getAdapterForTrackingIdentifier(trackingIdentifier: string): MeasurementAdapter;
+    static getAdapterForCodeType(measurementGroup: any): MeasurementAdapter;
+    static registerAdapterTypes(adapter: any, ...types: any[]): void;
+    static getAdaptersForTypes(graphicCode: string, graphicType: string, pointCount: number): any[];
 }
 export {};