@cornerstonejs/adapters 3.31.0 → 3.31.2

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

@@ -1,27 +1,37 @@
+import { type Types as CSTypes } from "@cornerstonejs/core";
+import type { Types } from "@cornerstonejs/tools";
+type Annotation = Types.Annotation;
 type SpatialCoordinatesState = {
     description?: string;
     sopInstanceUid?: string;
-    annotation: {
-        annotationUID: string;
-        metadata: {
-            toolName: string;
-            referencedImageId?: string;
-            FrameOfReferenceUID: string;
-            label: string;
-        };
-        data?: unknown;
-    };
+    annotation: Annotation;
     finding?: unknown;
     findingSites?: unknown;
 };
+type ScoordType = {
+    GraphicData: number[];
+};
 type SetupMeasurementData = {
     defaultState: SpatialCoordinatesState;
-    NUMGroup: Record<string, unknown>;
-    SCOORDGroup?: Record<string, unknown>;
+    state?: SpatialCoordinatesState;
+    is3DMeasurement?: boolean;
+    scoord?: ScoordType;
+    worldCoords?: CSTypes.Point3[];
+    scoordArgs?: {
+        referencedImageId: string;
+        is3DMeasurement: boolean;
+    };
+    NUMGroup: {
+        MeasuredValueSequence: {
+            NumericValue: number;
+        };
+    };
+    SCOORDGroup?: ScoordType;
     ReferencedSOPSequence?: Record<string, unknown>;
     ReferencedSOPInstanceUID?: string;
+    referencedImageId?: string;
     ReferencedFrameNumber?: string;
-    SCOORD3DGroup?: Record<string, unknown>;
+    SCOORD3DGroup?: ScoordType;
     FrameOfReferenceUID?: string;
 };
 type SpatialCoordinatesData = Omit<SetupMeasurementData, "defaultState" | "NUMGroup"> & {
@@ -38,17 +48,17 @@ export interface MeasurementAdapter {
     trackingIdentifiers: Set<string>;
     parentType: string;
     init(toolType: string, representation: any, options?: AdapterOptions): any;
-    getMeasurementData(measurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any, trackingIdentifier: string): any;
+    getMeasurementData(measurementGroup: any, sopInstanceUIDToImageIdMap: any, metadata: any, trackingIdentifier: string): any;
     isValidCornerstoneTrackingIdentifier(trackingIdentifier: string): boolean;
-    getTID300RepresentationArguments(tool: any, worldToImageCoords: any): Record<string, unknown>;
+    getTID300RepresentationArguments(tool: any, is3DMeasurement: any): Record<string, unknown>;
 }
 export default class MeasurementReport {
     static CORNERSTONE_3D_TAG: string;
     static measurementAdapterByToolType: Map<string, MeasurementAdapter>;
     static measurementAdapterByTrackingIdentifier: Map<string, MeasurementAdapter>;
-    static getTID300ContentItem(tool: any, ReferencedSOPSequence: any, toolClass: any, worldToImageCoords: any): any;
+    static getTID300ContentItem(tool: any, ReferencedSOPSequence: any, toolClass: any, is3DMeasurement: any): any;
     static codeValueMatch: (group: any, code: any, oldCode?: any) => boolean;
-    static getMeasurementGroup(toolType: any, toolData: any, ReferencedSOPSequence: any, worldToImageCoords: any): any;
+    static getMeasurementGroup(toolType: any, toolData: any, ReferencedSOPSequence: any, is3DMeasurement: any): any;
     static getCornerstoneLabelFromDefaultState(defaultState: any): any;
     static generateDatasetMeta(): {
         FileMetaInformationVersion: {
@@ -77,7 +87,28 @@ export default class MeasurementReport {
         toolType: any;
         sopInstanceUIDToImageIdMap: any;
         metadata: any;
-    }): SpatialCoordinatesData;
+    }): {
+        SCOORDGroup: any;
+        ReferencedSOPSequence: any;
+        ReferencedSOPInstanceUID: any;
+        ReferencedFrameNumber: any;
+        referencedImageId: any;
+        state: {
+            description: any;
+            sopInstanceUid: any;
+            annotation: {
+                data: {
+                    annotationUID: any;
+                };
+                annotationUID: any;
+                metadata: {
+                    toolName: any;
+                    referencedImageId: any;
+                    FrameOfReferenceUID: any;
+                };
+            };
+        };
+    };
     static processSCOORD3DGroup({ SCOORD3DGroup, toolType }: {
         SCOORD3DGroup: any;
         toolType: any;
@@ -96,28 +127,16 @@ export default class MeasurementReport {
         findingSiteGroups: any;
         toolType: any;
     }): {
-        defaultState: {
-            finding: any;
-            findingSites: any;
-            description?: string;
-            sopInstanceUid?: string;
-            annotation: {
-                annotationUID: string;
-                metadata: {
-                    toolName: string;
-                    referencedImageId?: string;
-                    FrameOfReferenceUID: string;
-                    label: string;
-                };
-                data?: unknown;
-            };
-        };
+        defaultState: SpatialCoordinatesState;
+        state: SpatialCoordinatesState;
         NUMGroup: any;
-        SCOORDGroup: Record<string, unknown>;
+        scoord: ScoordType;
+        SCOORDGroup: ScoordType;
         ReferencedSOPSequence: Record<string, unknown>;
         ReferencedSOPInstanceUID: string;
+        referencedImageId: string;
         ReferencedFrameNumber: string;
-        SCOORD3DGroup: Record<string, unknown>;
+        SCOORD3DGroup: ScoordType;
         FrameOfReferenceUID: string;
     };
     static getSetupMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, metadata: any, toolType: any): SetupMeasurementData;
@@ -137,8 +156,8 @@ export default class MeasurementReport {
         toolData: any;
         toolTypes: any;
     }): string;
