@cornerstonejs/adapters 0.2.0 → 0.2.1

package/src/adapters/Cornerstone/cornerstone4Tag.js

@@ -1 +0,0 @@
-export default "cornerstoneTools@^4.0.0";

package/src/adapters/Cornerstone/index.js

@@ -1,27 +0,0 @@
-import MeasurementReport from "./MeasurementReport";
-import Length from "./Length";
-import FreehandRoi from "./FreehandRoi";
-import Bidirectional from "./Bidirectional";
-import EllipticalRoi from "./EllipticalRoi";
-import CircleRoi from "./CircleRoi";
-import ArrowAnnotate from "./ArrowAnnotate";
-import Segmentation from "./Segmentation";
-import CobbAngle from "./CobbAngle";
-import Angle from "./Angle";
-import RectangleRoi from "./RectangleRoi";
-
-const Cornerstone = {
-    Length,
-    FreehandRoi,
-    Bidirectional,
-    EllipticalRoi,
-    CircleRoi,
-    ArrowAnnotate,
-    MeasurementReport,
-    Segmentation,
-    CobbAngle,
-    Angle,
-    RectangleRoi
-};
-
-export default Cornerstone;

package/src/adapters/Cornerstone3D/ArrowAnnotate.js

@@ -1,155 +0,0 @@
-import MeasurementReport from "./MeasurementReport";
-import { utilities } from "dcmjs";
-import CORNERSTONE_3D_TAG from "./cornerstone3DTag";
-import CodingScheme from "./CodingScheme";
-
-const { Point: TID300Point } = utilities.TID300;
-
-const ARROW_ANNOTATE = "ArrowAnnotate";
-const trackingIdentifierTextValue = `${CORNERSTONE_3D_TAG}:${ARROW_ANNOTATE}`;
-
-const { codeValues, CodingSchemeDesignator } = CodingScheme;
-
-class ArrowAnnotate {
-    static getMeasurementData(
-        MeasurementGroup,
-        sopInstanceUIDToImageIdMap,
-        imageToWorldCoords,
-        metadata
-    ) {
-        const { defaultState, SCOORDGroup, ReferencedFrameNumber } =
-            MeasurementReport.getSetupMeasurementData(
-                MeasurementGroup,
-                sopInstanceUIDToImageIdMap,
-                metadata,
-                ArrowAnnotate.toolType
-            );
-
-        const referencedImageId =
-            defaultState.annotation.metadata.referencedImageId;
-
-        const text = defaultState.annotation.metadata.label;
-
-        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);
-        }
-
-        // Since the arrowAnnotate measurement is just a point, to generate the tool state
-        // we derive the second point based on the image size relative to the first point.
-        if (worldCoords.length === 1) {
-            const imagePixelModule = metadata.get(
-                "imagePixelModule",
-                referencedImageId
-            );
-
-            let xOffset = 10;
-            let yOffset = 10;
-
-            if (imagePixelModule) {
-                const { columns, rows } = imagePixelModule;
-                xOffset = columns / 10;
-                yOffset = rows / 10;
-            }
-
-            const secondPoint = imageToWorldCoords(referencedImageId, [
-                GraphicData[0] + xOffset,
-                GraphicData[1] + yOffset
-            ]);
-
-            worldCoords.push(secondPoint);
-        }
-
-        const state = defaultState;
-
-        state.annotation.data = {
-            text,
-            handles: {
-                arrowFirst: true,
-                points: [worldCoords[0], worldCoords[1]],
-                activeHandleIndex: 0,
-                textBox: {
-                    hasMoved: false
-                }
-            },
-            frameNumber: ReferencedFrameNumber
-        };
-
-        return state;
-    }
-
-    static getTID300RepresentationArguments(tool, worldToImageCoords) {
-        const { data, metadata } = tool;
-        let { finding, findingSites } = tool;
-        const { referencedImageId } = metadata;
-
-        if (!referencedImageId) {
-            throw new Error(
-                "ArrowAnnotate.getTID300RepresentationArguments: referencedImageId is not defined"
-            );
-        }
-
-        const { points, arrowFirst } = data.handles;
-
-        let point;
-
-        if (arrowFirst) {
-            point = points[0];
-        } else {
-            point = points[1];
-        }
-
-        const pointImage = worldToImageCoords(referencedImageId, point);
-
-        const TID300RepresentationArguments = {
-            points: [
-                {
-                    x: pointImage[0],
-                    y: pointImage[1]
-                }
-            ],
-            trackingIdentifierTextValue,
-            findingSites: findingSites || []
-        };
-
-        // If freetext finding isn't present, add it from the tool text.
-        if (!finding || finding.CodeValue !== codeValues.CORNERSTONEFREETEXT) {
-            finding = {
-                CodeValue: codeValues.CORNERSTONEFREETEXT,
-                CodingSchemeDesignator,
-                CodeMeaning: data.text
-            };
-        }
-
-        TID300RepresentationArguments.finding = finding;
-
-        return TID300RepresentationArguments;
-    }
-}
-
-ArrowAnnotate.toolType = ARROW_ANNOTATE;
-ArrowAnnotate.utilityToolType = ARROW_ANNOTATE;
-ArrowAnnotate.TID300Representation = TID300Point;
-ArrowAnnotate.isValidCornerstoneTrackingIdentifier = TrackingIdentifier => {
-    if (!TrackingIdentifier.includes(":")) {
-        return false;
-    }
-
-    const [cornerstone3DTag, toolType] = TrackingIdentifier.split(":");
-
-    if (cornerstone3DTag !== CORNERSTONE_3D_TAG) {
-        return false;
-    }
-
-    return toolType === ARROW_ANNOTATE;
-};
-
-MeasurementReport.registerTool(ArrowAnnotate);
-
-export default ArrowAnnotate;

