@cornerstonejs/adapters 0.2.0 → 0.2.1

package/src/adapters/Cornerstone/EllipticalRoi.js

@@ -1,149 +0,0 @@
-import { utilities } from "dcmjs";
-import MeasurementReport from "./MeasurementReport";
-import CORNERSTONE_4_TAG from "./cornerstone4Tag";
-
-const { Ellipse: TID300Ellipse } = utilities.TID300;
-
-const ELLIPTICALROI = "EllipticalRoi";
-
-class EllipticalRoi {
-    // TODO: this function is required for all Cornerstone Tool Adapters, since it is called by MeasurementReport.
-    static getMeasurementData(MeasurementGroup) {
-        const { defaultState, NUMGroup, SCOORDGroup } =
-            MeasurementReport.getSetupMeasurementData(MeasurementGroup);
-
-        const { GraphicData } = SCOORDGroup;
-
-        const majorAxis = [
-            { x: GraphicData[0], y: GraphicData[1] },
-            { x: GraphicData[2], y: GraphicData[3] }
-        ];
-        const minorAxis = [
-            { x: GraphicData[4], y: GraphicData[5] },
-            { x: GraphicData[6], y: GraphicData[7] }
-        ];
-
-        // Calculate two opposite corners of box defined by two axes.
-
-        const minorAxisLength = Math.sqrt(
-            Math.pow(minorAxis[0].x - minorAxis[1].x, 2) +
-                Math.pow(minorAxis[0].y - minorAxis[1].y, 2)
-        );
-
-        const minorAxisDirection = {
-            x: (minorAxis[1].x - minorAxis[0].x) / minorAxisLength,
-            y: (minorAxis[1].y - minorAxis[0].y) / minorAxisLength
-        };
-
-        const halfMinorAxisLength = minorAxisLength / 2;
-
-        // First end point of major axis + half minor axis vector
-        const corner1 = {
-            x: majorAxis[0].x + minorAxisDirection.x * halfMinorAxisLength,
-            y: majorAxis[0].y + minorAxisDirection.y * halfMinorAxisLength
-        };
-
-        // Second end point of major axis - half of minor axis vector
-        const corner2 = {
-            x: majorAxis[1].x - minorAxisDirection.x * halfMinorAxisLength,
-            y: majorAxis[1].y - minorAxisDirection.y * halfMinorAxisLength
-        };
-        const state = {
-            ...defaultState,
-            toolType: EllipticalRoi.toolType,
-            active: false,
-            cachedStats: {
-                area: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : 0
-            },
-            handles: {
-                end: {
-                    x: corner1.x,
-                    y: corner1.y,
-                    highlight: false,
-                    active: false
-                },
-                initialRotation: 0,
-                start: {
-                    x: corner2.x,
-                    y: corner2.y,
-                    highlight: false,
-                    active: false
-                },
-                textBox: {
-                    hasMoved: false,
-                    movesIndependently: false,
-                    drawnIndependently: true,
-                    allowedOutsideImage: true,
-                    hasBoundingBox: true
-                }
-            },
-            invalidated: true,
-            visible: true
-        };
-
-        return state;
-    }
-
-    static getTID300RepresentationArguments(tool) {
-        const { cachedStats = {}, handles, finding, findingSites } = tool;
-        const { start, end } = handles;
-        const { area } = cachedStats;
-
-        const halfXLength = Math.abs(start.x - end.x) / 2;
-        const halfYLength = Math.abs(start.y - end.y) / 2;
-
-        const points = [];
-
-        const center = { x: (start.x + end.x) / 2, y: (start.y + end.y) / 2 };
-
-        if (halfXLength > halfYLength) {
-            // X-axis major
-            // Major axis
-            points.push({ x: center.x - halfXLength, y: center.y });
-            points.push({ x: center.x + halfXLength, y: center.y });
-            // Minor axis
-            points.push({ x: center.x, y: center.y - halfYLength });
-            points.push({ x: center.x, y: center.y + halfYLength });
-        } else {
-            // Y-axis major
-            // Major axis
-            points.push({ x: center.x, y: center.y - halfYLength });
-            points.push({ x: center.x, y: center.y + halfYLength });
-            // Minor axis
-            points.push({ x: center.x - halfXLength, y: center.y });
-            points.push({ x: center.x + halfXLength, y: center.y });
-        }
-
-        const trackingIdentifierTextValue =
-            "cornerstoneTools@^4.0.0:EllipticalRoi";
-
-        return {
-            area,
-            points,
-            trackingIdentifierTextValue,
-            finding,
-            findingSites: findingSites || []
-        };
-    }
-}
-
-EllipticalRoi.toolType = ELLIPTICALROI;
-EllipticalRoi.utilityToolType = ELLIPTICALROI;
-EllipticalRoi.TID300Representation = TID300Ellipse;
-EllipticalRoi.isValidCornerstoneTrackingIdentifier = TrackingIdentifier => {
-    if (!TrackingIdentifier.includes(":")) {
-        return false;
-    }
-
-    const [cornerstone4Tag, toolType] = TrackingIdentifier.split(":");
-
-    if (cornerstone4Tag !== CORNERSTONE_4_TAG) {
-        return false;
-    }
-
-    return toolType === ELLIPTICALROI;
-};
-
-MeasurementReport.registerTool(EllipticalRoi);
-
-export default EllipticalRoi;

