@cornerstonejs/adapters 0.1.5 → 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/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;

package/src/adapters/Cornerstone3D/EllipticalROI.js

@@ -1,204 +0,0 @@
-import { vec3 } from "gl-matrix";
-import { utilities } from "dcmjs";
-import CORNERSTONE_3D_TAG from "./cornerstone3DTag";
-import MeasurementReport from "./MeasurementReport";
-
-const { Ellipse: TID300Ellipse } = utilities.TID300;
-
-const ELLIPTICALROI = "EllipticalROI";
-const EPSILON = 1e-4;
-
-const trackingIdentifierTextValue = `${CORNERSTONE_3D_TAG}:${ELLIPTICALROI}`;
-
-class EllipticalROI {
-    static getMeasurementData(
-        MeasurementGroup,
-        sopInstanceUIDToImageIdMap,
-        imageToWorldCoords,
-        metadata
-    ) {
-        const { defaultState, NUMGroup, SCOORDGroup, ReferencedFrameNumber } =
-            MeasurementReport.getSetupMeasurementData(
-                MeasurementGroup,
-                sopInstanceUIDToImageIdMap,
-                metadata,
-                EllipticalROI.toolType
-            );
-
-        const referencedImageId =
-            defaultState.annotation.metadata.referencedImageId;
-
-        const { GraphicData } = SCOORDGroup;
-
-        // GraphicData is ordered as [majorAxisStartX, majorAxisStartY, majorAxisEndX, majorAxisEndY, minorAxisStartX, minorAxisStartY, minorAxisEndX, minorAxisEndY]
-        // But Cornerstone3D points are ordered as top, bottom, left, right for the
-        // ellipse so we need to identify if the majorAxis is horizontal or vertical
-        // in the image plane and then choose the correct points to use for the ellipse.
-        const pointsWorld = [];
-        for (let i = 0; i < GraphicData.length; i += 2) {
-            const worldPos = imageToWorldCoords(referencedImageId, [
-                GraphicData[i],
-                GraphicData[i + 1]
-            ]);
-
-            pointsWorld.push(worldPos);
-        }
-
-        const majorAxisStart = vec3.fromValues(...pointsWorld[0]);
-        const majorAxisEnd = vec3.fromValues(...pointsWorld[1]);
-        const minorAxisStart = vec3.fromValues(...pointsWorld[2]);
-        const minorAxisEnd = vec3.fromValues(...pointsWorld[3]);
-
-        const majorAxisVec = vec3.create();
-        vec3.sub(majorAxisVec, majorAxisEnd, majorAxisStart);
-
-        // normalize majorAxisVec to avoid scaling issues
-        vec3.normalize(majorAxisVec, majorAxisVec);
-
-        const minorAxisVec = vec3.create();
-        vec3.sub(minorAxisVec, minorAxisEnd, minorAxisStart);
-        vec3.normalize(minorAxisVec, minorAxisVec);
-
-        const imagePlaneModule = metadata.get(
-            "imagePlaneModule",
-            referencedImageId
-        );
-
-        if (!imagePlaneModule) {
-            throw new Error("imageId does not have imagePlaneModule metadata");
-        }
-
-        const { columnCosines } = imagePlaneModule;
-
-        // find which axis is parallel to the columnCosines
-        const columnCosinesVec = vec3.fromValues(...columnCosines);
-
-        const projectedMajorAxisOnColVec = vec3.dot(
-            columnCosinesVec,
-            majorAxisVec
-        );
-
-        const projectedMinorAxisOnColVec = vec3.dot(
-            columnCosinesVec,
-            minorAxisVec
-        );
-
-        const absoluteOfMajorDotProduct = Math.abs(projectedMajorAxisOnColVec);
-        const absoluteOfMinorDotProduct = Math.abs(projectedMinorAxisOnColVec);
-
-        let ellipsePoints = [];
-        if (Math.abs(absoluteOfMajorDotProduct - 1) < EPSILON) {
-            ellipsePoints = [
-                pointsWorld[0],
-                pointsWorld[1],
-                pointsWorld[2],
-                pointsWorld[3]
-            ];
-        } else if (Math.abs(absoluteOfMinorDotProduct - 1) < EPSILON) {
-            ellipsePoints = [
-                pointsWorld[2],
-                pointsWorld[3],
-                pointsWorld[0],
-                pointsWorld[1]
-            ];
-        } else {
-            console.warn("OBLIQUE ELLIPSE NOT YET SUPPORTED");
-        }
-
-        const state = defaultState;
-
-        state.annotation.data = {
-            handles: {
-                points: [...ellipsePoints],
-                activeHandleIndex: 0,
-                textBox: {
-                    hasMoved: false
-                }
-            },
-            cachedStats: {
-                [`imageId:${referencedImageId}`]: {
-                    area: 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(
-                "EllipticalROI.getTID300RepresentationArguments: referencedImageId is not defined"
-            );
-        }
-
-        const top = worldToImageCoords(referencedImageId, handles.points[0]);
-        const bottom = worldToImageCoords(referencedImageId, handles.points[1]);
-        const left = worldToImageCoords(referencedImageId, handles.points[2]);
-        const right = worldToImageCoords(referencedImageId, handles.points[3]);
-
-        // find the major axis and minor axis
-        const topBottomLength = Math.abs(top[1] - bottom[1]);
-        const leftRightLength = Math.abs(left[0] - right[0]);
-
-        let points = [];
-        if (topBottomLength > leftRightLength) {
-            // major axis is bottom to top
-            points.push({ x: top[0], y: top[1] });
-            points.push({ x: bottom[0], y: bottom[1] });
-
-            // minor axis is left to right
-            points.push({ x: left[0], y: left[1] });
-            points.push({ x: right[0], y: right[1] });
-        } else {
-            // major axis is left to right
-            points.push({ x: left[0], y: left[1] });
-            points.push({ x: right[0], y: right[1] });
-
-            // minor axis is bottom to top
-            points.push({ x: top[0], y: top[1] });
-            points.push({ x: bottom[0], y: bottom[1] });
-        }
-
-        const { area } = cachedStats[`imageId:${referencedImageId}`] || {};
-
-        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 [cornerstone3DTag, toolType] = TrackingIdentifier.split(":");
-
-    if (cornerstone3DTag !== CORNERSTONE_3D_TAG) {
-        return false;
-    }
-
-    // The following is needed since the new cornerstone3D has changed
-    // the EllipticalRoi toolName (which was in the old cornerstone) to EllipticalROI
-    return toolType.toLowerCase() === ELLIPTICALROI.toLowerCase();
-};
-
-MeasurementReport.registerTool(EllipticalROI);
-
-export default EllipticalROI;