@cornerstonejs/adapters 3.31.3 → 3.31.5

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

@@ -1,6 +1,6 @@
 import BaseAdapter3D from "./BaseAdapter3D";
 declare class Angle extends BaseAdapter3D {
-    static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any): {
+    static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, metadata: any): {
         description?: string;
         sopInstanceUid?: string;
         annotation: import("packages/tools/dist/esm/types").Annotation;

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

@@ -10,12 +10,10 @@ const {
   CobbAngle: TID300CobbAngle
 } = utilities.TID300;
 class Angle extends BaseAdapter3D {
-  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata) {
     const {
       state,
       NUMGroup,
-      scoord,
-      scoordArgs,
       worldCoords,
       referencedImageId,
       ReferencedFrameNumber

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

@@ -1,6 +1,6 @@
 import BaseAdapter3D from "./BaseAdapter3D";
 declare class ArrowAnnotate extends BaseAdapter3D {
-    static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any, _trackingIdentifier: any): {
+    static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, metadata: any, _trackingIdentifier: any): {
         description?: string;
         sopInstanceUid?: string;
         annotation: import("packages/tools/dist/esm/types").Annotation;

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

@@ -1,20 +1,23 @@
-import MeasurementReport from './MeasurementReport.js';
 import { utilities } from 'dcmjs';
+import { utilities as utilities$1 } from '@cornerstonejs/core';
+import MeasurementReport from './MeasurementReport.js';
 import BaseAdapter3D from './BaseAdapter3D.js';
 import CodingScheme from './CodingScheme.js';
 import 'buffer';
 import { toScoord } from '../helpers/toScoordType.js';
-import '@cornerstonejs/core';
 
 var _ArrowAnnotate;
 const {
   Point: TID300Point
 } = utilities.TID300;
+const {
+  imageToWorldCoords
+} = utilities$1;
 const {
   codeValues
 } = CodingScheme;
 class ArrowAnnotate extends BaseAdapter3D {
-  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata, _trackingIdentifier) {
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, _trackingIdentifier) {
     const {
       state,
       SCOORDGroup,

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

@@ -19,11 +19,18 @@ export default class BaseAdapter3D {
     static trackingIdentifierTextValue: string;
     static trackingIdentifiers: Set<string>;
     static parentType: string;
+    static registerType(code?: string, type?: string, count?: number): void;
+    static getPointsCount(graphicItem: any): number;
+    static getGraphicItems(measurementGroup: any, filter: any): any;
+    static getGraphicItem(measurementGroup: any, offset?: number, type?: any): any;
+    static getGraphicCode(graphicItem: any): string;
+    static getGraphicType(graphicItem: any): any;
+    static isValidMeasurement(_measurementGroup: any): boolean;
     static init(toolType: string, representation: any, options?: AdapterOptions): void;
     static registerLegacy(): void;
     static registerSubType(adapter: MeasurementAdapter, toolType: string, replace?: any): any;
     static isValidCornerstoneTrackingIdentifier(trackingIdentifier: string): boolean;
-    static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, _imageToWorldCoords: any, metadata: any, trackingIdentifier?: string): {
+    static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, metadata: any, trackingIdentifier?: string): {
         description?: string;
         sopInstanceUid?: string;
         annotation: import("packages/tools/dist/esm/types").Annotation;

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

@@ -6,6 +6,50 @@ import { toScoords } from '../helpers/toScoordType.js';
 import '@cornerstonejs/core';
 
 class BaseAdapter3D {
+  static registerType() {
+    let code = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
+    let type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
+    let count = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    let key = code;
+    if (type) {
+      key = `${key}${key.length ? "-" : ""}${type}`;
+    }
+    if (count) {
+      key = `${key}${key.length ? "-" : ""}${count}`;
+    }
+    MeasurementReport.registerAdapterTypes(this, key);
+  }
+  static getPointsCount(graphicItem) {
+    const is3DMeasurement = graphicItem.ValueType === "SCOORD3D";
+    const pointSize = is3DMeasurement ? 3 : 2;
+    return graphicItem.GraphicData.length / pointSize;
+  }
+  static getGraphicItems(measurementGroup, filter) {
+    const items = measurementGroup.ContentSequence.filter(group => group.ValueType === "SCOORD" || group.ValueType === "SCOORD3D");
+    return filter ? items.filter(filter) : items;
+  }
+  static getGraphicItem(measurementGroup) {
+    let offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    let type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+    const items = this.getGraphicItems(measurementGroup, type && (group => group.ValueType === type));
+    return items[offset];
+  }
+  static getGraphicCode(graphicItem) {
+    const {
+      ConceptNameCodeSequence: conceptNameItem
+    } = graphicItem;
+    const {
+      CodeValue: graphicValue,
+      CodingSchemeDesignator: graphicDesignator
+    } = conceptNameItem;
+    return `${graphicDesignator}:${graphicValue}`;
+  }
+  static getGraphicType(graphicItem) {
+    return graphicItem.GraphicType;
+  }
+  static isValidMeasurement(_measurementGroup) {
+    return false;
+  }
   static init(toolType, representation, options) {
     this.toolType = toolType;
     if (BaseAdapter3D.toolType) {
@@ -44,7 +88,7 @@ class BaseAdapter3D {
     }
     return trackingIdentifier.startsWith(this.trackingIdentifierTextValue);
   }
-  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, _imageToWorldCoords, metadata, trackingIdentifier) {
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, trackingIdentifier) {
     const {
       defaultState: state,
       ReferencedFrameNumber

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

@@ -16,10 +16,12 @@ class Bidirectional extends BaseAdapter3D {
   static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata) {
     const {
       state,
+      NUMGroup,
+      scoord,
       scoordArgs,
       referencedImageId,
       ReferencedFrameNumber
-    } = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, Bidirectional.toolType);
+    } = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
     const {
       ContentSequence
     } = MeasurementGroup;
@@ -28,8 +30,8 @@ class Bidirectional extends BaseAdapter3D {
     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 = [];
-    worldCoords.push(...scoordToWorld(scoordArgs, longAxisScoordGroup.GraphicData));
-    worldCoords.push(...scoordToWorld(scoordArgs, shortAxisScoordGroup.GraphicData));
+    worldCoords.push(...scoordToWorld(scoordArgs, longAxisScoordGroup));
+    worldCoords.push(...scoordToWorld(scoordArgs, shortAxisScoordGroup));
     state.annotation.data = {
       ...state.annotation.data,
       handles: {

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

@@ -1,6 +1,6 @@
 import BaseAdapter3D from "./BaseAdapter3D";
 declare class EllipticalROI extends BaseAdapter3D {
-    static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any): {
+    static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, metadata: any): {
         description?: string;
         sopInstanceUid?: string;
         annotation: import("packages/tools/dist/esm/types").Annotation;
@@ -9,7 +9,15 @@ declare class EllipticalROI extends BaseAdapter3D {
     };
     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,60 +1,27 @@
-import { vec3 } from 'gl-matrix';
 import { utilities } from 'dcmjs';
-import { utilities as utilities$1 } from '@cornerstonejs/core';
 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 {
-  worldToImageCoords
-} = utilities$1;
-const EPSILON = 1e-4;
 class EllipticalROI extends BaseAdapter3D {
-  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata) {
     const {
       state,
       NUMGroup,
-      scoord,
-      scoordArgs,
       worldCoords,
       referencedImageId,
       ReferencedFrameNumber
     } = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, EllipticalROI.toolType);
-    const [majorAxisStart, majorAxisEnd, minorAxisStart, minorAxisEnd] = worldCoords;
-    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 = worldCoords;
-    } else if (Math.abs(absoluteOfMinorDotProduct - 1) < EPSILON) {
-      ellipsePoints = [worldCoords[2], worldCoords[3], worldCoords[0], worldCoords[1]];
-    } else {
-      console.warn("OBLIQUE ELLIPSE NOT YET SUPPORTED");
-      return null;
-    }
     state.annotation.data = {
       ...state.annotation.data,
       handles: {
-        points: [...ellipsePoints],
+        points: worldCoords,
         activeHandleIndex: 0,
         textBox: {
           hasMoved: false
@@ -62,13 +29,11 @@ class EllipticalROI extends BaseAdapter3D {
       },
       frameNumber: ReferencedFrameNumber
     };
-    if (referencedImageId) {
-      state.annotation.data.cachedStats = {
-        [`imageId:${referencedImageId}`]: {
-          area: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : 0
-        }
-      };
-    }
+    state.annotation.data.cachedStats = referencedImageId ? {
+      [`imageId:${referencedImageId}`]: {
+        area: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : 0
+      }
+    } : {};
     return state;
   }
   static getTID300RepresentationArguments(tool) {
@@ -87,62 +52,37 @@ class EllipticalROI extends BaseAdapter3D {
     const {
       referencedImageId
     } = metadata;
+    const scoordProps = {
+      is3DMeasurement,
+      referencedImageId
+    };
     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]);
+      bottom = handles.points[2];
+      top = handles.points[3];
+      left = handles.points[0];
+      right = 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]);
+      top = handles.points[0];
+      bottom = handles.points[1];
+      left = handles.points[2];
+      right = handles.points[3];
     }
-    const topBottomLength = Math.abs(top.y - bottom.y);
-    const leftRightLength = Math.abs(left.x - right.x);
+    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]
-      });
-      points.push({
-        x: bottom[0],
-        y: bottom[1]
-      });
-      points.push({
-        x: left[0],
-        y: left[1]
-      });
-      points.push({
-        x: right[0],
-        y: right[1]
-      });
+      points.push(top, bottom, left, right);
     } 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]
-      });
+      points.push(left, right, top, bottom);
     }
     const {
       area
     } = cachedStats[`imageId:${referencedImageId}`] || {};
+    const convertedPoints = points.map(point => toScoord(scoordProps, point));
     return {
       area,
-      points,
+      points: convertedPoints,
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding,
       findingSites: findingSites || [],

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

@@ -3,7 +3,13 @@ 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 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;
+    };
     static getTID300RepresentationArguments(tool: any): {
         points: ({
             x: any;

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

@@ -6,8 +6,8 @@ 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;

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

@@ -50,11 +50,13 @@ export interface MeasurementAdapter {
     init(toolType: string, representation: any, options?: AdapterOptions): any;
     getMeasurementData(measurementGroup: any, sopInstanceUIDToImageIdMap: any, metadata: any, trackingIdentifier: string): any;
     isValidCornerstoneTrackingIdentifier(trackingIdentifier: string): boolean;
+    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, is3DMeasurement: any): any;
     static codeValueMatch: (group: any, code: any, oldCode?: any) => boolean;
@@ -161,5 +163,8 @@ export default class MeasurementReport {
     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 {};

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

@@ -242,7 +242,9 @@ class MeasurementReport {
     const contentSequenceArr = toArray(ContentSequence);
     const findingGroup = contentSequenceArr.find(group => this.codeValueMatch(group, FINDING));
     const findingSiteGroups = contentSequenceArr.filter(group => this.codeValueMatch(group, FINDING_SITE, FINDING_SITE_OLD)) || [];
-    const NUMGroup = contentSequenceArr.find(group => group.ValueType === "NUM");
+    const NUMGroup = contentSequenceArr.find(group => group.ValueType === "NUM") || {
+      ContentSequence: contentSequenceArr.filter(group => group.ValueType === "SCOORD" || group.ValueType === "SCOORD3D")
+    };
     const spatialGroup = this.processSpatialCoordinatesGroup({
       NUMGroup,
       sopInstanceUIDToImageIdMap,
@@ -390,7 +392,7 @@ 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, metadata, trackingIdentifierValue);
           measurement.TrackingUniqueIdentifier = trackingUniqueIdentifierValue;
@@ -439,10 +441,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 {
@@ -465,5 +497,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/Probe.d.ts

@@ -1,16 +1,13 @@
 import BaseAdapter3D from "./BaseAdapter3D";
 declare class Probe extends BaseAdapter3D {
-    static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any, trackingIdentifier: any): any;
-    static getMeasurementDataFromScoord({ state, defaultState, SCOORDGroup, imageToWorldCoords }: {
-        state: any;
-        defaultState: any;
-        SCOORDGroup: any;
-        imageToWorldCoords: any;
-    }): any;
-    static getMeasurementDataFromScoord3D({ state, SCOORD3DGroup }: {
-        state: any;
-        SCOORD3DGroup: any;
-    }): any;
+    static isValidMeasurement(measurement: any): boolean;
+    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;
+    };
     static getTID300RepresentationArguments(tool: any, is3DMeasurement?: boolean): {
         points: ({
             x: any;

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

@@ -10,79 +10,36 @@ const {
   Point: TID300Point
 } = utilities.TID300;
 class Probe extends BaseAdapter3D {
-  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata, trackingIdentifier) {
-    const state = super.getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata, trackingIdentifier);
-    const {
-      defaultState,
-      SCOORDGroup,
-      SCOORD3DGroup
-    } = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, Probe.toolType);
-    if (SCOORDGroup) {
-      return this.getMeasurementDataFromScoord({
-        state,
-        defaultState,
-        SCOORDGroup,
-        imageToWorldCoords
-      });
-    } else if (SCOORD3DGroup) {
-      return this.getMeasurementDataFromScoord3D({
-        state,
-        SCOORD3DGroup
-      });
-    } else {
-      throw new Error("Can't get measurement data with missing SCOORD and SCOORD3D groups.");
-    }
+  static isValidMeasurement(measurement) {
+    const graphicItem = this.getGraphicItem(measurement);
+    return this.getGraphicType(graphicItem) === "POINT" && this.getPointsCount(graphicItem) <= 2;
   }
-  static getMeasurementDataFromScoord(_ref) {
-    let {
-      state,
-      defaultState,
-      SCOORDGroup,
-      imageToWorldCoords
-    } = _ref;
-    const referencedImageId = defaultState.annotation.metadata.referencedImageId;
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, _trackingIdentifier) {
     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);
-    }
-    state.annotation.data = {
-      ...state.annotation.data,
-      handles: {
-        points: worldCoords,
-        activeHandleIndex: null,
-        textBox: {
-          hasMoved: false
-        }
-      }
-    };
-    return state;
-  }
-  static getMeasurementDataFromScoord3D(_ref2) {
-    let {
       state,
-      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);
-    }
+      NUMGroup,
+      scoord,
+      scoordArgs,
+      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: {
         points: worldCoords,
-        activeHandleIndex: null,
+        activeHandleIndex: 0,
         textBox: {
           hasMoved: false
         }
-      }
+      },
+      cachedStats,
+      frameNumber: ReferencedFrameNumber
     };
     return state;
   }
@@ -123,6 +80,8 @@ _Probe = Probe;
 (() => {
   _Probe.init("Probe", TID300Point);
   _Probe.registerLegacy();
+  _Probe.registerType("DCM:111030", "POINT", 1);
+  _Probe.registerType("DCM:111030", "POINT", 2);
 })();
 
 export { Probe as default };

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

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

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

@@ -1,5 +1,7 @@
 import { utilities } from 'dcmjs';
-import { utilities as utilities$1 } from '@cornerstonejs/core';
+import 'buffer';
+import { toScoords } from '../helpers/toScoordType.js';
+import '@cornerstonejs/core';
 import MeasurementReport from './MeasurementReport.js';
 import BaseAdapter3D from './BaseAdapter3D.js';
 
@@ -7,96 +9,36 @@ var _RectangleROI;
 const {
   Polyline: TID300Polyline
 } = utilities.TID300;
-const {
-  worldToImageCoords
-} = utilities$1;
 class RectangleROI extends BaseAdapter3D {
-  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata) {
     const {
-      defaultState,
+      state,
       NUMGroup,
-      SCOORDGroup,
-      SCOORD3DGroup,
+      scoord,
+      scoordArgs,
+      worldCoords,
+      referencedImageId,
       ReferencedFrameNumber
-    } = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, RectangleROI.toolType);
-    if (SCOORDGroup) {
-      return this.getMeasurementDataFromScoord({
-        defaultState,
-        SCOORDGroup,
-        imageToWorldCoords,
-        NUMGroup,
-        ReferencedFrameNumber
-      });
-    } else if (SCOORD3DGroup) {
-      return this.getMeasurementDataFromScoord3D({
-        SCOORD3DGroup,
-        defaultState
-      });
-    } 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;
+    } = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
+    const cachedStats = referencedImageId ? {
+      [`imageId:${referencedImageId}`]: {
+        area: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : 0
+      }
+    } : {};
     state.annotation.data = {
+      ...state.annotation.data,
       handles: {
-        points: [worldCoords[0], worldCoords[1], worldCoords[3], worldCoords[2]],
+        points: worldCoords,
         activeHandleIndex: 0,
         textBox: {
           hasMoved: false
         }
       },
-      cachedStats: {
-        [`imageId:${referencedImageId}`]: {
-          area: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : null
-        }
-      },
+      cachedStats,
       frameNumber: ReferencedFrameNumber
     };
     return state;
   }
-  static getMeasurementDataFromScoord3D(_ref2) {
-    let {
-      SCOORD3DGroup,
-      defaultState
-    } = _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[3], worldCoords[2]],
-        activeHandleIndex: 0,
-        textBox: {
-          hasMoved: false
-        }
-      },
-      cachedStats: {}
-    };
-    return state;
-  }
   static getTID300RepresentationArguments(tool) {
     let is3DMeasurement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     const {
@@ -106,46 +48,21 @@ class RectangleROI extends BaseAdapter3D {
       metadata
     } = tool;
     const {
-      cachedStats = {},
-      handles
-    } = data;
+      polyline,
+      closed
+    } = data.contour;
     const {
       referencedImageId
     } = metadata;
-    if (is3DMeasurement) {
-      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
-    }
-    const corners = handles.points.map(point => worldToImageCoords(referencedImageId, point));
-    const {
-      area,
-      perimeter
-    } = cachedStats;
-    return {
-      points: [corners[0], corners[1], corners[3], corners[2], corners[0]],
-      area,
-      perimeter,
-      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 corners = handles.points;
+    const corners = toScoords(scoordProps, polyline);
     const {
       area,
       perimeter
-    } = cachedStats;
+    } = data.cachedStats[`imageId:${referencedImageId}`] || {};
     return {
       points: [corners[0], corners[1], corners[3], corners[2], corners[0]],
       area,
@@ -153,8 +70,7 @@ class RectangleROI extends BaseAdapter3D {
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding,
       findingSites: findingSites || [],
-      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
-      use3DSpatialCoordinates: true
+      use3DSpatialCoordinates: false
     };
   }
 }
