@cornerstonejs/adapters 0.1.2 → 0.1.4

package/src/adapters/Cornerstone3D/Length.js

@@ -0,0 +1,113 @@
+import { utilities } from "dcmjs";
+import CORNERSTONE_3D_TAG from "./cornerstone3DTag";
+import MeasurementReport from "./MeasurementReport";
+
+const { Length: TID300Length } = utilities.TID300;
+
+const LENGTH = "Length";
+const trackingIdentifierTextValue = `${CORNERSTONE_3D_TAG}:${LENGTH}`;
+
+class Length {
+    // TODO: this function is required for all Cornerstone Tool Adapters, since it is called by MeasurementReport.
+    static getMeasurementData(
+        MeasurementGroup,
+        sopInstanceUIDToImageIdMap,
+        imageToWorldCoords,
+        metadata
+    ) {
+        const { defaultState, NUMGroup, SCOORDGroup, ReferencedFrameNumber } =
+            MeasurementReport.getSetupMeasurementData(
+                MeasurementGroup,
+                sopInstanceUIDToImageIdMap,
+                metadata,
+                Length.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;
+
+        state.annotation.data = {
+            handles: {
+                points: [worldCoords[0], worldCoords[1]],
+                activeHandleIndex: 0,
+                textBox: {
+                    hasMoved: false
+                }
+            },
+            cachedStats: {
+                [`imageId:${referencedImageId}`]: {
+                    length: NUMGroup
+                        ? NUMGroup.MeasuredValueSequence.NumericValue
+                        : 0
+                }
+            },
+            frameNumber: ReferencedFrameNumber
+        };
+
+        return state;
+    }
+
+    static getTID300RepresentationArguments(tool, worldToImageCoords) {
+        const { data, finding, findingSites, metadata } = tool;
+        const { cachedStats = {}, handles } = data;
+
+        const { referencedImageId } = metadata;
+
+        if (!referencedImageId) {
+            throw new Error(
+                "Length.getTID300RepresentationArguments: referencedImageId is not defined"
+            );
+        }
+
+        const start = worldToImageCoords(referencedImageId, handles.points[0]);
+        const end = worldToImageCoords(referencedImageId, handles.points[1]);
+
+        const point1 = { x: start[0], y: start[1] };
+        const point2 = { x: end[0], y: end[1] };
+
+        const { length: distance } =
+            cachedStats[`imageId:${referencedImageId}`] || {};
+
+        return {
+            point1,
+            point2,
+            distance,
+            trackingIdentifierTextValue,
+            finding,
+            findingSites: findingSites || []
+        };
+    }
+}
+
+Length.toolType = LENGTH;
+Length.utilityToolType = LENGTH;
+Length.TID300Representation = TID300Length;
+Length.isValidCornerstoneTrackingIdentifier = TrackingIdentifier => {
+    if (!TrackingIdentifier.includes(":")) {
+        return false;
+    }
+
+    const [cornerstone3DTag, toolType] = TrackingIdentifier.split(":");
+
+    if (cornerstone3DTag !== CORNERSTONE_3D_TAG) {
+        return false;
+    }
+
+    return toolType === LENGTH;
+};
+
+MeasurementReport.registerTool(Length);
+
+export default Length;

package/src/adapters/Cornerstone3D/MeasurementReport.js

@@ -0,0 +1,445 @@
+import { normalizers, data, utilities, derivations } from "dcmjs";
+
+import { toArray, codeMeaningEquals } from "../helpers";
+import Cornerstone3DCodingScheme from "./CodingScheme";
+
+const { TID1500, addAccessors } = utilities;
+
+const { StructuredReport } = derivations;
+
+const { Normalizer } = normalizers;
+
+const { TID1500MeasurementReport, TID1501MeasurementGroup } = TID1500;
+
+const { DicomMetaDictionary } = data;
+
+const FINDING = { CodingSchemeDesignator: "DCM", CodeValue: "121071" };
+const FINDING_SITE = { CodingSchemeDesignator: "SCT", CodeValue: "363698007" };
+const FINDING_SITE_OLD = { CodingSchemeDesignator: "SRT", CodeValue: "G-C0E3" };
+
+const codeValueMatch = (group, code, oldCode) => {
+    const { ConceptNameCodeSequence } = group;
+    if (!ConceptNameCodeSequence) return;
+    const { CodingSchemeDesignator, CodeValue } = ConceptNameCodeSequence;
+    return (
+        (CodingSchemeDesignator == code.CodingSchemeDesignator &&
+            CodeValue == code.CodeValue) ||
+        (oldCode &&
+            CodingSchemeDesignator == oldCode.CodingSchemeDesignator &&
+            CodeValue == oldCode.CodeValue)
+    );
+};
+
+function getTID300ContentItem(
+    tool,
+    toolType,
+    ReferencedSOPSequence,
+    toolClass,
+    worldToImageCoords
+) {
+    const args = toolClass.getTID300RepresentationArguments(
+        tool,
+        worldToImageCoords
+    );
+    args.ReferencedSOPSequence = ReferencedSOPSequence;
+
+    const TID300Measurement = new toolClass.TID300Representation(args);
+
+    return TID300Measurement;
+}
+
+function getMeasurementGroup(
+    toolType,
+    toolData,
+    ReferencedSOPSequence,
+    worldToImageCoords
+) {
+    const toolTypeData = toolData[toolType];
+    const toolClass =
+        MeasurementReport.CORNERSTONE_TOOL_CLASSES_BY_TOOL_TYPE[toolType];
+    if (
+        !toolTypeData ||
+        !toolTypeData.data ||
+        !toolTypeData.data.length ||
+        !toolClass
+    ) {
+        return;
+    }
+
+    // Loop through the array of tool instances
+    // for this tool
+    const Measurements = toolTypeData.data.map(tool => {
+        return getTID300ContentItem(
+            tool,
+            toolType,
+            ReferencedSOPSequence,
+            toolClass,
+            worldToImageCoords
+        );
+    });
+
+    return new TID1501MeasurementGroup(Measurements);
+}
+
+export default class MeasurementReport {
+    static getCornerstoneLabelFromDefaultState(defaultState) {
+        const { findingSites = [], finding } = defaultState;
+
+        const cornersoneFreeTextCodingValue =
+            Cornerstone3DCodingScheme.codeValues.CORNERSTONEFREETEXT;
+
+        let freeTextLabel = findingSites.find(
+            fs => fs.CodeValue === cornersoneFreeTextCodingValue
+        );
+
+        if (freeTextLabel) {
+            return freeTextLabel.CodeMeaning;
+        }
+
+        if (finding && finding.CodeValue === cornersoneFreeTextCodingValue) {
+            return finding.CodeMeaning;
+        }
+    }
+
+    static generateDatasetMeta() {
+        // TODO: what is the correct metaheader
+        // http://dicom.nema.org/medical/Dicom/current/output/chtml/part10/chapter_7.html
+        // TODO: move meta creation to happen in derivations.js
+        const fileMetaInformationVersionArray = new Uint8Array(2);
+        fileMetaInformationVersionArray[1] = 1;
+
+        const _meta = {
+            FileMetaInformationVersion: {
+                Value: [fileMetaInformationVersionArray.buffer],
+                vr: "OB"
+            },
+            //MediaStorageSOPClassUID
+            //MediaStorageSOPInstanceUID: sopCommonModule.sopInstanceUID,
+            TransferSyntaxUID: {
+                Value: ["1.2.840.10008.1.2.1"],
+                vr: "UI"
+            },
+            ImplementationClassUID: {
+                Value: [DicomMetaDictionary.uid()], // TODO: could be git hash or other valid id
+                vr: "UI"
+            },
+            ImplementationVersionName: {
+                Value: ["dcmjs"],
+                vr: "SH"
+            }
+        };
+
+        return _meta;
+    }
+
+    static generateDerivationSourceDataset(
+        StudyInstanceUID,
+        SeriesInstanceUID
+    ) {
+        const _vrMap = {
+            PixelData: "OW"
+        };
+
+        const _meta = MeasurementReport.generateDatasetMeta();
+
+        const derivationSourceDataset = {
+            StudyInstanceUID,
+            SeriesInstanceUID,
+            _meta: _meta,
+            _vrMap: _vrMap
+        };
+
+        return derivationSourceDataset;
+    }
+
+    static getSetupMeasurementData(
+        MeasurementGroup,
+        sopInstanceUIDToImageIdMap,
+        metadata,
+        toolType
+    ) {
+        const { ContentSequence } = MeasurementGroup;
+
+        const contentSequenceArr = toArray(ContentSequence);
+        const findingGroup = contentSequenceArr.find(group =>
+            codeValueMatch(group, FINDING)
+        );
+        const findingSiteGroups =
+            contentSequenceArr.filter(group =>
+                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"
+        );
+        const { ReferencedSOPSequence } = SCOORDGroup.ContentSequence;
+        const { ReferencedSOPInstanceUID, ReferencedFrameNumber } =
+            ReferencedSOPSequence;
+
+        const referencedImageId =
+            sopInstanceUIDToImageIdMap[ReferencedSOPInstanceUID];
+        const imagePlaneModule = metadata.get(
+            "imagePlaneModule",
+            referencedImageId
+        );
+
+        const finding = findingGroup
+            ? addAccessors(findingGroup.ConceptCodeSequence)
+            : undefined;
+        const findingSites = findingSiteGroups.map(fsg => {
+            return addAccessors(fsg.ConceptCodeSequence);
+        });
+
+        const defaultState = {
+            sopInstanceUid: ReferencedSOPInstanceUID,
+            annotation: {
+                annotationUID: DicomMetaDictionary.uid(),
+                metadata: {
+                    toolName: toolType,
+                    referencedImageId,
+                    FrameOfReferenceUID: imagePlaneModule.frameOfReferenceUID,
+                    label: ""
+                }
+            },
+            finding,
+            findingSites
+        };
+        if (defaultState.finding) {
+            defaultState.description = defaultState.finding.CodeMeaning;
+        }
+
+        defaultState.annotation.metadata.label =
+            MeasurementReport.getCornerstoneLabelFromDefaultState(defaultState);
+
+        return {
+            defaultState,
+            NUMGroup,
+            SCOORDGroup,
+            ReferencedSOPSequence,
+            ReferencedSOPInstanceUID,
+            ReferencedFrameNumber
+        };
+    }
+
+    static generateReport(
+        toolState,
+        metadataProvider,
+        worldToImageCoords,
+        options
+    ) {
+        // ToolState for array of imageIDs to a Report
+        // Assume Cornerstone metadata provider has access to Study / Series / Sop Instance UID
+        let allMeasurementGroups = [];
+
+        /* Patient ID
+        Warning - Missing attribute or value that would be needed to build DICOMDIR - Patient ID
+        Warning - Missing attribute or value that would be needed to build DICOMDIR - Study Date
+        Warning - Missing attribute or value that would be needed to build DICOMDIR - Study Time
+        Warning - Missing attribute or value that would be needed to build DICOMDIR - Study ID
+        */
+
+        const sopInstanceUIDsToSeriesInstanceUIDMap = {};
+        const derivationSourceDatasets = [];
+
+        const _meta = MeasurementReport.generateDatasetMeta();
+
+        // Loop through each image in the toolData
+        Object.keys(toolState).forEach(imageId => {
+            const sopCommonModule = metadataProvider.get(
+                "sopCommonModule",
+                imageId
+            );
+            const generalSeriesModule = metadataProvider.get(
+                "generalSeriesModule",
+                imageId
+            );
+
+            const { sopInstanceUID, sopClassUID } = sopCommonModule;
+            const { studyInstanceUID, seriesInstanceUID } = generalSeriesModule;
+
+            sopInstanceUIDsToSeriesInstanceUIDMap[sopInstanceUID] =
+                seriesInstanceUID;
+
+            if (
+                !derivationSourceDatasets.find(
+                    dsd => dsd.SeriesInstanceUID === seriesInstanceUID
+                )
+            ) {
+                // Entry not present for series, create one.
+                const derivationSourceDataset =
+                    MeasurementReport.generateDerivationSourceDataset(
+                        studyInstanceUID,
+                        seriesInstanceUID
+                    );
+
+                derivationSourceDatasets.push(derivationSourceDataset);
+            }
+
+            const frameNumber = metadataProvider.get("frameNumber", imageId);
+            const toolData = toolState[imageId];
+            const toolTypes = Object.keys(toolData);
+
+            const ReferencedSOPSequence = {
+                ReferencedSOPClassUID: sopClassUID,
+                ReferencedSOPInstanceUID: sopInstanceUID
+            };
+
+            const instance = metadataProvider.get("instance", imageId);
+            if (
+                (instance &&
+                    instance.NumberOfFrames &&
+                    instance.NumberOfFrames > 1) ||
+                Normalizer.isMultiframeSOPClassUID(sopClassUID)
+            ) {
+                ReferencedSOPSequence.ReferencedFrameNumber = frameNumber;
+            }
+
+            // Loop through each tool type for the image
+            const measurementGroups = [];
+
+            toolTypes.forEach(toolType => {
+                const group = getMeasurementGroup(
+                    toolType,
+                    toolData,
+                    ReferencedSOPSequence,
+                    worldToImageCoords
+                );
+                if (group) {
+                    measurementGroups.push(group);
+                }
+            });
+
+            allMeasurementGroups =
+                allMeasurementGroups.concat(measurementGroups);
+        });
+
+        const tid1500MeasurementReport = new TID1500MeasurementReport(
+            { TID1501MeasurementGroups: allMeasurementGroups },
+            options
+        );
+
+        const report = new StructuredReport(derivationSourceDatasets);
+
+        const contentItem = tid1500MeasurementReport.contentItem(
+            derivationSourceDatasets,
+            { sopInstanceUIDsToSeriesInstanceUIDMap }
+        );
+
+        // Merge the derived dataset with the content from the Measurement Report
+        report.dataset = Object.assign(report.dataset, contentItem);
+        report.dataset._meta = _meta;
+
+        return report;
+    }
+
+    /**
+     * Generate Cornerstone tool state from dataset
+     * @param {object} dataset dataset
+     * @param {object} hooks
+     * @param {function} hooks.getToolClass Function to map dataset to a tool class
+     * @returns
+     */
+    static generateToolState(
+        dataset,
+        sopInstanceUIDToImageIdMap,
+        imageToWorldCoords,
+        metadata,
+        hooks = {}
+    ) {
+        // For now, bail out if the dataset is not a TID1500 SR with length measurements
+        if (dataset.ContentTemplateSequence.TemplateIdentifier !== "1500") {
+            throw new Error(
+                "This package can currently only interpret DICOM SR TID 1500"
+            );
+        }
+
+        const REPORT = "Imaging Measurements";
+        const GROUP = "Measurement Group";
+        const TRACKING_IDENTIFIER = "Tracking Identifier";
+
+        // Identify the Imaging Measurements
+        const imagingMeasurementContent = toArray(dataset.ContentSequence).find(
+            codeMeaningEquals(REPORT)
+        );
+
+        // Retrieve the Measurements themselves
+        const measurementGroups = toArray(
+            imagingMeasurementContent.ContentSequence
+        ).filter(codeMeaningEquals(GROUP));
+
+        // For each of the supported measurement types, compute the measurement data
+        const measurementData = {};
+
+        const cornerstoneToolClasses =
+            MeasurementReport.CORNERSTONE_TOOL_CLASSES_BY_UTILITY_TYPE;
+
+        const registeredToolClasses = [];
+
+        Object.keys(cornerstoneToolClasses).forEach(key => {
+            registeredToolClasses.push(cornerstoneToolClasses[key]);
+            measurementData[key] = [];
+        });
+
+        measurementGroups.forEach(measurementGroup => {
+            const measurementGroupContentSequence = toArray(
+                measurementGroup.ContentSequence
+            );
+
+            const TrackingIdentifierGroup =
+                measurementGroupContentSequence.find(
+                    contentItem =>
+                        contentItem.ConceptNameCodeSequence.CodeMeaning ===
+                        TRACKING_IDENTIFIER
+                );
+
+            const TrackingIdentifierValue = TrackingIdentifierGroup.TextValue;
+
+            const toolClass = hooks.getToolClass
+                ? hooks.getToolClass(
+                      measurementGroup,
+                      dataset,
+                      registeredToolClasses
+                  )
+                : registeredToolClasses.find(tc =>
+                      tc.isValidCornerstoneTrackingIdentifier(
+                          TrackingIdentifierValue
+                      )
+                  );
+
+            if (toolClass) {
+                const measurement = toolClass.getMeasurementData(
+                    measurementGroup,
+                    sopInstanceUIDToImageIdMap,
+                    imageToWorldCoords,
+                    metadata
+                );
+
+                console.log(`=== ${toolClass.toolType} ===`);
+                console.log(measurement);
+
+                measurementData[toolClass.toolType].push(measurement);
+            }
+        });
+
+        // NOTE: There is no way of knowing the cornerstone imageIds as that could be anything.
+        // That is up to the consumer to derive from the SOPInstanceUIDs.
+        return measurementData;
+    }
+
+    static registerTool(toolClass) {
+        MeasurementReport.CORNERSTONE_TOOL_CLASSES_BY_UTILITY_TYPE[
+            toolClass.utilityToolType
+        ] = toolClass;
+        MeasurementReport.CORNERSTONE_TOOL_CLASSES_BY_TOOL_TYPE[
+            toolClass.toolType
+        ] = toolClass;
+        MeasurementReport.MEASUREMENT_BY_TOOLTYPE[toolClass.toolType] =
+            toolClass.utilityToolType;
+    }
+}
+
+MeasurementReport.MEASUREMENT_BY_TOOLTYPE = {};
+MeasurementReport.CORNERSTONE_TOOL_CLASSES_BY_UTILITY_TYPE = {};
+MeasurementReport.CORNERSTONE_TOOL_CLASSES_BY_TOOL_TYPE = {};

package/src/adapters/Cornerstone3D/PlanarFreehandROI.js

@@ -0,0 +1,137 @@
+import MeasurementReport from "./MeasurementReport";
+import { utilities } from "dcmjs";
+import CORNERSTONE_3D_TAG from "./cornerstone3DTag";
+import { vec3 } from "gl-matrix";
+
+const { Polyline: TID300Polyline } = utilities.TID300;
+
+const PLANARFREEHANDROI = "PlanarFreehandROI";
+const trackingIdentifierTextValue = `${CORNERSTONE_3D_TAG}:${PLANARFREEHANDROI}`;
+const closedContourThreshold = 1e-5;
+
+class PlanarFreehandROI {
+    static getMeasurementData(
+        MeasurementGroup,
+        sopInstanceUIDToImageIdMap,
+        imageToWorldCoords,
+        metadata
+    ) {
+        const { defaultState, SCOORDGroup, ReferencedFrameNumber } =
+            MeasurementReport.getSetupMeasurementData(
+                MeasurementGroup,
+                sopInstanceUIDToImageIdMap,
+                metadata,
+                PlanarFreehandROI.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 distanceBetweenFirstAndLastPoint = vec3.distance(
+            worldCoords[worldCoords.length - 1],
+            worldCoords[0]
+        );
+
+        let isOpenContour = true;
+
+        // If the contour is closed, this should have been encoded as exactly the same point, so check for a very small difference.
+        if (distanceBetweenFirstAndLastPoint < closedContourThreshold) {
+            worldCoords.pop(); // Remove the last element which is duplicated.
+
+            isOpenContour = false;
+        }
+
+        let points = [];
+
+        if (isOpenContour) {
+            points.push(worldCoords[0], worldCoords[worldCoords.length - 1]);
+        }
+
+        const state = defaultState;
+
+        state.annotation.data = {
+            polyline: worldCoords,
+            isOpenContour,
+            handles: {
+                points,
+                activeHandleIndex: null,
+                textBox: {
+                    hasMoved: false
+                }
+            },
+            frameNumber: ReferencedFrameNumber
+        };
+
+        return state;
+    }
+
+    static getTID300RepresentationArguments(tool, worldToImageCoords) {
+        const { data, finding, findingSites, metadata } = tool;
+        const { isOpenContour, polyline } = data;
+
+        const { referencedImageId } = metadata;
+
+        if (!referencedImageId) {
+            throw new Error(
+                "PlanarFreehandROI.getTID300RepresentationArguments: referencedImageId is not defined"
+            );
+        }
+
+        const points = polyline.map(worldPos =>
+            worldToImageCoords(referencedImageId, worldPos)
+        );
+
+        if (!isOpenContour) {
+            // Need to repeat the first point at the end of to have an explicitly closed contour.
+            const firstPoint = points[0];
+
+            // Explicitly expand to avoid ciruclar references.
+            points.push([firstPoint[0], firstPoint[1]]);
+        }
+
+        const area = 0; // TODO -> The tool doesn't have these stats yet.
+        const perimeter = 0;
+
+        return {
+            points,
+            area,
+            perimeter,
+            trackingIdentifierTextValue,
+            finding,
+            findingSites: findingSites || []
+        };
+    }
+}
+
+PlanarFreehandROI.toolType = PLANARFREEHANDROI;
+PlanarFreehandROI.utilityToolType = PLANARFREEHANDROI;
+PlanarFreehandROI.TID300Representation = TID300Polyline;
+PlanarFreehandROI.isValidCornerstoneTrackingIdentifier = TrackingIdentifier => {
+    if (!TrackingIdentifier.includes(":")) {
+        return false;
+    }
+
+    const [cornerstone3DTag, toolType] = TrackingIdentifier.split(":");
+
+    if (cornerstone3DTag !== CORNERSTONE_3D_TAG) {
+        return false;
+    }
+
+    return toolType === PLANARFREEHANDROI;
+};
+
+MeasurementReport.registerTool(PlanarFreehandROI);
+
+export default PlanarFreehandROI;