-    static generateReport(toolState: any, metadataProvider: any, worldToImageCoords: any, options: any): any;
-    static generateToolState(dataset: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any, hooks: any): {};
+    static generateReport(toolState: any, metadataProvider: any, options: any): any;
+    static generateToolState(dataset: any, sopInstanceUIDToImageIdMap: any, metadata: any, hooks: any): {};
     static registerTool(toolAdapter: MeasurementAdapter, replace?: boolean | ((original: any) => void)): void;
     static registerTrackingIdentifier(toolClass: any, ...trackingIdentifiers: string[]): void;
     static getAdapterForTrackingIdentifier(trackingIdentifier: string): MeasurementAdapter;

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

@@ -1,11 +1,13 @@
-import { utilities, derivations, normalizers, data } from 'dcmjs';
-import { cache } from '@cornerstonejs/core';
+import { utilities as utilities$1, derivations, normalizers, data } from 'dcmjs';
+import { utilities, cache } from '@cornerstonejs/core';
 import CORNERSTONE_3D_TAG from './cornerstone3DTag.js';
 import { toArray } from '../helpers/toArray.js';
 import { codeMeaningEquals } from '../helpers/codeMeaningEquals.js';
 import 'buffer';
 import { copyStudyTags } from '../helpers/copyStudyTags.js';
 import { copySeriesTags } from '../helpers/copySeriesTags.js';
+import { scoordToWorld } from '../helpers/scoordToWorld.js';
+import { toPoint3 } from '../helpers/toPoint3.js';
 import CodingScheme from './CodingScheme.js';
 import { NO_IMAGE_ID } from './constants/index.js';
 
@@ -13,7 +15,7 @@ var _MeasurementReport;
 const {
   TID1500,
   addAccessors
-} = utilities;
+} = utilities$1;
 const {
   StructuredReport
 } = derivations;
