@cornerstonejs/adapters 3.30.3 → 3.31.1

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

@@ -1,5 +1,9 @@
 import CORNERSTONE_3D_TAG from './cornerstone3DTag.js';
 import MeasurementReport from './MeasurementReport.js';
+import 'dcmjs';
+import 'buffer';
+import { toScoords } from '../helpers/toScoordType.js';
+import '@cornerstonejs/core';
 
 class BaseAdapter3D {
   static init(toolType, representation, options) {
@@ -52,9 +56,9 @@ class BaseAdapter3D {
     };
     return state;
   }
-  static getTID300RepresentationArguments(tool, worldToImageCoords) {
+  static getTID300RepresentationArguments(tool) {
+    let is3DMeasurement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     const {
-      data,
       metadata
     } = tool;
     const {
@@ -64,52 +68,19 @@ class BaseAdapter3D {
     const {
       referencedImageId
     } = metadata;
-    if (!referencedImageId) {
-      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
-    }
-    const {
-      handles: {
-        points = []
-      }
-    } = data;
-    const pointsImage = points.map(point => {
-      const pointImage = worldToImageCoords(referencedImageId, point);
-      return {
-        x: pointImage[0],
-        y: pointImage[1]
-      };
-    });
+    const scoordProps = {
+      is3DMeasurement,
+      referencedImageId
+    };
+    const pointsImage = toScoords(scoordProps, tool.data.handles.points);
     const tidArguments = {
       points: pointsImage,
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       findingSites: findingSites || [],
-      finding
-    };
-    return tidArguments;
-  }
-  static getTID300RepresentationArgumentsSCOORD3D(tool) {
-    const {
-      data,
       finding,
-      findingSites
-    } = tool;
-    const {
-      handles: {
-        points = []
-      }
-    } = data;
-    const point = points[0];
-    const pointXYZ = {
-      x: point[0],
-      y: point[1],
-      z: point[2]
-    };
-    return {
-      points: [pointXYZ],
-      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
-      findingSites: findingSites || [],
-      finding
+      ReferencedFrameOfReferenceUID: is3DMeasurement ? metadata.FrameOfReferenceUID : null
     };
+    return tidArguments;
   }
 }
 

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

@@ -1,96 +1,31 @@
 import BaseAdapter3D from "./BaseAdapter3D";
 declare class Bidirectional extends BaseAdapter3D {
-    static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any): any;
-    static getMeasurementDataFromScoord({ longAxisNUMGroup, shortAxisNUMGroup, longAxisSCOORDGroup, shortAxisSCOORDGroup, referencedImageId, imageToWorldCoords, ReferencedFrameNumber, defaultState }: {
-        longAxisNUMGroup: any;
-        shortAxisNUMGroup: any;
-        longAxisSCOORDGroup: any;
-        shortAxisSCOORDGroup: any;
-        referencedImageId: any;
-        imageToWorldCoords: any;
-        ReferencedFrameNumber: any;
-        defaultState: any;
-    }): any;
-    static getMeasurementDataFromScoord3d({ longAxisNUMGroup, shortAxisNUMGroup, defaultState }: {
-        longAxisNUMGroup: any;
-        shortAxisNUMGroup: any;
-        defaultState: any;
-    }): any;
-    static getTID300RepresentationArguments(tool: any, worldToImageCoords: any): {
-        longAxis: {
-            point1: {
-                x: any;
-                y: any;
-                z: any;
-            };
-            point2: {
-                x: any;
-                y: any;
-                z: any;
-            };
-        };
-        shortAxis: {
-            point1: {
-                x: any;
-                y: any;
-                z: any;
-            };
-            point2: {
-                x: any;
-                y: any;
-                z: any;
-            };
-        };
-        longAxisLength: any;
-        shortAxisLength: any;
-        trackingIdentifierTextValue: string;
-        finding: any;
-        findingSites: any;
-        ReferencedFrameOfReferenceUID: any;
-        use3DSpatialCoordinates: boolean;
-    } | {
-        longAxis: {
-            point1: {
-                x: any;
-                y: any;
-            };
-            point2: {
-                x: any;
-                y: any;
-            };
-        };
-        shortAxis: {
-            point1: {
-                x: any;
-                y: any;
-            };
-            point2: {
-                x: any;
-                y: any;
-            };
-        };
-        longAxisLength: any;
-        shortAxisLength: 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;
     };
-    static getTID300RepresentationArgumentsSCOORD3D({ tool, shortAxisPoints, longAxisPoints }: {
-        tool: any;
-        shortAxisPoints: any;
-        longAxisPoints: any;
-    }): {
+    static getTID300RepresentationArguments(tool: any, is3DMeasurement?: boolean): {
         longAxis: {
             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;
             };
         };
         shortAxis: {
@@ -98,11 +33,19 @@ declare class Bidirectional extends BaseAdapter3D {
                 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;
             };
         };
         longAxisLength: any;

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

@@ -2,6 +2,8 @@ import { utilities } from 'dcmjs';
 import MeasurementReport from './MeasurementReport.js';
 import { toArray } from '../helpers/toArray.js';
 import 'buffer';
+import { toScoord } from '../helpers/toScoordType.js';
+import { scoordToWorld } from '../helpers/scoordToWorld.js';
 import BaseAdapter3D from './BaseAdapter3D.js';
 
 var _Bidirectional;
@@ -11,61 +13,25 @@ const {
 const LONG_AXIS = "Long Axis";
 const SHORT_AXIS = "Short Axis";
 class Bidirectional extends BaseAdapter3D {
-  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata) {
     const {
-      defaultState,
+      state,
+      scoordArgs,
+      referencedImageId,
       ReferencedFrameNumber
     } = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, Bidirectional.toolType);
-    const referencedImageId = defaultState.annotation.metadata.referencedImageId;
     const {
       ContentSequence
     } = MeasurementGroup;
     const longAxisNUMGroup = toArray(ContentSequence).find(group => group.ConceptNameCodeSequence.CodeMeaning === LONG_AXIS);
     const shortAxisNUMGroup = toArray(ContentSequence).find(group => group.ConceptNameCodeSequence.CodeMeaning === SHORT_AXIS);
-    const longAxisSCOORDGroup = toArray(longAxisNUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD");
-    const shortAxisSCOORDGroup = toArray(shortAxisNUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD");
-    if (longAxisSCOORDGroup && shortAxisSCOORDGroup) {
-      return this.getMeasurementDataFromScoord({
-        longAxisNUMGroup,
-        shortAxisNUMGroup,
-        longAxisSCOORDGroup,
-        shortAxisSCOORDGroup,
-        referencedImageId,
-        imageToWorldCoords,
-        ReferencedFrameNumber,
-        defaultState
-      });
-    } else {
-      return this.getMeasurementDataFromScoord3d({
-        longAxisNUMGroup,
-        shortAxisNUMGroup,
-        defaultState
-      });
-    }
-  }
-  static getMeasurementDataFromScoord(_ref) {
-    let {
-      longAxisNUMGroup,
-      shortAxisNUMGroup,
-      longAxisSCOORDGroup,
-      shortAxisSCOORDGroup,
-      referencedImageId,
-      imageToWorldCoords,
-      ReferencedFrameNumber,
-      defaultState
-    } = _ref;
+    const longAxisScoordGroup = toArray(longAxisNUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD3D" || group.ValueType === "SCOORD");
+    const shortAxisScoordGroup = toArray(shortAxisNUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD3D" || group.ValueType === "SCOORD");
     const worldCoords = [];
-    [longAxisSCOORDGroup, shortAxisSCOORDGroup].forEach(group => {
-      const {
-        GraphicData
-      } = group;
-      for (let i = 0; i < GraphicData.length; i += 2) {
-        const point = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
-        worldCoords.push(point);
-      }
-    });
-    const state = defaultState;
+    worldCoords.push(...scoordToWorld(scoordArgs, longAxisScoordGroup.GraphicData));
+    worldCoords.push(...scoordToWorld(scoordArgs, shortAxisScoordGroup.GraphicData));
     state.annotation.data = {
+      ...state.annotation.data,
       handles: {
         points: [worldCoords[0], worldCoords[1], worldCoords[2], worldCoords[3]],
         activeHandleIndex: 0,
@@ -73,48 +39,20 @@ class Bidirectional extends BaseAdapter3D {
           hasMoved: false
         }
       },
-      cachedStats: {
+      frameNumber: ReferencedFrameNumber
+    };
+    if (referencedImageId) {
+      state.annotation.data.cachedStats = {
         [`imageId:${referencedImageId}`]: {
           length: longAxisNUMGroup.MeasuredValueSequence.NumericValue,
           width: shortAxisNUMGroup.MeasuredValueSequence.NumericValue
         }
-      },
-      frameNumber: ReferencedFrameNumber
-    };
-    return state;
-  }
-  static getMeasurementDataFromScoord3d(_ref2) {
-    let {
-      longAxisNUMGroup,
-      shortAxisNUMGroup,
-      defaultState
-    } = _ref2;
-    const worldCoords = [];
-    const longAxisSCOORD3DGroup = toArray(longAxisNUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD3D");
-    const shortAxisSCOORD3DGroup = toArray(shortAxisNUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD3D");
-    [longAxisSCOORD3DGroup, shortAxisSCOORD3DGroup].forEach(group => {
-      const {
-        GraphicData
-      } = group;
-      for (let i = 0; i < GraphicData.length; i += 3) {
-        const point = [GraphicData[i], GraphicData[i + 1], GraphicData[i + 2]];
-        worldCoords.push(point);
-      }
-    });
-    const state = defaultState;
-    state.annotation.data = {
-      handles: {
-        points: [worldCoords[0], worldCoords[1], worldCoords[2], worldCoords[3]],
-        activeHandleIndex: 0,
-        textBox: {
-          hasMoved: false
-        }
-      },
-      cachedStats: {}
-    };
+      };
+    }
     return state;
   }
-  static getTID300RepresentationArguments(tool, worldToImageCoords) {
+  static getTID300RepresentationArguments(tool) {
+    let is3DMeasurement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     const {
       data,
       finding,
@@ -128,6 +66,10 @@ class Bidirectional extends BaseAdapter3D {
     const {
       referencedImageId
     } = metadata;
+    const scoordProps = {
+      is3DMeasurement,
+      referencedImageId
+    };
     const {
       points
     } = handles;
@@ -144,106 +86,30 @@ class Bidirectional extends BaseAdapter3D {
       shortAxisPoints = secondPointPairs;
       longAxisPoints = firstPointPairs;
     }
-    if (!referencedImageId) {
-      return this.getTID300RepresentationArgumentsSCOORD3D({
-        tool,
-        shortAxisPoints,
-        longAxisPoints
-      });
-    }
-    const longAxisStartImage = worldToImageCoords(referencedImageId, shortAxisPoints[0]);
-    const longAxisEndImage = worldToImageCoords(referencedImageId, shortAxisPoints[1]);
-    const shortAxisStartImage = worldToImageCoords(referencedImageId, longAxisPoints[0]);
-    const shortAxisEndImage = worldToImageCoords(referencedImageId, longAxisPoints[1]);
+    const longAxisStartImage = toScoord(scoordProps, shortAxisPoints[0]);
+    const longAxisEndImage = toScoord(scoordProps, shortAxisPoints[1]);
+    const shortAxisStartImage = toScoord(scoordProps, longAxisPoints[0]);
+    const shortAxisEndImage = toScoord(scoordProps, longAxisPoints[1]);
     const {
       length,
       width
     } = cachedStats[`imageId:${referencedImageId}`] || {};
     return {
       longAxis: {
-        point1: {
-          x: longAxisStartImage[0],
-          y: longAxisStartImage[1]
-        },
-        point2: {
-          x: longAxisEndImage[0],
-          y: longAxisEndImage[1]
-        }
+        point1: longAxisStartImage,
+        point2: longAxisEndImage
       },
       shortAxis: {
-        point1: {
-          x: shortAxisStartImage[0],
-          y: shortAxisStartImage[1]
-        },
-        point2: {
-          x: shortAxisEndImage[0],
-          y: shortAxisEndImage[1]
-        }
-      },
-      longAxisLength: length,
-      shortAxisLength: width,
-      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
-      finding: finding,
-      findingSites: findingSites || [],
-      use3DSpatialCoordinates: false
-    };
-  }
-  static getTID300RepresentationArgumentsSCOORD3D(_ref3) {
-    let {
-      tool,
-      shortAxisPoints,
-      longAxisPoints
-    } = _ref3;
-    const {
-      data,
-      finding,
-      findingSites,
-      metadata
-    } = tool;
-    const {
-      cachedStats = {}
-    } = data;
-    const longAxisStart = shortAxisPoints[0];
-    const longAxisEnd = shortAxisPoints[1];
-    const shortAxisStart = longAxisPoints[0];
-    const shortAxisEnd = longAxisPoints[1];
-    const cachedStatsKeys = Object.keys(cachedStats)[0];
-    const {
-      length = undefined,
-      width = undefined
-    } = cachedStatsKeys ? cachedStats[cachedStatsKeys] : {};
-    return {
-      longAxis: {
-        point1: {
-          x: longAxisStart[0],
-          y: longAxisStart[1],
-          z: longAxisStart[2]
-        },
-        point2: {
-          x: longAxisEnd[0],
-          y: longAxisEnd[1],
-          z: longAxisEnd[2]
-        }
-      },
-      shortAxis: {
-        point1: {
-          x: shortAxisStart[0],
-          y: shortAxisStart[1],
-          z: shortAxisStart[2]
-        },
-        point2: {
-          x: shortAxisEnd[0],
-          y: shortAxisEnd[1],
-          z: shortAxisEnd[2]
-        }
+        point1: shortAxisStartImage,
+        point2: shortAxisEndImage
       },
       longAxisLength: length,
       shortAxisLength: width,
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding: finding,
       findingSites: findingSites || [],
-      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
-      use3DSpatialCoordinates: true
+      ReferencedFrameOfReferenceUID: is3DMeasurement ? metadata.FrameOfReferenceUID : null,
+      use3DSpatialCoordinates: is3DMeasurement
     };
   }
 }

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

@@ -1,42 +1,25 @@
 import BaseAdapter3D from "./BaseAdapter3D";
 declare class CircleROI extends BaseAdapter3D {
-    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): {
-        area: any;
-        perimeter: number;
-        radius: any;
-        points: any[];
-        trackingIdentifierTextValue: string;
-        finding: any;
-        findingSites: any;
-        ReferencedFrameOfReferenceUID: any;
-        use3DSpatialCoordinates: boolean;
-    } | {
-        area: any;
-        perimeter: number;
-        radius: any;
-        points: 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;
     };
-    static getTID300RepresentationArgumentsSCOORD3D(tool: any): {
+    static getTID300RepresentationArguments(tool: any, is3DMeasurement?: boolean): {
         area: any;
         perimeter: number;
         radius: any;
-        points: any[];
+        points: ({
+            x: any;
+            y: any;
+            z: any;
+        } | {
+            x: number;
+            y: number;
+            z?: undefined;
+        })[];
         trackingIdentifierTextValue: string;
         finding: any;
         findingSites: any;