@cornerstonejs/adapters 3.14.3 → 3.15.0

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

@@ -14,8 +14,36 @@ class EllipticalROI extends BaseAdapter3D {
       defaultState,
       NUMGroup,
       SCOORDGroup,
+      SCOORD3DGroup,
       ReferencedFrameNumber
     } = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, EllipticalROI.toolType);
+    if (SCOORDGroup) {
+      return this.getMeasurementDataFromScoord({
+        defaultState,
+        SCOORDGroup,
+        imageToWorldCoords,
+        metadata,
+        NUMGroup,
+        ReferencedFrameNumber
+      });
+    } else if (SCOORD3DGroup) {
+      return this.getMeasurementDataFromScoord3D({
+        defaultState,
+        SCOORD3DGroup
+      });
+    } else {
+      throw new Error("Can't get measurement data with missing SCOORD and SCOORD3D groups.");
+    }
+  }
+  static getMeasurementDataFromScoord(_ref) {
+    let {
+      defaultState,
+      SCOORDGroup,
+      imageToWorldCoords,
+      metadata,
+      NUMGroup,
+      ReferencedFrameNumber
+    } = _ref;
     const referencedImageId = defaultState.annotation.metadata.referencedImageId;
     const {
       GraphicData
@@ -73,6 +101,42 @@ class EllipticalROI extends BaseAdapter3D {
     };
     return state;
   }
+  static getMeasurementDataFromScoord3D(_ref2) {
+    let {
+      defaultState,
+      SCOORD3DGroup
+    } = _ref2;
+    const {
+      GraphicData
+    } = SCOORD3DGroup;
+    const pointsWorld = [];
+    for (let i = 0; i < GraphicData.length; i += 3) {
+      const worldPos = [GraphicData[i], GraphicData[i + 1], GraphicData[i + 2]];
+      pointsWorld.push(worldPos);
+    }
+    const majorAxisStart = vec3.fromValues(...pointsWorld[0]);
+    const majorAxisEnd = vec3.fromValues(...pointsWorld[1]);
+    const minorAxisStart = vec3.fromValues(...pointsWorld[2]);
+    const minorAxisEnd = vec3.fromValues(...pointsWorld[3]);
+    const majorAxisVec = vec3.create();
+    vec3.sub(majorAxisVec, majorAxisEnd, majorAxisStart);
+    vec3.normalize(majorAxisVec, majorAxisVec);
+    const minorAxisVec = vec3.create();
+    vec3.sub(minorAxisVec, minorAxisEnd, minorAxisStart);
+    vec3.normalize(minorAxisVec, minorAxisVec);
+    const state = defaultState;
+    state.annotation.data = {
+      handles: {
+        points: [majorAxisStart, majorAxisEnd, minorAxisStart, minorAxisEnd],
+        activeHandleIndex: 0,
+        textBox: {
+          hasMoved: false
+        }
+      },
+      cachedStats: {}
+    };
+    return state;
+  }
   static getTID300RepresentationArguments(tool, worldToImageCoords) {
     const {
       data,
@@ -89,7 +153,7 @@ class EllipticalROI extends BaseAdapter3D {
       referencedImageId
     } = metadata;
     if (!referencedImageId) {
-      throw new Error("EllipticalROI.getTID300RepresentationArguments: referencedImageId is not defined");
+      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
     }
     let top, bottom, left, right;
     if (rotation == 90 || rotation == 270) {
@@ -149,7 +213,92 @@ class EllipticalROI extends BaseAdapter3D {
       points,
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding,
-      findingSites: findingSites || []
+      findingSites: findingSites || [],
+      use3DSpatialCoordinates: false
+    };
+  }
+  static getTID300RepresentationArgumentsSCOORD3D(tool) {
+    const {
+      data,
+      finding,
+      findingSites,
+      metadata
+    } = tool;
+    const {
+      cachedStats,
+      handles
+    } = data;
+    const rotation = data.initialRotation || 0;
+    let top, bottom, left, right;
+    if (rotation == 90 || rotation == 270) {
+      bottom = handles.points[2];
+      top = handles.points[3];
+      left = handles.points[0];
+      right = handles.points[1];
+    } else {
+      top = handles.points[0];
+      bottom = handles.points[1];
+      left = handles.points[2];
+      right = handles.points[3];
+    }
+    const topBottomLength = Math.sqrt((top[0] - bottom[0]) ** 2 + (top[1] - bottom[1]) ** 2 + (top[2] - bottom[2]) ** 2);
+    const leftRightLength = Math.sqrt((left[0] - right[0]) ** 2 + (left[1] - right[1]) ** 2 + (left[2] - right[2]) ** 2);
+    const points = [];
+    if (topBottomLength > leftRightLength) {
+      points.push({
+        x: top[0],
+        y: top[1],
+        z: top[2]
+      });
+      points.push({
+        x: bottom[0],
+        y: bottom[1],
+        z: bottom[2]
+      });
+      points.push({
+        x: left[0],
+        y: left[1],
+        z: left[2]
+      });
+      points.push({
+        x: right[0],
+        y: right[1],
+        z: right[2]
+      });
+    } else {
+      points.push({
+        x: left[0],
+        y: left[1],
+        z: left[2]
+      });
+      points.push({
+        x: right[0],
+        y: right[1],
+        z: right[2]
+      });
+      points.push({
+        x: top[0],
+        y: top[1],
+        z: top[2]
+      });
+      points.push({
+        x: bottom[0],
+        y: bottom[1],
+        z: bottom[2]
+      });
+    }
+    const cachedStatsKeys = Object.keys(cachedStats)[0];
+    const {
+      area
+    } = cachedStatsKeys ? cachedStats[cachedStatsKeys] : {};
+    return {
+      area,
+      points,
+      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
+      finding,
+      findingSites: findingSites || [],
+      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
+      use3DSpatialCoordinates: true
     };
   }
 }

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

@@ -3,22 +3,24 @@ export default class KeyImage extends Probe {
     static trackingSeriesIdentifier: string;
     static trackingPointIdentifier: string;
     static trackingSeriesPointIdentifier: string;
-    static getMeasurementData(measurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any, trackingIdentifier: any): {
-        description: any;
-        sopInstanceUid: any;
-        annotation: {
-            annotationUID: any;
-            metadata: {
-                toolName: any;
-                referencedImageId: any;
-                FrameOfReferenceUID: any;
-                label: string;
-            };
-            data: any;
-        };
+    static getMeasurementData(measurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any, trackingIdentifier: any): any;
+    static getTID300RepresentationArguments(tool: any, worldToImageCoords: any): {
+        points: {
+            x: any;
+            y: any;
+            z: any;
+        }[];
+        trackingIdentifierTextValue: string;
+        ReferencedFrameOfReferenceUID: any;
+        findingSites: any;
         finding: any;
-        findingSites: any[];
+        use3DSpatialCoordinates: boolean;
+    } | {
+        points: any;
+        trackingIdentifierTextValue: string;
+        findingSites: any;
+        finding: any;
+        use3DSpatialCoordinates: boolean;
     };
-    static getTID300RepresentationArguments(tool: any, worldToImageCoords: any): import("./BaseAdapter3D").TID300Arguments;
 }
 export { KeyImage };

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

@@ -1,33 +1,65 @@
 import BaseAdapter3D from "./BaseAdapter3D";
 export default class Length extends BaseAdapter3D {
-    static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any): {
-        description: any;
-        sopInstanceUid: any;
-        annotation: {
-            annotationUID: any;
-            metadata: {
-                toolName: any;
-                referencedImageId: any;
-                FrameOfReferenceUID: any;
-                label: string;
-            };
-            data: any;
+    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[];
+        findingSites: any;
+        use3DSpatialCoordinates: boolean;
     };
-    static getTID300RepresentationArguments(tool: any, worldToImageCoords: any): {
+    static getTID300RepresentationArgumentsSCOORD3D(tool: 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;
     };
 }

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

@@ -8,13 +8,14 @@ const {
 } = utilities.TID300;
 const LENGTH = "Length";
 class Length extends BaseAdapter3D {
-  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
-    const {
+  static getMeasurementDataFromScoord(_ref) {
+    let {
       defaultState,
       NUMGroup,
       SCOORDGroup,
-      ReferencedFrameNumber
-    } = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
+      ReferencedFrameNumber,
+      imageToWorldCoords
+    } = _ref;
     const referencedImageId = defaultState.annotation.metadata.referencedImageId;
     const {
       GraphicData
@@ -42,6 +43,53 @@ class Length extends BaseAdapter3D {
     };
     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) {
     const {
       data,
@@ -57,7 +105,7 @@ class Length extends BaseAdapter3D {
       referencedImageId
     } = metadata;
     if (!referencedImageId) {
-      throw new Error("Length.getTID300RepresentationArguments: referencedImageId is not defined");
+      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
     }
     const start = worldToImageCoords(referencedImageId, handles.points[0]);
     const end = worldToImageCoords(referencedImageId, handles.points[1]);
@@ -78,7 +126,46 @@ class Length extends BaseAdapter3D {
       distance,
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding,
-      findingSites: findingSites || []
+      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
     };
   }
 }

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

@@ -1,3 +1,31 @@
+type SpatialCoordinatesState = {
+    description?: string;
+    sopInstanceUid?: string;
+    annotation: {
+        annotationUID: string;
+        metadata: {
+            toolName: string;
+            referencedImageId?: string;
+            FrameOfReferenceUID: string;
+            label: string;
+        };
+    };
+    finding?: unknown;
+    findingSites?: unknown;
+};
+type SetupMeasurementData = {
+    defaultState: SpatialCoordinatesState;
+    NUMGroup: Record<string, unknown>;
+    SCOORDGroup?: Record<string, unknown>;
+    ReferencedSOPSequence?: Record<string, unknown>;
+    ReferencedSOPInstanceUID?: string;
+    ReferencedFrameNumber?: string;
+    SCOORD3DGroup?: Record<string, unknown>;
+    FrameOfReferenceUID?: string;
+};
+type SpatialCoordinatesData = Omit<SetupMeasurementData, "defaultState" | "NUMGroup"> & {
+    state: SpatialCoordinatesState;
+};
 export type AdapterOptions = {
     parentType?: string;
     replace?: boolean | ((original: MeasurementAdapter) => void);
@@ -43,32 +71,74 @@ export default class MeasurementReport {
         _meta: any;
         _vrMap: any;
     };
-    static getSetupMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, metadata: any, toolType: any): {
+    static processSCOORDGroup({ SCOORDGroup, toolType, sopInstanceUIDToImageIdMap, metadata }: {
+        SCOORDGroup: any;
+        toolType: any;
+        sopInstanceUIDToImageIdMap: any;
+        metadata: any;
+    }): SpatialCoordinatesData;
+    static processSCOORD3DGroup({ SCOORD3DGroup, toolType }: {
+        SCOORD3DGroup: any;
+        toolType: any;
+    }): SpatialCoordinatesData;
+    static getSpatialCoordinatesState({ NUMGroup, sopInstanceUIDToImageIdMap, metadata, toolType }: {
+        NUMGroup: any;
+        sopInstanceUIDToImageIdMap: any;
+        metadata: any;
+        toolType: any;
+    }): SpatialCoordinatesData;
+    static processSpatialCoordinatesGroup({ NUMGroup, sopInstanceUIDToImageIdMap, metadata, findingGroup, findingSiteGroups, toolType }: {
+        NUMGroup: any;
+        sopInstanceUIDToImageIdMap: any;
+        metadata: any;
+        findingGroup: any;
+        findingSiteGroups: any;
+        toolType: any;
+    }): {
         defaultState: {
-            description: any;
-            sopInstanceUid: any;
+            finding: any;
+            findingSites: any;
+            description?: string;
+            sopInstanceUid?: string;
             annotation: {
-                annotationUID: any;
+                annotationUID: string;
                 metadata: {
-                    toolName: any;
-                    referencedImageId: any;
-                    FrameOfReferenceUID: any;
+                    toolName: string;
+                    referencedImageId?: string;
+                    FrameOfReferenceUID: string;
                     label: string;
                 };
-                data: any;
             };
-            finding: any;
-            findingSites: any[];
         };
         NUMGroup: any;
-        SCOORDGroup: any;
-        ReferencedSOPSequence: any;
+        SCOORDGroup: Record<string, unknown>;
+        ReferencedSOPSequence: Record<string, unknown>;
+        ReferencedSOPInstanceUID: string;
+        ReferencedFrameNumber: string;
+        SCOORD3DGroup: Record<string, unknown>;
+        FrameOfReferenceUID: string;
+    };
+    static getSetupMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, metadata: any, toolType: any): SetupMeasurementData;
+    static generateReferencedSOPSequence({ toolData, toolTypes, metadataProvider, imageId, sopInstanceUIDsToSeriesInstanceUIDMap, derivationSourceDatasets }: {
+        toolData: any;
+        toolTypes: any;
+        metadataProvider: any;
+        imageId: any;
+        sopInstanceUIDsToSeriesInstanceUIDMap: any;
+        derivationSourceDatasets: any;
+    }): {
+        ReferencedSOPClassUID: any;
         ReferencedSOPInstanceUID: any;
         ReferencedFrameNumber: any;
     };
+    static getImageIdFromVolume({ toolData, toolTypes }: {
+        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 registerTool(toolAdapter: MeasurementAdapter, replace?: boolean | ((original: any) => void)): void;
     static registerTrackingIdentifier(toolClass: any, ...trackingIdentifiers: string[]): void;
     static getAdapterForTrackingIdentifier(trackingIdentifier: string): MeasurementAdapter;
 }
+export {};