@@ -40,20 +42,20 @@ const FINDING_SITE_OLD = {
   CodeValue: "G-C0E3"
 };
 class MeasurementReport {
-  static getTID300ContentItem(tool, ReferencedSOPSequence, toolClass, worldToImageCoords) {
-    const args = toolClass.getTID300RepresentationArguments(tool, worldToImageCoords);
+  static getTID300ContentItem(tool, ReferencedSOPSequence, toolClass, is3DMeasurement) {
+    const args = toolClass.getTID300RepresentationArguments(tool, is3DMeasurement);
     args.ReferencedSOPSequence = ReferencedSOPSequence;
     const TID300Measurement = new toolClass.TID300Representation(args);
     return TID300Measurement;
   }
-  static getMeasurementGroup(toolType, toolData, ReferencedSOPSequence, worldToImageCoords) {
+  static getMeasurementGroup(toolType, toolData, ReferencedSOPSequence, is3DMeasurement) {
     const toolTypeData = toolData[toolType];
     const toolClass = this.measurementAdapterByToolType.get(toolType);
     if (!toolTypeData || !toolTypeData.data || !toolTypeData.data.length || !toolClass) {
       return;
     }
     const Measurements = toolTypeData.data.map(tool => {
-      return this.getTID300ContentItem(tool, ReferencedSOPSequence, toolClass, worldToImageCoords);
+      return this.getTID300ContentItem(tool, ReferencedSOPSequence, toolClass, is3DMeasurement);
     });
     return new TID1501MeasurementGroup(Measurements);
   }
@@ -110,21 +112,25 @@ class MeasurementReport {
     } = ReferencedSOPSequence;
     const referencedImageId = sopInstanceUIDToImageIdMap[ReferencedSOPInstanceUID];
     const imagePlaneModule = metadata.get("imagePlaneModule", referencedImageId);
+    const annotationUID = DicomMetaDictionary.uid();
     return {
       SCOORDGroup,
       ReferencedSOPSequence,
       ReferencedSOPInstanceUID,
       ReferencedFrameNumber,
+      referencedImageId,
       state: {
         description: undefined,
         sopInstanceUid: ReferencedSOPInstanceUID,
         annotation: {
-          annotationUID: DicomMetaDictionary.uid(),
+          data: {
+            annotationUID
+          },
+          annotationUID,
           metadata: {
             toolName: toolType,
             referencedImageId,
-            FrameOfReferenceUID: imagePlaneModule.frameOfReferenceUID,
-            label: ""
+            FrameOfReferenceUID: imagePlaneModule.frameOfReferenceUID
           }
         }
       }
@@ -135,21 +141,26 @@ class MeasurementReport {
       SCOORD3DGroup,
       toolType
     } = _ref2;
-    return {
+    const annotationUID = DicomMetaDictionary.uid();
+    const toolData = {
       SCOORD3DGroup,
       FrameOfReferenceUID: SCOORD3DGroup.ReferencedFrameOfReferenceUID,
       state: {
         description: undefined,
         annotation: {
-          annotationUID: DicomMetaDictionary.uid(),
+          annotationUID,
+          data: {
+            annotationUID
+          },
           metadata: {
             toolName: toolType,
-            FrameOfReferenceUID: SCOORD3DGroup.ReferencedFrameOfReferenceUID,
-            label: ""
+            FrameOfReferenceUID: SCOORD3DGroup.ReferencedFrameOfReferenceUID
           }
         }
       }
     };
+    utilities.updatePlaneRestriction(toPoint3(SCOORD3DGroup.GraphicData), toolData.state.annotation.metadata);
+    return toolData;
   }
   static getSpatialCoordinatesState(_ref3) {
     let {
@@ -192,7 +203,8 @@ class MeasurementReport {
       ReferencedSOPInstanceUID,
       ReferencedFrameNumber,
       SCOORD3DGroup,
-      FrameOfReferenceUID
+      FrameOfReferenceUID,
+      referencedImageId
     } = this.getSpatialCoordinatesState({
       NUMGroup,
       sopInstanceUIDToImageIdMap,
@@ -203,21 +215,21 @@ class MeasurementReport {
     const findingSites = findingSiteGroups.map(fsg => {
       return addAccessors(fsg.ConceptCodeSequence);
     });
-    const defaultState = {
-      ...state,
-      finding,
-      findingSites
-    };
-    if (defaultState.finding) {
-      defaultState.description = defaultState.finding.CodeMeaning;
+    state.finding = finding;
+    state.findingSites = findingSites;
+    if (finding) {
+      state.description = finding.CodeMeaning;
     }
-    defaultState.annotation.metadata.label = MeasurementReport.getCornerstoneLabelFromDefaultState(defaultState);
+    state.annotation.data.label = MeasurementReport.getCornerstoneLabelFromDefaultState(state);
     return {
-      defaultState,
+      defaultState: state,
+      state,
       NUMGroup,
+      scoord: SCOORD3DGroup || SCOORDGroup,
       SCOORDGroup,
       ReferencedSOPSequence,
       ReferencedSOPInstanceUID,
+      referencedImageId,
       ReferencedFrameNumber,
       SCOORD3DGroup,
       FrameOfReferenceUID
@@ -231,7 +243,7 @@ class MeasurementReport {
     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");
-    return this.processSpatialCoordinatesGroup({
+    const spatialGroup = this.processSpatialCoordinatesGroup({
       NUMGroup,
       sopInstanceUIDToImageIdMap,
       metadata,
@@ -239,6 +251,23 @@ class MeasurementReport {
       findingSiteGroups,
       toolType
     });
+    const {
+      referencedImageId
+    } = spatialGroup.state.annotation.metadata;
+    const is3DMeasurement = !!spatialGroup.SCOORD3DGroup;
+    const scoordArgs = {
+      referencedImageId,
+      is3DMeasurement
+    };
+    const scoord = spatialGroup.SCOORD3DGroup || spatialGroup.SCOORDGroup;
+    const worldCoords = scoordToWorld(scoordArgs, scoord);
+    return {
+      ...spatialGroup,
+      is3DMeasurement,
+      scoordArgs,
+      scoord,
+      worldCoords
+    };
   }
   static generateReferencedSOPSequence(_ref5) {
     let {
@@ -286,10 +315,13 @@ class MeasurementReport {
     const referenceToolData = toolData?.[toolTypes?.[0]]?.data?.[0];
     const volumeId = referenceToolData?.metadata?.volumeId;
     const volume = cache.getVolume(volumeId);
+    if (!volume) {
+      throw new Error(`No volume found for ${volumeId}`);
+    }
     const imageId = volume.imageIds[0];
     return imageId;
   }
-  static generateReport(toolState, metadataProvider, worldToImageCoords, options) {
+  static generateReport(toolState, metadataProvider, options) {
     let allMeasurementGroups = [];
     const sopInstanceUIDsToSeriesInstanceUIDMap = {};
     const derivationSourceDatasets = [];
@@ -298,6 +330,7 @@ class MeasurementReport {
     Object.keys(toolState).forEach(imageId => {
       const toolData = toolState[imageId];
       const toolTypes = Object.keys(toolData);
+      const is3DMeasurement = imageId === NO_IMAGE_ID;
       const ReferencedSOPSequence = this.generateReferencedSOPSequence({
         toolData,
         toolTypes,
@@ -306,12 +339,12 @@ class MeasurementReport {
         sopInstanceUIDsToSeriesInstanceUIDMap,
         derivationSourceDatasets
       });
-      if (imageId === NO_IMAGE_ID) {
+      if (is3DMeasurement) {
         is3DSR = true;
       }
       const measurementGroups = [];
       toolTypes.forEach(toolType => {
-        const group = this.getMeasurementGroup(toolType, toolData, ReferencedSOPSequence, worldToImageCoords);
+        const group = this.getMeasurementGroup(toolType, toolData, ReferencedSOPSequence, is3DMeasurement);
         if (group) {
           measurementGroups.push(group);
         }
@@ -331,10 +364,13 @@ class MeasurementReport {
     report.SpecificCharacterSet = "ISO_IR 192";
     if (is3DSR) {
       report.dataset.SOPClassUID = DicomMetaDictionary.sopClassUIDsByName.Comprehensive3DSR;
+      if (!report.dataset.SOPClassUID) {
+        throw new Error(`NO sop class defined for Comprehensive3DSR in ${JSON.stringify(DicomMetaDictionary.sopClassUIDsByName)}`);
+      }
     }
     return report;
   }
-  static generateToolState(dataset, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata, hooks) {
+  static generateToolState(dataset, sopInstanceUIDToImageIdMap, metadata, hooks) {
     if (dataset.ContentTemplateSequence.TemplateIdentifier !== "1500") {
       throw new Error("This package can currently only interpret DICOM SR TID 1500");
     }
@@ -356,7 +392,7 @@ class MeasurementReport {
         const trackingUniqueIdentifierValue = trackingUniqueIdentifierGroup?.UID;
         const toolAdapter = hooks?.getToolClass?.(measurementGroup, dataset, this.measurementAdapterByToolType) || this.getAdapterForTrackingIdentifier(trackingIdentifierValue);
         if (toolAdapter) {
-          const measurement = toolAdapter.getMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata, trackingIdentifierValue);
+          const measurement = toolAdapter.getMeasurementData(measurementGroup, sopInstanceUIDToImageIdMap, metadata, trackingIdentifierValue);
           measurement.TrackingUniqueIdentifier = trackingUniqueIdentifierValue;
           console.log(`=== ${toolAdapter.toolType} ===`);
           console.log(measurement);

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

@@ -1,48 +1,23 @@
 import BaseAdapter3D from "./BaseAdapter3D";
 declare class PlanarFreehandROI extends BaseAdapter3D {
     static closedContourThreshold: number;
-    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): {
-        points: any;
-        area: any;
-        areaUnit: any;
-        perimeter: any;
-        modalityUnit: any;
-        mean: any;
-        max: any;
-        stdDev: any;
-        trackingIdentifierTextValue: string;
-        finding: any;
-        findingSites: any;
-        ReferencedFrameOfReferenceUID: any;
-        use3DSpatialCoordinates: boolean;
-    } | {
-        points: any;
-        area: any;
-        areaUnit: any;
-        perimeter: any;
-        modalityUnit: any;
-        mean: any;
-        max: any;
-        stdDev: 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): {
-        points: any;
+    static getTID300RepresentationArguments(tool: any, is3DMeasurement?: boolean): {
+        points: ({
+            x: any;
+            y: any;
+            z: any;
+        } | {
+            x: number;
+            y: number;
+            z?: undefined;
+        })[];
         area: any;
         areaUnit: any;
         perimeter: any;

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

@@ -2,54 +2,25 @@ import MeasurementReport from './MeasurementReport.js';
 import { utilities } from 'dcmjs';
 import { vec3 } from 'gl-matrix';
 import BaseAdapter3D from './BaseAdapter3D.js';
+import 'buffer';
+import { toScoords } from '../helpers/toScoordType.js';
+import '@cornerstonejs/core';
 
 var _PlanarFreehandROI;
 const {
   Polyline: TID300Polyline
 } = utilities.TID300;
 class PlanarFreehandROI 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, PlanarFreehandROI.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);
-    }
+    } = MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
     const distanceBetweenFirstAndLastPoint = vec3.distance(worldCoords[worldCoords.length - 1], worldCoords[0]);
     let isOpenContour = true;
     if (distanceBetweenFirstAndLastPoint < this.closedContourThreshold) {
@@ -60,8 +31,8 @@ class PlanarFreehandROI extends BaseAdapter3D {
     if (isOpenContour) {
       points.push(worldCoords[0], worldCoords[worldCoords.length - 1]);
     }
-    const state = defaultState;
     state.annotation.data = {
+      ...state.annotation.data,
       contour: {
         polyline: worldCoords,
         closed: !isOpenContour
@@ -73,56 +44,19 @@ class PlanarFreehandROI extends BaseAdapter3D {
           hasMoved: false
         }
       },
-      cachedStats: {
+      frameNumber: ReferencedFrameNumber
+    };
+    if (referencedImageId) {
+      state.annotation.data.cachedStats = {
         [`imageId:${referencedImageId}`]: {
           area: 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 distanceBetweenFirstAndLastPoint = vec3.distance(worldCoords[worldCoords.length - 1], worldCoords[0]);
-    let isOpenContour = true;
-    if (distanceBetweenFirstAndLastPoint < this.closedContourThreshold) {
-      worldCoords.pop();
-      isOpenContour = false;
-    }
-    const points = [];
-    if (isOpenContour) {
-      points.push(worldCoords[0], worldCoords[worldCoords.length - 1]);
-    }
-    const state = defaultState;
-    state.annotation.data = {
-      contour: {
-        polyline: worldCoords,
-        closed: !isOpenContour
-      },
-      handles: {
-        points,
-        activeHandleIndex: null,
-        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,
@@ -137,13 +71,14 @@ class PlanarFreehandROI extends BaseAdapter3D {
     const {
       referencedImageId
     } = metadata;
-    if (!referencedImageId) {
-      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
-    }
-    const points = polyline.map(worldPos => worldToImageCoords(referencedImageId, worldPos));
+    const scoordProps = {
+      is3DMeasurement,
+      referencedImageId
+    };
+    const points = toScoords(scoordProps, polyline);
     if (!isOpenContour) {
       const firstPoint = points[0];
-      points.push([firstPoint[0], firstPoint[1]]);
+      points.push(firstPoint);
     }
     const {
       area,
@@ -166,52 +101,10 @@ class PlanarFreehandROI extends BaseAdapter3D {
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding,
       findingSites: findingSites || [],
+      ReferencedFrameOfReferenceUID: is3DMeasurement ? metadata.FrameOfReferenceUID : null,
       use3DSpatialCoordinates: false
     };
   }
-  static getTID300RepresentationArgumentsSCOORD3D(tool) {
-    const {
-      data,
-      finding,
-      findingSites,
-      metadata
-    } = tool;
-    const {
-      polyline,
-      closed
-    } = data.contour;
-    const isOpenContour = closed !== true;
-    const points = polyline;
-    if (!isOpenContour) {
-      const firstPoint = points[0];
-      points.push([firstPoint[0], firstPoint[1], firstPoint[2]]);
-    }
-    const cachedStatsKeys = Object.keys(data.cachedStats)[0];
-    const {
-      area = undefined,
-      areaUnit = undefined,
-      modalityUnit = undefined,
-      perimeter = undefined,
-      mean = undefined,
-      max = undefined,
-      stdDev = undefined
-    } = cachedStatsKeys ? data.cachedStats[cachedStatsKeys] : {};
-    return {
-      points,
-      area,
-      areaUnit,
-      perimeter,
-      modalityUnit,
-      mean,
-      max,
-      stdDev,
-      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
-      finding,
-      findingSites: findingSites || [],
-      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
-      use3DSpatialCoordinates: true
-    };
-  }
 }
 _PlanarFreehandROI = PlanarFreehandROI;
 _PlanarFreehandROI.closedContourThreshold = 1e-5;