@cornerstonejs/adapters 4.0.0-beta.2 → 4.0.0-beta.4

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

@@ -1,99 +1,42 @@
 import { utilities } from 'dcmjs';
 import MeasurementReport from './MeasurementReport.js';
 import BaseAdapter3D from './BaseAdapter3D.js';
+import 'buffer';
+import { toScoords } from '../helpers/toScoordType.js';
+import '@cornerstonejs/core';
 
 var _CobbAngle;
 const {
   CobbAngle: TID300CobbAngle
 } = utilities.TID300;
 class CobbAngle extends BaseAdapter3D {
-  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata) {
     const {
-      defaultState,
+      state,
       NUMGroup,
-      SCOORDGroup,
-      SCOORD3DGroup,
+      referencedImageId,
+      worldCoords,
       ReferencedFrameNumber
     } = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, CobbAngle.toolType);
-    if (SCOORDGroup) {
-      return this.getMeasurementDataFromScoord({
-        defaultState,
-        SCOORDGroup,
-        imageToWorldCoords,
-        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,
-      NUMGroup,
-      ReferencedFrameNumber
-    } = _ref;
-    const referencedImageId = defaultState.annotation.metadata.referencedImageId;
-    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.annotation.data = {
+      ...state.annotation.data,
       handles: {
-        points: [worldCoords[0], worldCoords[1], worldCoords[2], worldCoords[3]],
-        activeHandleIndex: 0,
-        textBox: {
-          hasMoved: false
-        }
+        ...state.annotation.data.handles,
+        points: [worldCoords[0], worldCoords[1], worldCoords[2], worldCoords[3]]
       },
-      cachedStats: {
+      frameNumber: ReferencedFrameNumber
+    };
+    if (referencedImageId) {
+      state.annotation.data.cachedStats = {
         [`imageId:${referencedImageId}`]: {
           angle: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : null
         }
-      },
-      frameNumber: ReferencedFrameNumber
-    };
-    return state;
-  }
-  static getMeasurementDataFromScoord3D(_ref2) {
-    let {
-      defaultState,
-      SCOORD3DGroup
-    } = _ref2;
-    const {
-      GraphicData
-    } = SCOORD3DGroup;
-    const worldCoords = [];
-    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,
@@ -107,29 +50,12 @@ class CobbAngle extends BaseAdapter3D {
     const {
       referencedImageId
     } = metadata;
-    if (!referencedImageId) {
-      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
-    }
-    const start1 = worldToImageCoords(referencedImageId, handles.points[0]);
-    const end1 = worldToImageCoords(referencedImageId, handles.points[1]);
-    const start2 = worldToImageCoords(referencedImageId, handles.points[2]);
-    const end2 = worldToImageCoords(referencedImageId, handles.points[3]);
-    const point1 = {
-      x: start1[0],
-      y: start1[1]
-    };
-    const point2 = {
-      x: end1[0],
-      y: end1[1]
-    };
-    const point3 = {
-      x: start2[0],
-      y: start2[1]
-    };
-    const point4 = {
-      x: end2[0],
-      y: end2[1]
+    const scoordProps = {
+      is3DMeasurement,
+      referencedImageId
     };
+    const points = toScoords(scoordProps, handles.points);
+    const [point1, point2, point3, point4] = points;
     const {
       angle
     } = cachedStats[`imageId:${referencedImageId}`] || {};
@@ -142,59 +68,8 @@ class CobbAngle extends BaseAdapter3D {
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding,
       findingSites: findingSites || [],
-      use3DSpatialCoordinates: false
-    };
-  }
-  static getTID300RepresentationArgumentsSCOORD3D(tool) {
-    const {
-      data,
-      finding,
-      findingSites,
-      metadata
-    } = tool;
-    const {
-      cachedStats = {},
-      handles
-    } = data;
-    const start1 = handles.points[0];
-    const end1 = handles.points[1];
-    const start2 = handles.points[2];
-    const end2 = handles.points[3];
-    const point1 = {
-      x: start1[0],
-      y: start1[1],
-      z: start1[2]
-    };
-    const point2 = {
-      x: end1[0],
-      y: end1[1],
-      z: end1[2]
-    };
-    const point3 = {
-      x: start2[0],
-      y: start2[1],
-      z: start2[2]
-    };
-    const point4 = {
-      x: end2[0],
-      y: end2[1],
-      z: end2[2]
-    };
-    const cachedStatsKeys = Object.keys(cachedStats)[0];
-    const {
-      angle
-    } = cachedStatsKeys ? cachedStats[cachedStatsKeys] : {};
-    return {
-      point1,
-      point2,
-      point3,
-      point4,
-      rAngle: angle,
-      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
-      finding,
-      findingSites: findingSites || [],
-      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
-      use3DSpatialCoordinates: true
+      ReferencedFrameOfReferenceUID: is3DMeasurement ? metadata.FrameOfReferenceUID : null,
+      use3DSpatialCoordinates: is3DMeasurement
     };
   }
 }

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

@@ -1,37 +1,25 @@
 import BaseAdapter3D from "./BaseAdapter3D";
 declare class EllipticalROI extends BaseAdapter3D {
-    static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any): any;
-    static getMeasurementDataFromScoord({ defaultState, SCOORDGroup, imageToWorldCoords, metadata, NUMGroup, ReferencedFrameNumber }: {
-        defaultState: any;
-        SCOORDGroup: any;
-        imageToWorldCoords: any;
-        metadata: any;
-        NUMGroup: any;
-        ReferencedFrameNumber: any;
-    }): any;
-    static getMeasurementDataFromScoord3D({ defaultState, SCOORD3DGroup }: {
-        defaultState: any;
-        SCOORD3DGroup: any;
-    }): any;
-    static getTID300RepresentationArguments(tool: any, worldToImageCoords: any): {
-        area: any;
-        points: any[];
-        trackingIdentifierTextValue: string;
-        finding: any;
-        findingSites: any;
-        ReferencedFrameOfReferenceUID: any;
-        use3DSpatialCoordinates: boolean;
-    } | {
-        area: 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;
+        commentGroup?: any;
+        commentPositionGroup?: any;
     };
-    static getTID300RepresentationArgumentsSCOORD3D(tool: any): {
+    static getTID300RepresentationArguments(tool: any, is3DMeasurement?: boolean): {
         area: any;
-        points: any[];
+        points: ({
+            x: any;
+            y: any;
+            z: any;
+        } | {
+            x: number;
+            y: number;
+            z?: undefined;
+        })[];
         trackingIdentifierTextValue: string;
         finding: any;
         findingSites: any;

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

@@ -1,143 +1,40 @@
-import { vec3 } from 'gl-matrix';
 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 _EllipticalROI;
 const {
   Ellipse: TID300Ellipse
 } = utilities.TID300;
-const EPSILON = 1e-4;
 class EllipticalROI extends BaseAdapter3D {
-  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata) {
     const {
-      defaultState,
+      state,
       NUMGroup,
-      SCOORDGroup,
-      SCOORD3DGroup,
+      worldCoords,
+      referencedImageId,
       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
-    } = SCOORDGroup;
-    const pointsWorld = [];
-    for (let i = 0; i < GraphicData.length; i += 2) {
-      const worldPos = imageToWorldCoords(referencedImageId, [GraphicData[i], GraphicData[i + 1]]);
-      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 imagePlaneModule = metadata.get("imagePlaneModule", referencedImageId);
-    if (!imagePlaneModule) {
-      throw new Error("imageId does not have imagePlaneModule metadata");
-    }
-    const {
-      columnCosines
-    } = imagePlaneModule;
-    const columnCosinesVec = vec3.fromValues(columnCosines[0], columnCosines[1], columnCosines[2]);
-    const projectedMajorAxisOnColVec = vec3.dot(columnCosinesVec, majorAxisVec);
-    const projectedMinorAxisOnColVec = vec3.dot(columnCosinesVec, minorAxisVec);
-    const absoluteOfMajorDotProduct = Math.abs(projectedMajorAxisOnColVec);
-    const absoluteOfMinorDotProduct = Math.abs(projectedMinorAxisOnColVec);
-    let ellipsePoints = [];
-    if (Math.abs(absoluteOfMajorDotProduct - 1) < EPSILON) {
-      ellipsePoints = [pointsWorld[0], pointsWorld[1], pointsWorld[2], pointsWorld[3]];
-    } else if (Math.abs(absoluteOfMinorDotProduct - 1) < EPSILON) {
-      ellipsePoints = [pointsWorld[2], pointsWorld[3], pointsWorld[0], pointsWorld[1]];
-    } else {
-      console.warn("OBLIQUE ELLIPSE NOT YET SUPPORTED");
-    }
-    const state = defaultState;
     state.annotation.data = {
+      ...state.annotation.data,
       handles: {
-        points: [...ellipsePoints],
-        activeHandleIndex: 0,
-        textBox: {
-          hasMoved: false
-        }
-      },
-      cachedStats: {
-        [`imageId:${referencedImageId}`]: {
-          area: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : 0
-        }
+        ...state.annotation.data.handles,
+        points: worldCoords
       },
       frameNumber: ReferencedFrameNumber
     };
+    state.annotation.data.cachedStats = referencedImageId ? {
+      [`imageId:${referencedImageId}`]: {
+        area: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : 0
+      }
+    } : {};
     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) {
+  static getTID300RepresentationArguments(tool) {
+    let is3DMeasurement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     const {
       data,
       finding,
@@ -152,83 +49,10 @@ class EllipticalROI extends BaseAdapter3D {
     const {
       referencedImageId
     } = metadata;
-    if (!referencedImageId) {
-      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
-    }
-    let top, bottom, left, right;
-    if (rotation == 90 || rotation == 270) {
-      bottom = worldToImageCoords(referencedImageId, handles.points[2]);
-      top = worldToImageCoords(referencedImageId, handles.points[3]);
-      left = worldToImageCoords(referencedImageId, handles.points[0]);
-      right = worldToImageCoords(referencedImageId, handles.points[1]);
-    } else {
-      top = worldToImageCoords(referencedImageId, handles.points[0]);
-      bottom = worldToImageCoords(referencedImageId, handles.points[1]);
-      left = worldToImageCoords(referencedImageId, handles.points[2]);
-      right = worldToImageCoords(referencedImageId, handles.points[3]);
-    }
-    const topBottomLength = Math.abs(top[1] - bottom[1]);
-    const leftRightLength = Math.abs(left[0] - right[0]);
-    const points = [];
-    if (topBottomLength > leftRightLength) {
-      points.push({
-        x: top[0],
-        y: top[1]
-      });
-      points.push({
-        x: bottom[0],
-        y: bottom[1]
-      });
-      points.push({
-        x: left[0],
-        y: left[1]
-      });
-      points.push({
-        x: right[0],
-        y: right[1]
-      });
-    } else {
-      points.push({
-        x: left[0],
-        y: left[1]
-      });
-      points.push({
-        x: right[0],
-        y: right[1]
-      });
-      points.push({
-        x: top[0],
-        y: top[1]
-      });
-      points.push({
-        x: bottom[0],
-        y: bottom[1]
-      });
-    }
-    const {
-      area
-    } = cachedStats[`imageId:${referencedImageId}`] || {};
-    return {
-      area,
-      points,
-      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
-      finding,
-      findingSites: findingSites || [],
-      use3DSpatialCoordinates: false
+    const scoordProps = {
+      is3DMeasurement,
+      referencedImageId
     };
-  }
-  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];
@@ -245,60 +69,22 @@ class EllipticalROI extends BaseAdapter3D {
     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]
-      });
+      points.push(top, bottom, left, right);
     } 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]
-      });
+      points.push(left, right, top, bottom);
     }
-    const cachedStatsKeys = Object.keys(cachedStats)[0];
     const {
       area
-    } = cachedStatsKeys ? cachedStats[cachedStatsKeys] : {};
+    } = cachedStats[`imageId:${referencedImageId}`] || {};
+    const convertedPoints = points.map(point => toScoord(scoordProps, point));
     return {
       area,
-      points,
+      points: convertedPoints,
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding,
       findingSites: findingSites || [],
-      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
-      use3DSpatialCoordinates: true
+      ReferencedFrameOfReferenceUID: is3DMeasurement ? metadata.FrameOfReferenceUID : null,
+      use3DSpatialCoordinates: is3DMeasurement
     };
   }
 }

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