package/src/adapters/Cornerstone3D/Bidirectional.js

@@ -1,196 +0,0 @@
-import { utilities } from "dcmjs";
-import CORNERSTONE_3D_TAG from "./cornerstone3DTag";
-import MeasurementReport from "./MeasurementReport";
-import { toArray } from "../helpers";
-
-const { Bidirectional: TID300Bidirectional } = utilities.TID300;
-
-const BIDIRECTIONAL = "Bidirectional";
-const LONG_AXIS = "Long Axis";
-const SHORT_AXIS = "Short Axis";
-const trackingIdentifierTextValue = `${CORNERSTONE_3D_TAG}:${BIDIRECTIONAL}`;
-
-class Bidirectional {
-    static getMeasurementData(
-        MeasurementGroup,
-        sopInstanceUIDToImageIdMap,
-        imageToWorldCoords,
-        metadata
-    ) {
-        const { defaultState, ReferencedFrameNumber } =
-            MeasurementReport.getSetupMeasurementData(
-                MeasurementGroup,
-                sopInstanceUIDToImageIdMap,
-                metadata,
-                Bidirectional.toolType
-            );
-
-        const referencedImageId =
-            defaultState.annotation.metadata.referencedImageId;
-        const { ContentSequence } = MeasurementGroup;
-
-        const longAxisNUMGroup = toArray(ContentSequence).find(
-            group => group.ConceptNameCodeSequence.CodeMeaning === LONG_AXIS
-        );
-
-        const longAxisSCOORDGroup = toArray(
-            longAxisNUMGroup.ContentSequence
-        ).find(group => group.ValueType === "SCOORD");
-
-        const shortAxisNUMGroup = toArray(ContentSequence).find(
-            group => group.ConceptNameCodeSequence.CodeMeaning === SHORT_AXIS
-        );
-
-        const shortAxisSCOORDGroup = toArray(
-            shortAxisNUMGroup.ContentSequence
-        ).find(group => group.ValueType === "SCOORD");
-
-        const worldCoords = [];
-
-        [longAxisSCOORDGroup, shortAxisSCOORDGroup].forEach(group => {
-            const { GraphicData } = group;
-            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],
-                    worldCoords[2],
-                    worldCoords[3]
-                ],
-                activeHandleIndex: 0,
-                textBox: {
-                    hasMoved: false
-                }
-            },
-            cachedStats: {
-                [`imageId:${referencedImageId}`]: {
-                    length: longAxisNUMGroup.MeasuredValueSequence.NumericValue,
-                    width: shortAxisNUMGroup.MeasuredValueSequence.NumericValue
-                }
-            },
-            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(
-                "Bidirectional.getTID300RepresentationArguments: referencedImageId is not defined"
-            );
-        }
-
-        const { length, width } =
-            cachedStats[`imageId:${referencedImageId}`] || {};
-        const { points } = handles;
-
-        // Find the length and width point pairs by comparing the distances of the points at 0,1 to points at 2,3
-        let firstPointPairs = [points[0], points[1]];
-        let secondPointPairs = [points[2], points[3]];
-
-        let firstPointPairsDistance = Math.sqrt(
-            Math.pow(firstPointPairs[0][0] - firstPointPairs[1][0], 2) +
-                Math.pow(firstPointPairs[0][1] - firstPointPairs[1][1], 2) +
-                Math.pow(firstPointPairs[0][2] - firstPointPairs[1][2], 2)
-        );
-
-        let secondPointPairsDistance = Math.sqrt(
-            Math.pow(secondPointPairs[0][0] - secondPointPairs[1][0], 2) +
-                Math.pow(secondPointPairs[0][1] - secondPointPairs[1][1], 2) +
-                Math.pow(secondPointPairs[0][2] - secondPointPairs[1][2], 2)
-        );
-
-        let shortAxisPoints;
-        let longAxisPoints;
-        if (firstPointPairsDistance > secondPointPairsDistance) {
-            shortAxisPoints = firstPointPairs;
-            longAxisPoints = secondPointPairs;
-        } else {
-            shortAxisPoints = secondPointPairs;
-            longAxisPoints = firstPointPairs;
-        }
-
-        const longAxisStartImage = worldToImageCoords(
-            referencedImageId,
-            shortAxisPoints[0]
-        );
-        const longAxisEndImage = worldToImageCoords(
-            referencedImageId,
-            shortAxisPoints[1]
-        );
-        const shortAxisStartImage = worldToImageCoords(
-            referencedImageId,
-            longAxisPoints[0]
-        );
-        const shortAxisEndImage = worldToImageCoords(
-            referencedImageId,
-            longAxisPoints[1]
-        );
-
-        return {
-            longAxis: {
-                point1: {
-                    x: longAxisStartImage[0],
-                    y: longAxisStartImage[1]
-                },
-                point2: {
-                    x: longAxisEndImage[0],
-                    y: longAxisEndImage[1]
-                }
-            },
-            shortAxis: {
-                point1: {
-                    x: shortAxisStartImage[0],
-                    y: shortAxisStartImage[1]
-                },
-                point2: {
-                    x: shortAxisEndImage[0],
-                    y: shortAxisEndImage[1]
-                }
-            },
-            longAxisLength: length,
-            shortAxisLength: width,
-            trackingIdentifierTextValue,
-            finding: finding,
-            findingSites: findingSites || []
-        };
-    }
-}
-
-Bidirectional.toolType = BIDIRECTIONAL;
-Bidirectional.utilityToolType = BIDIRECTIONAL;
-Bidirectional.TID300Representation = TID300Bidirectional;
-Bidirectional.isValidCornerstoneTrackingIdentifier = TrackingIdentifier => {
-    if (!TrackingIdentifier.includes(":")) {
-        return false;
-    }
-
-    const [cornerstone3DTag, toolType] = TrackingIdentifier.split(":");
-
-    if (cornerstone3DTag !== CORNERSTONE_3D_TAG) {
-        return false;
-    }
-
-    return toolType === BIDIRECTIONAL;
-};
-
-MeasurementReport.registerTool(Bidirectional);
-
-export default Bidirectional;

