@cornerstonejs/adapters 3.14.3 → 3.15.0

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

@@ -1,4 +1,5 @@
 import { utilities, derivations, normalizers, data } from 'dcmjs';
+import { cache } from '@cornerstonejs/core';
 import CORNERSTONE_3D_TAG from './cornerstone3DTag.js';
 import { toArray } from '../helpers/toArray.js';
 import { codeMeaningEquals } from '../helpers/codeMeaningEquals.js';
@@ -92,15 +93,13 @@ class MeasurementReport {
     };
     return _meta;
   }
-  static getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, toolType) {
-    const {
-      ContentSequence
-    } = MeasurementGroup;
-    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 SCOORDGroup = toArray(NUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD");
+  static processSCOORDGroup(_ref) {
+    let {
+      SCOORDGroup,
+      toolType,
+      sopInstanceUIDToImageIdMap,
+      metadata
+    } = _ref;
     const {
       ReferencedSOPSequence
     } = SCOORDGroup.ContentSequence;
@@ -110,23 +109,101 @@ class MeasurementReport {
     } = ReferencedSOPSequence;
     const referencedImageId = sopInstanceUIDToImageIdMap[ReferencedSOPInstanceUID];
     const imagePlaneModule = metadata.get("imagePlaneModule", referencedImageId);
+    return {
+      SCOORDGroup,
+      ReferencedSOPSequence,
+      ReferencedSOPInstanceUID,
+      ReferencedFrameNumber,
+      state: {
+        description: undefined,
+        sopInstanceUid: ReferencedSOPInstanceUID,
+        annotation: {
+          annotationUID: DicomMetaDictionary.uid(),
+          metadata: {
+            toolName: toolType,
+            referencedImageId,
+            FrameOfReferenceUID: imagePlaneModule.frameOfReferenceUID,
+            label: ""
+          }
+        }
+      }
+    };
+  }
+  static processSCOORD3DGroup(_ref2) {
+    let {
+      SCOORD3DGroup,
+      toolType
+    } = _ref2;
+    return {
+      SCOORD3DGroup,
+      FrameOfReferenceUID: SCOORD3DGroup.ReferencedFrameOfReferenceUID,
+      state: {
+        description: undefined,
+        annotation: {
+          annotationUID: DicomMetaDictionary.uid(),
+          metadata: {
+            toolName: toolType,
+            FrameOfReferenceUID: SCOORD3DGroup.ReferencedFrameOfReferenceUID,
+            label: ""
+          }
+        }
+      }
+    };
+  }
+  static getSpatialCoordinatesState(_ref3) {
+    let {
+      NUMGroup,
+      sopInstanceUIDToImageIdMap,
+      metadata,
+      toolType
+    } = _ref3;
+    const SCOORDGroup = toArray(NUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD");
+    const SCOORD3DGroup = toArray(NUMGroup.ContentSequence).find(group => group.ValueType === "SCOORD3D");
+    if (SCOORDGroup) {
+      return this.processSCOORDGroup({
+        SCOORDGroup,
+        toolType,
+        metadata,
+        sopInstanceUIDToImageIdMap
+      });
+    } else if (SCOORD3DGroup) {
+      return this.processSCOORD3DGroup({
+        SCOORD3DGroup,
+        toolType
+      });
+    } else {
+      throw new Error("No spatial coordinates group found.");
+    }
+  }
+  static processSpatialCoordinatesGroup(_ref4) {
+    let {
+      NUMGroup,
+      sopInstanceUIDToImageIdMap,
+      metadata,
+      findingGroup,
+      findingSiteGroups,
+      toolType
+    } = _ref4;
+    const {
+      state,
+      SCOORDGroup,
+      ReferencedSOPSequence,
+      ReferencedSOPInstanceUID,
+      ReferencedFrameNumber,
+      SCOORD3DGroup,
+      FrameOfReferenceUID
+    } = this.getSpatialCoordinatesState({
+      NUMGroup,
+      sopInstanceUIDToImageIdMap,
+      metadata,
+      toolType
+    });
     const finding = findingGroup ? addAccessors(findingGroup.ConceptCodeSequence) : undefined;
     const findingSites = findingSiteGroups.map(fsg => {
       return addAccessors(fsg.ConceptCodeSequence);
     });
     const defaultState = {
-      description: undefined,
-      sopInstanceUid: ReferencedSOPInstanceUID,
-      annotation: {
-        annotationUID: DicomMetaDictionary.uid(),
-        metadata: {
-          toolName: toolType,
-          referencedImageId,
-          FrameOfReferenceUID: imagePlaneModule.frameOfReferenceUID,
-          label: ""
-        },
-        data: undefined
-      },
+      ...state,
       finding,
       findingSites
     };
@@ -140,39 +217,96 @@ class MeasurementReport {
       SCOORDGroup,
       ReferencedSOPSequence,
       ReferencedSOPInstanceUID,
-      ReferencedFrameNumber
+      ReferencedFrameNumber,
+      SCOORD3DGroup,
+      FrameOfReferenceUID
     };
   }
+  static getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, toolType) {
+    const {
+      ContentSequence
+    } = MeasurementGroup;
+    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");
+    return this.processSpatialCoordinatesGroup({
+      NUMGroup,
+      sopInstanceUIDToImageIdMap,
+      metadata,
+      findingGroup,
+      findingSiteGroups,
+      toolType
+    });
+  }
+  static generateReferencedSOPSequence(_ref5) {
+    let {
+      toolData,
+      toolTypes,
+      metadataProvider,
+      imageId,
+      sopInstanceUIDsToSeriesInstanceUIDMap,
+      derivationSourceDatasets
+    } = _ref5;
+    const effectiveImageId = imageId === "none" ? this.getImageIdFromVolume({
+      toolData,
+      toolTypes
+    }) : imageId;
+    const sopCommonModule = metadataProvider.get("sopCommonModule", effectiveImageId);
+    const instance = metadataProvider.get("instance", effectiveImageId);
+    const {
+      sopInstanceUID,
+      sopClassUID
+    } = sopCommonModule;
+    const {
+      SeriesInstanceUID: seriesInstanceUID
+    } = instance;
+    sopInstanceUIDsToSeriesInstanceUIDMap[sopInstanceUID] = seriesInstanceUID;
+    if (!derivationSourceDatasets.find(dsd => dsd.SeriesInstanceUID === seriesInstanceUID)) {
+      const derivationSourceDataset = MeasurementReport.generateDerivationSourceDataset(instance);
+      derivationSourceDatasets.push(derivationSourceDataset);
+    }
+    const frameNumber = metadataProvider.get("frameNumber", effectiveImageId);
+    const ReferencedSOPSequence = {
+      ReferencedSOPClassUID: sopClassUID,
+      ReferencedSOPInstanceUID: sopInstanceUID,
+      ReferencedFrameNumber: undefined
+    };
+    if (instance && instance.NumberOfFrames && instance.NumberOfFrames > 1 || Normalizer.isMultiframeSOPClassUID(sopClassUID)) {
+      ReferencedSOPSequence.ReferencedFrameNumber = frameNumber;
+    }
+    return ReferencedSOPSequence;
+  }
+  static getImageIdFromVolume(_ref6) {
+    let {
+      toolData,
+      toolTypes
+    } = _ref6;
+    const referenceToolData = toolData?.[toolTypes?.[0]]?.data?.[0];
+    const volumeId = referenceToolData?.metadata?.volumeId;
+    const volume = cache.getVolume(volumeId);
+    const imageId = volume.imageIds[0];
+    return imageId;
+  }
   static generateReport(toolState, metadataProvider, worldToImageCoords, options) {
     let allMeasurementGroups = [];
     const sopInstanceUIDsToSeriesInstanceUIDMap = {};
     const derivationSourceDatasets = [];
     const _meta = MeasurementReport.generateDatasetMeta();
+    let is3DSR = false;
     Object.keys(toolState).forEach(imageId => {
-      const sopCommonModule = metadataProvider.get("sopCommonModule", imageId);
-      const instance = metadataProvider.get("instance", imageId);
-      const {
-        sopInstanceUID,
-        sopClassUID
-      } = sopCommonModule;
-      const {
-        SeriesInstanceUID: seriesInstanceUID
-      } = instance;
-      sopInstanceUIDsToSeriesInstanceUIDMap[sopInstanceUID] = seriesInstanceUID;
-      if (!derivationSourceDatasets.find(dsd => dsd.SeriesInstanceUID === seriesInstanceUID)) {
-        const derivationSourceDataset = MeasurementReport.generateDerivationSourceDataset(instance);
-        derivationSourceDatasets.push(derivationSourceDataset);
-      }
-      const frameNumber = metadataProvider.get("frameNumber", imageId);
       const toolData = toolState[imageId];
       const toolTypes = Object.keys(toolData);
-      const ReferencedSOPSequence = {
-        ReferencedSOPClassUID: sopClassUID,
-        ReferencedSOPInstanceUID: sopInstanceUID,
-        ReferencedFrameNumber: undefined
-      };
-      if (instance && instance.NumberOfFrames && instance.NumberOfFrames > 1 || Normalizer.isMultiframeSOPClassUID(sopClassUID)) {
-        ReferencedSOPSequence.ReferencedFrameNumber = frameNumber;
+      const ReferencedSOPSequence = this.generateReferencedSOPSequence({
+        toolData,
+        toolTypes,
+        metadataProvider,
+        imageId,
+        sopInstanceUIDsToSeriesInstanceUIDMap,
+        derivationSourceDatasets
+      });
+      if (imageId === "none") {
+        is3DSR = true;
       }
       const measurementGroups = [];
       toolTypes.forEach(toolType => {
@@ -194,6 +328,9 @@ class MeasurementReport {
     report.dataset = Object.assign(report.dataset, contentItem);
     report.dataset._meta = _meta;
     report.SpecificCharacterSet = "ISO_IR 192";
+    if (is3DSR) {
+      report.dataset.SOPClassUID = DicomMetaDictionary.sopClassUIDsByName.Comprehensive3DSR;
+    }
     return report;
   }
   static generateToolState(dataset, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata, hooks) {

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

@@ -1,23 +1,47 @@
 import BaseAdapter3D from "./BaseAdapter3D";
 declare class PlanarFreehandROI extends BaseAdapter3D {
     static closedContourThreshold: number;
-    static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any): {
-        description: any;
-        sopInstanceUid: any;
-        annotation: {
-            annotationUID: any;
-            metadata: {
-                toolName: any;
-                referencedImageId: any;
-                FrameOfReferenceUID: any;
-                label: string;
-            };
-            data: any;
-        };
+    static 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[];
+        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 getTID300RepresentationArguments(tool: any, worldToImageCoords: any): {
+    static getTID300RepresentationArgumentsSCOORD3D(tool: any): {
         points: any;
         area: any;
         areaUnit: any;
@@ -29,6 +53,8 @@ declare class PlanarFreehandROI extends BaseAdapter3D {
         trackingIdentifierTextValue: string;
         finding: any;
         findingSites: any;
+        ReferencedFrameOfReferenceUID: any;
+        use3DSpatialCoordinates: boolean;
     };
 }
 export default PlanarFreehandROI;

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

@@ -13,8 +13,34 @@ class PlanarFreehandROI extends BaseAdapter3D {
       defaultState,
       NUMGroup,
       SCOORDGroup,
+      SCOORD3DGroup,
       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
@@ -56,6 +82,46 @@ class PlanarFreehandROI extends BaseAdapter3D {
     };
     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) {
     const {
       data,
@@ -72,7 +138,7 @@ class PlanarFreehandROI extends BaseAdapter3D {
       referencedImageId
     } = metadata;
     if (!referencedImageId) {
-      throw new Error("PlanarFreehandROI.getTID300RepresentationArguments: referencedImageId is not defined");
+      return this.getTID300RepresentationArgumentsSCOORD3D(tool);
     }
     const points = polyline.map(worldPos => worldToImageCoords(referencedImageId, worldPos));
     if (!isOpenContour) {
@@ -99,7 +165,51 @@ class PlanarFreehandROI extends BaseAdapter3D {
       stdDev,
       trackingIdentifierTextValue: this.trackingIdentifierTextValue,
       finding,
-      findingSites: findingSites || []
+      findingSites: findingSites || [],
+      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,
+      areaUnit,
+      modalityUnit,
+      perimeter,
+      mean,
+      max,
+      stdDev
+    } = cachedStatsKeys ? data.cachedStats[cachedStatsKeys] : {};
+    return {
+      points,
+      area,
+      areaUnit,
+      perimeter,
+      modalityUnit,
+      mean,
+      max,
+      stdDev,
+      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
+      finding,
+      findingSites: findingSites || [],
+      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
+      use3DSpatialCoordinates: true
     };
   }
 }

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

@@ -1,20 +1,45 @@
 import BaseAdapter3D from "./BaseAdapter3D";
 declare class Probe extends BaseAdapter3D {
-    static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any, trackingIdentifier: any): {
-        description: any;
-        sopInstanceUid: any;
-        annotation: {
-            annotationUID: any;
-            metadata: {
-                toolName: any;
-                referencedImageId: any;
-                FrameOfReferenceUID: any;
-                label: string;
-            };
-            data: any;
-        };
+    static getMeasurementData(MeasurementGroup: any, sopInstanceUIDToImageIdMap: any, imageToWorldCoords: any, metadata: any, trackingIdentifier: any): any;
+    static getMeasurementDataFromScoord({ state, defaultState, SCOORDGroup, imageToWorldCoords }: {
+        state: any;
+        defaultState: any;
+        SCOORDGroup: any;
+        imageToWorldCoords: any;
+    }): any;
+    static getMeasurementDataFromScoord3D({ state, SCOORD3DGroup }: {
+        state: any;
+        SCOORD3DGroup: any;
+    }): any;
+    static getTID300RepresentationArguments(tool: any, worldToImageCoords: any): {
+        points: {
+            x: any;
+            y: any;
+            z: any;
+        }[];
+        trackingIdentifierTextValue: string;
+        ReferencedFrameOfReferenceUID: any;
+        findingSites: any;
         finding: any;
-        findingSites: any[];
+        use3DSpatialCoordinates: boolean;
+    } | {
+        points: any;
+        trackingIdentifierTextValue: string;
+        findingSites: any;
+        finding: any;
+        use3DSpatialCoordinates: boolean;
+    };
+    static getTID300RepresentationArgumentsSCOORD3D(tool: any): {
+        points: {
+            x: any;
+            y: any;
+            z: any;
+        }[];
+        trackingIdentifierTextValue: string;
+        ReferencedFrameOfReferenceUID: any;
+        findingSites: any;
+        finding: any;
+        use3DSpatialCoordinates: boolean;
     };
 }
 export default Probe;

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

@@ -11,8 +11,32 @@ class Probe extends BaseAdapter3D {
     const state = super.getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, imageToWorldCoords, metadata, trackingIdentifier);
     const {
       defaultState,
-      SCOORDGroup
+      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 getMeasurementDataFromScoord(_ref) {
+    let {
+      state,
+      defaultState,
+      SCOORDGroup,
+      imageToWorldCoords
+    } = _ref;
     const referencedImageId = defaultState.annotation.metadata.referencedImageId;
     const {
       GraphicData
@@ -34,6 +58,93 @@ class Probe extends BaseAdapter3D {
     };
     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);
+    }
+    state.annotation.data = {
+      ...state.annotation.data,
+      handles: {
+        points: worldCoords,
+        activeHandleIndex: null,
+        textBox: {
+          hasMoved: false
+        }
+      }
+    };
+    return state;
+  }
+  static getTID300RepresentationArguments(tool, worldToImageCoords) {
+    const {
+      data,
+      metadata
+    } = tool;
+    const {
+      finding,
+      findingSites
+    } = tool;
+    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]
+      };
+    });
+    return {
+      points: pointsImage,
+      trackingIdentifierTextValue: this.trackingIdentifierTextValue,
+      findingSites: findingSites || [],
+      finding,
+      use3DSpatialCoordinates: false
+    };
+  }
+  static getTID300RepresentationArgumentsSCOORD3D(tool) {
+    const {
+      data,
+      finding,
+      findingSites,
+      metadata
+    } = 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,
+      ReferencedFrameOfReferenceUID: metadata.FrameOfReferenceUID,
+      findingSites: findingSites || [],
+      finding,
+      use3DSpatialCoordinates: true
+    };
+  }
 }
 _Probe = Probe;
 (() => {