@@ -164,4 +80,4 @@ _RectangleROI = RectangleROI;
   _RectangleROI.registerLegacy();
 })();
 
-export { RectangleROI as default };
+export { RectangleROI, RectangleROI as default };

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

@@ -1,6 +1,6 @@
 import BaseAdapter3D from "./BaseAdapter3D";
 declare class UltrasoundDirectional extends BaseAdapter3D {
-    static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any): {
+    static getMeasurementData(measurementGroup: any, sopInstanceUIDToImageIdMap: any, metadata: any): {
         description?: string;
         sopInstanceUid?: string;
         annotation: import("packages/tools/dist/esm/types").Annotation;

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

@@ -11,26 +11,16 @@ const {
   worldToImageCoords
 } = utilities$1;
 class UltrasoundDirectional extends BaseAdapter3D {
-  static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata) {
+  static getMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, metadata) {
     const {
-      defaultState,
-      SCOORDGroup,
+      state,
+      worldCoords,
       ReferencedFrameNumber
-    } = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, UltrasoundDirectional.toolType);
-    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;
+    } = MeasurementReport.getSetupMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
     state.annotation.data = {
       ...state.annotation.data,
       handles: {
-        points: [worldCoords[0], worldCoords[1]],
+        points: worldCoords,
         activeHandleIndex: 0,
         textBox: {
           hasMoved: false

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

@@ -7,7 +7,7 @@ import Angle from './Angle.js';
 import CobbAngle from './CobbAngle.js';
 import CircleROI from './CircleROI.js';
 import EllipticalROI from './EllipticalROI.js';
-import RectangleROI from './RectangleROI.js';
+import { RectangleROI } from './RectangleROI.js';
 import Length from './Length.js';
 import PlanarFreehandROI from './PlanarFreehandROI.js';
 import Probe from './Probe.js';

package/dist/esm/adapters/helpers/toArray.js

@@ -1,3 +1,3 @@
-const toArray = x => Array.isArray(x) ? x : [x];
+const toArray = x => Array.isArray(x) ? x : x !== undefined ? [x] : [];
 
 export { toArray };

package/dist/esm/adapters/index.d.ts

@@ -22,7 +22,7 @@ declare const adaptersSR: {
         Length: typeof import("./Cornerstone3D/Length").default;
         CircleROI: typeof import("./Cornerstone3D/CircleROI").default;
         EllipticalROI: typeof import("./Cornerstone3D/EllipticalROI").default;
-        RectangleROI: typeof import("./Cornerstone3D/RectangleROI").default;
+        RectangleROI: typeof import("./Cornerstone3D/RectangleROI").RectangleROI;
         ArrowAnnotate: typeof import("./Cornerstone3D/ArrowAnnotate").default;
         Probe: typeof import("./Cornerstone3D/Probe").default;
         PlanarFreehandROI: typeof import("./Cornerstone3D/PlanarFreehandROI").default;

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "3.31.3";
+export declare const version = "3.31.5";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cornerstonejs/adapters",
-    "version": "3.31.3",
+    "version": "3.31.5",
     "description": "Adapters for Cornerstone3D to/from formats including DICOM SR and others",
     "module": "./dist/esm/index.js",
     "types": "./dist/esm/index.d.ts",
@@ -90,8 +90,8 @@
         "ndarray": "^1.0.19"
     },
     "peerDependencies": {
-        "@cornerstonejs/core": "^3.31.3",
-        "@cornerstonejs/tools": "^3.31.3"
+        "@cornerstonejs/core": "^3.31.5",
+        "@cornerstonejs/tools": "^3.31.5"
     },
-    "gitHead": "f68f1d6e2f9c4e18f81c51d5d728d8560d6f56cb"
+    "gitHead": "014f4c4cc2b973b200ec9af2e16783464b9a2a0d"
 }