package/src/adapters/Cornerstone3D/CobbAngle.js

@@ -1,125 +0,0 @@
-import { utilities } from "dcmjs";
-import CORNERSTONE_3D_TAG from "./cornerstone3DTag";
-import MeasurementReport from "./MeasurementReport";
-
-const { CobbAngle: TID300CobbAngle } = utilities.TID300;
-
-const MEASUREMENT_TYPE = "CobbAngle";
-const trackingIdentifierTextValue = `${CORNERSTONE_3D_TAG}:${MEASUREMENT_TYPE}`;
-
-class CobbAngle {
-    // 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,
-                CobbAngle.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],
-                    worldCoords[2],
-                    worldCoords[3]
-                ],
-                activeHandleIndex: 0,
-                textBox: {
-                    hasMoved: false
-                }
-            },
-            cachedStats: {
-                [`imageId:${referencedImageId}`]: {
-                    angle: NUMGroup
-                        ? NUMGroup.MeasuredValueSequence.NumericValue
-                        : null
-                }
-            },
-            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(
-                "CobbAngle.getTID300RepresentationArguments: referencedImageId is not defined"
-            );
-        }
-
-        const start1 = worldToImageCoords(referencedImageId, handles.points[0]);
-        const end1 = worldToImageCoords(referencedImageId, handles.points[1]);
-
-        const start2 = worldToImageCoords(referencedImageId, handles.points[2]);
-        const end2 = worldToImageCoords(referencedImageId, handles.points[3]);
-
-        const point1 = { x: start1[0], y: start1[1] };
-        const point2 = { x: end1[0], y: end1[1] };
-        const point3 = { x: start2[0], y: start2[1] };
-        const point4 = { x: end2[0], y: end2[1] };
-
-        const { angle } = cachedStats[`imageId:${referencedImageId}`] || {};
-
-        return {
-            point1,
-            point2,
-            point3,
-            point4,
-            rAngle: angle,
-            trackingIdentifierTextValue,
-            finding,
-            findingSites: findingSites || []
-        };
-    }
-}
-
-CobbAngle.toolType = MEASUREMENT_TYPE;
-CobbAngle.utilityToolType = MEASUREMENT_TYPE;
-console.log("TID300CobbAngle=", TID300CobbAngle);
-CobbAngle.TID300Representation = TID300CobbAngle;
-CobbAngle.isValidCornerstoneTrackingIdentifier = TrackingIdentifier => {
-    if (!TrackingIdentifier.includes(":")) {
-        return false;
-    }
-
-    const [cornerstone3DTag, toolType] = TrackingIdentifier.split(":");
-
-    if (cornerstone3DTag !== CORNERSTONE_3D_TAG) {
-        return false;
-    }
-
-    return toolType === MEASUREMENT_TYPE;
-};
-
-MeasurementReport.registerTool(CobbAngle);
-
-export default CobbAngle;

package/src/adapters/Cornerstone3D/CodingScheme.js

@@ -1,16 +0,0 @@
-// This is a custom coding scheme defined to store some annotations from Cornerstone.
-// Note: CodeMeaning is VR type LO, which means we only actually support 64 characters
-// here this is fine for most labels, but may be problematic at some point.
-const CORNERSTONEFREETEXT = "CORNERSTONEFREETEXT";
-
-// Cornerstone specified coding scheme for storing findings
-const CodingSchemeDesignator = "CORNERSTONEJS";
-
-const CodingScheme = {
-    CodingSchemeDesignator,
-    codeValues: {
-        CORNERSTONEFREETEXT
-    }
-};
-
-export default CodingScheme;