package/src/adapters/Cornerstone/FreehandRoi.js

@@ -1,82 +0,0 @@
-import { utilities } from "dcmjs";
-
-import MeasurementReport from "./MeasurementReport";
-import CORNERSTONE_4_TAG from "./cornerstone4Tag";
-
-const { Polyline: TID300Polyline } = utilities.TID300;
-
-class FreehandRoi {
-    static getMeasurementData(MeasurementGroup) {
-        const { defaultState, SCOORDGroup, NUMGroup } =
-            MeasurementReport.getSetupMeasurementData(MeasurementGroup);
-
-        const state = {
-            ...defaultState,
-            toolType: FreehandRoi.toolType,
-            handles: {
-                points: [],
-                textBox: {
-                    active: false,
-                    hasMoved: false,
-                    movesIndependently: false,
-                    drawnIndependently: true,
-                    allowedOutsideImage: true,
-                    hasBoundingBox: true
-                }
-            },
-            cachedStats: {
-                area: NUMGroup ? NUMGroup.MeasuredValueSequence.NumericValue : 0
-            },
-            color: undefined,
-            invalidated: true
-        };
-        const { GraphicData } = SCOORDGroup;
-        for (let i = 0; i < GraphicData.length; i += 2) {
-            state.handles.points.push({
-                x: GraphicData[i],
-                y: GraphicData[i + 1]
-            });
-        }
-
-        return state;
-    }
-
-    static getTID300RepresentationArguments(tool) {
-        const { handles, finding, findingSites, cachedStats = {} } = tool;
-        const { points } = handles;
-        const { area = 0, perimeter = 0 } = cachedStats;
-
-        const trackingIdentifierTextValue =
-            "cornerstoneTools@^4.0.0:FreehandRoi";
-
-        return {
-            points,
-            area,
-            perimeter,
-            trackingIdentifierTextValue,
-            finding,
-            findingSites: findingSites || []
-        };
-    }
-}
-
-FreehandRoi.toolType = "FreehandRoi";
-FreehandRoi.utilityToolType = "FreehandRoi";
-FreehandRoi.TID300Representation = TID300Polyline;
-FreehandRoi.isValidCornerstoneTrackingIdentifier = TrackingIdentifier => {
-    if (!TrackingIdentifier.includes(":")) {
-        return false;
-    }
-
-    const [cornerstone4Tag, toolType] = TrackingIdentifier.split(":");
-
-    if (cornerstone4Tag !== CORNERSTONE_4_TAG) {
-        return false;
-    }
-
-    return toolType === FreehandRoi.toolType;
-};
-
-MeasurementReport.registerTool(FreehandRoi);
-
-export default FreehandRoi;

package/src/adapters/Cornerstone/Length.js