@@ -3,23 +3,29 @@ 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): any;
-    static getTID300RepresentationArguments(tool: any, worldToImageCoords: any): {
-        points: {
+    static getMeasurementData(measurementGroup: any, sopInstanceUIDToImageIdMap: any, metadata: any, trackingIdentifier: any): {
+        description?: string;
+        sopInstanceUid?: string;
+        annotation: import("packages/tools/dist/esm/types").Annotation;
+        finding?: unknown;
+        findingSites?: unknown;
+        commentGroup?: any;
+        commentPositionGroup?: any;
+    };
+    static getTID300RepresentationArguments(tool: any): {
+        points: ({
             x: any;
             y: any;
             z: any;
-        }[];
-        trackingIdentifierTextValue: string;
-        ReferencedFrameOfReferenceUID: any;
-        findingSites: any;
-        finding: any;
-        use3DSpatialCoordinates: boolean;
-    } | {
-        points: any;
+        } | {
+            x: number;
+            y: number;
+            z?: undefined;
+        })[];
         trackingIdentifierTextValue: string;
         findingSites: any;
         finding: any;
+        ReferencedFrameOfReferenceUID: any;
         use3DSpatialCoordinates: boolean;
     };
 }

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

@@ -6,16 +6,16 @@ const {
   Point: TID300Point
 } = utilities.TID300;
 class KeyImage extends Probe {
-  static getMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata, trackingIdentifier) {
-    const baseData = super.getMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata, trackingIdentifier);
+  static getMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, metadata, trackingIdentifier) {
+    const baseData = super.getMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, metadata, trackingIdentifier);
     const {
       data
     } = baseData.annotation;
     data.isPoint = trackingIdentifier.indexOf("Point") !== -1;
     return baseData;
   }
-  static getTID300RepresentationArguments(tool, worldToImageCoords) {
-    const tid300Arguments = super.getTID300RepresentationArguments(tool, worldToImageCoords);
+  static getTID300RepresentationArguments(tool) {
+    const tid300Arguments = super.getTID300RepresentationArguments(tool);
     const {
       data
     } = tool;

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

@@ -0,0 +1,11 @@
+import type { Types } from "@cornerstonejs/tools";
+export default class LabelData {
+    protected tid300Item: any;
+    protected annotation: Types.Annotation;
+    ReferencedSOPSequence: any;
+    constructor(tid300Item: any, annotation: Types.Annotation);
+    contentItem(): any;
+    filterCornerstoneFreeText(contentEntries: any): void;
+    createQualitativeLabel(label: string): any;
+    createQualitativeLabelPosition(annotation: Types.Annotation): any;
+}