@@ -1,80 +0,0 @@
-import { utilities } from "dcmjs";
-import MeasurementReport from "./MeasurementReport";
-import CORNERSTONE_4_TAG from "./cornerstone4Tag";
-
-const { Length: TID300Length } = utilities.TID300;
-
-const LENGTH = "Length";
-
-class Length {
-    // TODO: this function is required for all Cornerstone Tool Adapters, since it is called by MeasurementReport.
-    static getMeasurementData(MeasurementGroup) {
-        const { defaultState, NUMGroup, SCOORDGroup } =
-            MeasurementReport.getSetupMeasurementData(MeasurementGroup);
-
-        const state = {
-            ...defaultState,
-            length: NUMGroup.MeasuredValueSequence.NumericValue,
-            toolType: Length.toolType,
-            handles: {
-                start: {},
-                end: {},
-                textBox: {
-                    hasMoved: false,
-                    movesIndependently: false,
-                    drawnIndependently: true,
-                    allowedOutsideImage: true,
-                    hasBoundingBox: true
-                }
-            }
-        };
-
-        [
-            state.handles.start.x,
-            state.handles.start.y,
-            state.handles.end.x,
-            state.handles.end.y
-        ] = SCOORDGroup.GraphicData;
-
-        return state;
-    }
-
-    static getTID300RepresentationArguments(tool) {
-        const { handles, finding, findingSites } = tool;
-        const point1 = handles.start;
-        const point2 = handles.end;
-        const distance = tool.length;
-
-        const trackingIdentifierTextValue = "cornerstoneTools@^4.0.0:Length";
-
-        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 [cornerstone4Tag, toolType] = TrackingIdentifier.split(":");
-
-    if (cornerstone4Tag !== CORNERSTONE_4_TAG) {
-        return false;
-    }
-
-    return toolType === LENGTH;
-};
-
-MeasurementReport.registerTool(Length);
-
-export default Length;

package/src/adapters/Cornerstone/MeasurementReport.js

@@ -1,352 +0,0 @@
-import { normalizers, data, utilities, derivations } from "dcmjs";
-
-import { toArray, codeMeaningEquals } from "../helpers";
-
-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
-) {
-    const args = toolClass.getTID300RepresentationArguments(tool);
-    args.ReferencedSOPSequence = ReferencedSOPSequence;
-
-    const TID300Measurement = new toolClass.TID300Representation(args);
-
-    return TID300Measurement;
-}
-
-function getMeasurementGroup(toolType, toolData, ReferencedSOPSequence) {
-    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
-        );
-    });
-
-    return new TID1501MeasurementGroup(Measurements);
-}
-
-export default class MeasurementReport {
-    static getSetupMeasurementData(MeasurementGroup) {
-        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 defaultState = {
-            sopInstanceUid: ReferencedSOPInstanceUID,
-            frameIndex: ReferencedFrameNumber || 1,
-            complete: true,
-            finding: findingGroup
-                ? addAccessors(findingGroup.ConceptCodeSequence)
-                : undefined,
-            findingSites: findingSiteGroups.map(fsg => {
-                return addAccessors(fsg.ConceptCodeSequence);
-            })
-        };
-        if (defaultState.finding) {
-            defaultState.description = defaultState.finding.CodeMeaning;
-        }
-        const findingSite =
-            defaultState.findingSites && defaultState.findingSites[0];
-        if (findingSite) {
-            defaultState.location =
-                (findingSite[0] && findingSite[0].CodeMeaning) ||
-                findingSite.CodeMeaning;
-        }
-        return {
-            defaultState,
-            findingGroup,
-            findingSiteGroups,
-            NUMGroup,
-            SCOORDGroup,
-            ReferencedSOPSequence,
-            ReferencedSOPInstanceUID,
-            ReferencedFrameNumber
-        };
-    }
-
-    static generateReport(toolState, metadataProvider, options) {
-        // ToolState for array of imageIDs to a Report
-        // Assume Cornerstone metadata provider has access to Study / Series / Sop Instance UID
-
-        let allMeasurementGroups = [];
-        const firstImageId = Object.keys(toolState)[0];
-        if (!firstImageId) {
-            throw new Error("No measurements provided.");
-        }
-
-        /* 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 generalSeriesModule = metadataProvider.get(
-            "generalSeriesModule",
-            firstImageId
-        );
-
-        //const sopCommonModule = metadataProvider.get('sopCommonModule', firstImageId);
-
-        // NOTE: We are getting the Series and Study UIDs from the first imageId of the toolState
-        // which means that if the toolState is for multiple series, the report will have the incorrect
-        // SeriesInstanceUIDs
-        const { studyInstanceUID, seriesInstanceUID } = generalSeriesModule;
-
-        // Loop through each image in the toolData
-        Object.keys(toolState).forEach(imageId => {
-            const sopCommonModule = metadataProvider.get(
-                "sopCommonModule",
-                imageId
-            );
-            const frameNumber = metadataProvider.get("frameNumber", imageId);
-            const toolData = toolState[imageId];
-            const toolTypes = Object.keys(toolData);
-
-            const ReferencedSOPSequence = {
-                ReferencedSOPClassUID: sopCommonModule.sopClassUID,
-                ReferencedSOPInstanceUID: sopCommonModule.sopInstanceUID
-            };
-
-            if (
-                Normalizer.isMultiframeSOPClassUID(sopCommonModule.sopClassUID)
-            ) {
-                ReferencedSOPSequence.ReferencedFrameNumber = frameNumber;
-            }
-
-            // Loop through each tool type for the image
-            const measurementGroups = [];
-
-            toolTypes.forEach(toolType => {
-                const group = getMeasurementGroup(
-                    toolType,
-                    toolData,
-                    ReferencedSOPSequence
-                );
-                if (group) {
-                    measurementGroups.push(group);
-                }
-            });
-
-            allMeasurementGroups =
-                allMeasurementGroups.concat(measurementGroups);
-        });
-
-        const MeasurementReport = new TID1500MeasurementReport(
-            { TID1501MeasurementGroups: allMeasurementGroups },
-            options
-        );
-
-        // 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 derivationSourceDataset = {
-            StudyInstanceUID: studyInstanceUID,
-            SeriesInstanceUID: seriesInstanceUID
-            //SOPInstanceUID: sopInstanceUID, // TODO: Necessary?
-            //SOPClassUID: sopClassUID,
-        };
-
-        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"
-            }
-        };
-
-        const _vrMap = {
-            PixelData: "OW"
-        };
-
-        derivationSourceDataset._meta = _meta;
-        derivationSourceDataset._vrMap = _vrMap;
-
-        const report = new StructuredReport([derivationSourceDataset]);
-
-        const contentItem = MeasurementReport.contentItem(
-            derivationSourceDataset
-        );
-
-        // 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, 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);
-
-                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 = {};