IDC (Re #1215): Feat/v2 annotations (#2658)

* Add scoord3d parse / display tool to v2

* Update measurement panel with sr measurements

* Update measurement panel to display read only items

* Cleanup debugger statement

* Check for empty measurement

* fix SCOORD3D coordinates

* Update getRenderableData.js

* fix scoord3d coordinate transformation

* implement logic to detect the ReferencedSOPInstanceUID if missing in the measurement. Fix also world to IJ coordinates.

* Fix broken unit test / import

* fix comment style

* Init tools only once

* restore default config dcmjs server

Co-authored-by: igoroctaviano <igoroctaviano@gmail.com>
This commit is contained in:
Davide Punzoandigoroctaviano authored and GitHub committed 2022-02-03 09:33:02 +01:00
1 parent 1953118c8a
commit 5beb12a7fc
48 files changed
+2286 -231

No files matched your search

@@ -3,6 +3,7 @@ import OHIF from '@ohif/core';
import { connect } from 'react-redux';
import throttle from 'lodash.throttle';
import { setEnabledElement } from './state';
import initSRTools from './tools/initSRTools';
const { setViewportActive, setViewportSpecificData } = OHIF.redux.actions;
const {
@@ -92,6 +93,7 @@ const mapDispatchToProps = (dispatch, ownProps) => {
plugin: 'cornerstone',
})
);
initSRTools(enabledElement);
},
onMeasurementsChanged: (event, action) => {
@@ -5,6 +5,7 @@ import ConnectedCornerstoneViewport from './ConnectedCornerstoneViewport';
import OHIF from '@ohif/core';
import PropTypes from 'prop-types';
import cornerstone from 'cornerstone-core';
import checkForSRAnnotations from './tools/checkForSRAnnotations';
const { StackManager } = OHIF.utils;
@@ -187,6 +188,8 @@ class OHIFCornerstoneViewport extends Component {
displaySet.SOPInstanceUID !== prevDisplaySet.SOPInstanceUID ||
displaySet.frameIndex !== prevDisplaySet.frameIndex
) {
const { viewportIndex } = this.props;
checkForSRAnnotations({ displaySet, viewportIndex });
this.setStateFromProps();
}
}
+4
View File
@@ -5,6 +5,8 @@ import csTools from 'cornerstone-tools';
import merge from 'lodash.merge';
import initCornerstoneTools from './initCornerstoneTools.js';
import measurementServiceMappingsFactory from './utils/measurementServiceMappings/measurementServiceMappingsFactory';
import dicomSRModule from './tools/modules/dicomSRModule';
import srModuleId from './tools/id';
/**
*
@@ -15,6 +17,8 @@ import measurementServiceMappingsFactory from './utils/measurementServiceMapping
export default function init({ servicesManager, configuration }) {
const { UIDialogService, MeasurementService } = servicesManager.services;
csTools.register('module', srModuleId, dicomSRModule);
const callInputDialog = (data, event, callback) => {
if (UIDialogService) {
let dialogId = UIDialogService.create({
@@ -0,0 +1,414 @@
import csTools, {
importInternal,
getToolState,
toolColors,
} from 'cornerstone-tools';
import cornerstone from 'cornerstone-core';
/** Internal imports */
import TOOL_NAMES from './constants/toolNames';
import SCOORD_TYPES from './constants/scoordTypes';
import id from './id';
/** Cornerstone 3rd party dev kit imports */
const draw = importInternal('drawing/draw');
const drawJoinedLines = importInternal('drawing/drawJoinedLines');
const drawCircle = importInternal('drawing/drawCircle');
const drawEllipse = importInternal('drawing/drawEllipse');
const drawHandles = importInternal('drawing/drawHandles');
const drawArrow = importInternal('drawing/drawArrow');
const getNewContext = importInternal('drawing/getNewContext');
const BaseTool = importInternal('base/BaseTool');
const drawLinkedTextBox = importInternal('drawing/drawLinkedTextBox');
/**
* @class DICOMSRDisplayTool - Renders DICOMSR data in a read only manner (i.e. as an overlay).
*
* This is a generic render tool.
*
* A single tool that, given some schema, can render
* POINT, MULTIPOINT, POLYLINE, CIRCLE, and ELLIPSE
* value types for a given imageId.
*
*
* @extends cornerstoneTools.BaseTool
*/
export default class DICOMSRDisplayTool extends BaseTool {
constructor(props = {}) {
const defaultProps = {
mixins: ['enabledOrDisabledBinaryTool'],
name: TOOL_NAMES.DICOM_SR_DISPLAY_TOOL,
};
const initialProps = Object.assign(defaultProps, props);
super(initialProps);
this._module = csTools.getModule(id);
}
renderToolData(evt) {
const eventData = evt.detail;
const { element } = eventData;
const module = this._module;
const toolState = getToolState(element, this.name);
if (!toolState) {
return;
}
const trackingUniqueIdentifiersForElement = module.getters.trackingUniqueIdentifiersForElement(
element
);
const {
activeIndex,
trackingUniqueIdentifiers,
} = trackingUniqueIdentifiersForElement;
const activeTrackingUniqueIdentifier =
trackingUniqueIdentifiers[activeIndex];
// Filter toolData to only render the data for the active SR.
const filteredToolData = toolState.data.filter(td =>
trackingUniqueIdentifiers.includes(td.TrackingUniqueIdentifier)
);
let shouldRepositionTextBoxes = false;
for (let i = 0; i < filteredToolData.length; i++) {
const data = filteredToolData[i];
const { renderableData, labels } = data;
const color =
data.TrackingUniqueIdentifier === activeTrackingUniqueIdentifier
? toolColors.getActiveColor()
: toolColors.getToolColor();
const lineWidth = 2;
const options = {
color,
lineWidth,
handleRadius: 6,
};
Object.keys(renderableData).forEach(GraphicType => {
const renderableDataForGraphicType = renderableData[GraphicType];
switch (GraphicType) {
case SCOORD_TYPES.POINT:
this.renderPoint(renderableDataForGraphicType, eventData, options);
break;
case SCOORD_TYPES.MULTIPOINT:
this.renderMultipoint(
renderableDataForGraphicType,
eventData,
options
);
break;
case SCOORD_TYPES.POLYGON:
case SCOORD_TYPES.POLYLINE:
this.renderPolyLine(
renderableDataForGraphicType,
eventData,
options
);
break;
case SCOORD_TYPES.CIRCLE:
this.renderCircle(renderableDataForGraphicType, eventData, options);
break;
case SCOORD_TYPES.ELLIPSE:
this.renderEllipse(
renderableDataForGraphicType,
eventData,
options
);
break;
}
});
const { element } = eventData;
const context = getNewContext(eventData.canvasContext.canvas);
if (!data.handles || !data.handles.textBox) {
const textBox = {
active: false,
hasMoved: true,
movesIndependently: false,
drawnIndependently: true,
allowedOutsideImage: true,
hasBoundingBox: true,
};
const anchorPoints = _getTextBoxAnchorPointsForRenderableData(
renderableData,
eventData
);
textBox.anchorPoints = anchorPoints;
const bottomRight = {
x: Math.max(...anchorPoints.map(point => point.x)),
y: Math.max(...anchorPoints.map(point => point.y)),
};
textBox.x = bottomRight.x;
textBox.y = bottomRight.y;
data.handles = {};
data.handles.textBox = textBox;
shouldRepositionTextBoxes = true;
}
const text = _getTextBoxLinesFromLabels(labels);
function textBoxAnchorPoints() {
return data.handles.textBox.anchorPoints;
}
draw(context, context => {
drawLinkedTextBox(
context,
element,
data.handles.textBox,
text,
data.handles,
textBoxAnchorPoints,
color,
lineWidth,
0,
true
);
});
}
// TOOD -> text boxes may overlap with other annotations at the moment.
// To be fixed after we get requirements.
// if (shouldRepositionTextBoxes) {
// this.repositionTextBox(filteredToolData, eventData);
// }
}
// repositionTextBox(toolData, eventData) {
// const toolBoundingBoxes = [];
// for (let i = 0; i < toolData.length; i++) {
// const toolDataI = toolData[i];
// const { textBox } = toolDataI.handles;
// const { anchorPoints } = textBox;
// const boundingBox = _getBoundingBoxFromAnchorPoints(anchorPoints);
// // Get the textbox bounding locations.
// // Get the tool extents.
// }
// }
renderPolyLine(renderableData, eventData, options) {
const { element } = eventData;
const context = getNewContext(eventData.canvasContext.canvas);
renderableData.forEach(points => {
draw(context, context => {
drawJoinedLines(context, element, points[0], points, options);
});
});
}
renderMultipoint(renderableData, eventData, options) {
const context = getNewContext(eventData.canvasContext.canvas);
renderableData.forEach(points => {
draw(context, context => {
drawHandles(context, eventData, points, options);
});
});
}
renderPoint(renderableData, eventData, options) {
// Render single point as an arrow.
const { element, image } = eventData;
const { rows, columns } = image;
const context = getNewContext(eventData.canvasContext.canvas);
const { color, lineWidth } = options;
// Find a suitable length for the image size.
const xOffset = columns / 10;
const yOffset = rows / 10;
renderableData.forEach(points => {
const point = points[0]; // The SCOORD type is POINT so the array length is 1.
draw(context, context => {
// Draw the arrow
const handleStartCanvas = cornerstone.pixelToCanvas(element, point);
const handleEndCanvas = cornerstone.pixelToCanvas(element, {
x: point.x + xOffset,
y: point.y + yOffset,
});
drawArrow(
context,
handleEndCanvas,
handleStartCanvas,
color,
lineWidth,
false
);
});
});
}
renderCircle(renderableData, eventData, options) {
const { element } = eventData;
const context = getNewContext(eventData.canvasContext.canvas);
renderableData.forEach(circle => {
const { center, radius } = circle;
drawCircle(context, element, center, radius, options);
});
}
renderEllipse(renderableData, eventData, options) {
const { element } = eventData;
const context = getNewContext(eventData.canvasContext.canvas);
renderableData.forEach(ellipse => {
const { corner1, corner2 } = ellipse;
drawEllipse(
context,
element,
corner1,
corner2,
options,
'pixel',
0 // TODO -> Work our the initial rotation and add it here so we render appropriately rotated ellipses.
);
});
}
}
function _getTextBoxLinesFromLabels(labels) {
// TODO -> max 3 for now (label + shortAxis + longAxis), need a generic solution for this!
const labelLength = Math.min(labels.length, 3);
const lines = [];
for (let i = 0; i < labelLength; i++) {
const labelEntry = labels[i];
lines.push(`${_labelToShorthand(labelEntry.label)}${labelEntry.value}`);
}
return lines;
}
const SHORT_HAND_MAP = {
'Short Axis': 'W ',
'Long Axis': 'L ',
AREA: 'Area ',
Length: '',
CORNERSTONEFREETEXT: '',
};
function _labelToShorthand(label) {
const shortHand = SHORT_HAND_MAP[label];
if (shortHand !== undefined) {
return shortHand;
}
return label;
}
function _getTextBoxAnchorPointsForRenderableData(renderableData, eventData) {
let anchorPoints = [];
Object.keys(renderableData).forEach(GraphicType => {
const renderableDataForGraphicType = renderableData[GraphicType];
switch (GraphicType) {
case SCOORD_TYPES.POINT:
renderableDataForGraphicType.forEach(points => {
anchorPoints = [...anchorPoints, ...points];
// Add other arrow point based on image size.
const { image } = eventData;
const { rows, columns } = image;
const xOffset = columns / 10;
const yOffset = rows / 10;
const point = points[0];
anchorPoints.push({ x: point.x + xOffset, y: point.y + yOffset });
});
break;
case SCOORD_TYPES.MULTIPOINT:
case SCOORD_TYPES.POLYLINE:
case SCOORD_TYPES.POLYGON:
renderableDataForGraphicType.forEach(points => {
anchorPoints = [...anchorPoints, ...points];
});
break;
case SCOORD_TYPES.CIRCLE:
renderableDataForGraphicType.forEach(circle => {
const { center, radius } = circle;
anchorPoints.push({ x: center.x + radius, y: center.y });
anchorPoints.push({ x: center.x - radius, y: center.y });
anchorPoints.push({ x: center.x, y: center.y + radius });
anchorPoints.push({ x: center.x, y: center.y - radius });
});
break;
case SCOORD_TYPES.ELLIPSE:
renderableDataForGraphicType.forEach(ellipse => {
const { corner1, corner2 } = ellipse;
const halfWidth = Math.abs(corner1.x - corner2.x) / 2;
const halfHeight = Math.abs(corner1.y - corner2.y) / 2;
const center = {
x: (corner1.x + corner2.x) / 2,
y: (corner1.y + corner2.y) / 2,
};
anchorPoints.push({ x: center.x + halfWidth, y: center.y });
anchorPoints.push({ x: center.x - halfWidth, y: center.y });
anchorPoints.push({ x: center.x, y: center.y + halfHeight });
anchorPoints.push({ x: center.x, y: center.y - halfHeight });
});
break;
}
});
return anchorPoints;
}
function _getBoundingBoxFromAnchorPoints(anchorPoints) {
let minX = Infinity;
let maxX = -Infinity;
let minY = Infinity;
let maxY = -Infinity;
anchorPoints.forEach(point => {
const { x, y } = point;
if (x > maxX) {
maxX = x;
} else if (x < minX) {
minX = x;
}
if (y > maxX) {
maxY = y;
} else if (y < minY) {
minY = y;
}
});
}
@@ -0,0 +1,57 @@
import csTools from 'cornerstone-tools';
import cs from 'cornerstone-core';
import OHIF from '@ohif/core';
import { getEnabledElement } from '../state';
import id from './id';
const { studyMetadataManager } = OHIF.utils;
const checkForSRAnnotations = ({ viewportIndex, displaySet }) => {
const srModule = csTools.getModule(id);
const element = getEnabledElement(viewportIndex);
if (!element) {
return;
}
const { StudyInstanceUID } = displaySet;
const studyMetadata = studyMetadataManager.get(StudyInstanceUID);
if (!studyMetadata) {
return;
}
const srDisplaySets = studyMetadata
.getDisplaySets()
.filter(ds => ds.Modality === 'SR');
if (srDisplaySets.length === 0) {
return;
}
const { measurements: _measurements } = srDisplaySets[0];
if (!_measurements || _measurements.length < 1) {
return;
}
const measurements = _measurements.filter(m => m.loaded === true);
const measurement = measurements[0];
if (!measurement) {
return;
}
srModule.setters.trackingUniqueIdentifiersForElement(
element,
measurements.map(measurement => measurement.TrackingUniqueIdentifier),
measurement
);
const { TrackingUniqueIdentifier } = measurement;
srModule.setters.activeTrackingUniqueIdentifierForElement(
element,
TrackingUniqueIdentifier
);
cs.updateImage(element);
};
export default checkForSRAnnotations;
@@ -0,0 +1,8 @@
export default {
POINT: 'POINT',
MULTIPOINT: 'MULTIPOINT',
POLYLINE: 'POLYLINE',
CIRCLE: 'CIRCLE',
ELLIPSE: 'ELLIPSE',
POLYGON: 'POLYGON',
};
@@ -0,0 +1,5 @@
const TOOL_NAMES = {
DICOM_SR_DISPLAY_TOOL: 'DICOMSRDisplayTool',
};
export default TOOL_NAMES;
+7
View File
@@ -0,0 +1,7 @@
const id = 'org.ohif.dicom-sr';
export default id;
const SOPClassHandlerName = 'dicom-sr';
const SOPClassHandlerId = `${id}.sopClassHandlerModule.${SOPClassHandlerName}`;
export { SOPClassHandlerName, SOPClassHandlerId };
@@ -0,0 +1,108 @@
import cornerstoneTools from 'cornerstone-tools';
import DICOMSRDisplayTool from './DICOMSRDisplayTool';
import TOOL_NAMES from './constants/toolNames';
import getToolAlias from './utils/getToolAlias';
/**
* Initialize SR cornerstone tools.
*
* @param {*} targetElement
*/
const initSRTools = targetElement => {
const primaryToolId = 'Wwwc';
const toolAlias = getToolAlias(primaryToolId); // These are 1:1 for built-in only
// ~~ MAGIC
cornerstoneTools.addToolForElement(targetElement, DICOMSRDisplayTool);
cornerstoneTools.setToolEnabledForElement(
targetElement,
TOOL_NAMES.DICOM_SR_DISPLAY_TOOL
);
// ~~ Variants
cornerstoneTools.addToolForElement(
targetElement,
cornerstoneTools.LengthTool,
{
name: 'SRLength',
configuration: {
renderDashed: true,
},
}
);
cornerstoneTools.addToolForElement(
targetElement,
cornerstoneTools.ArrowAnnotateTool,
{
name: 'SRArrowAnnotate',
configuration: {
renderDashed: true,
},
}
);
cornerstoneTools.addToolForElement(
targetElement,
cornerstoneTools.BidirectionalTool,
{
name: 'SRBidirectional',
configuration: {
renderDashed: true,
},
}
);
cornerstoneTools.addToolForElement(
targetElement,
cornerstoneTools.EllipticalRoiTool,
{
name: 'SREllipticalRoi',
configuration: {
renderDashed: true,
},
}
);
cornerstoneTools.addToolForElement(
targetElement,
cornerstoneTools.RectangleRoiTool,
{
name: 'SRRectangleRoi',
configuration: {
renderDashed: true,
},
}
);
cornerstoneTools.addToolForElement(
targetElement,
cornerstoneTools.FreehandRoiTool,
{
name: 'SRFreehandRoi',
configuration: {
renderDashed: true,
},
}
);
// ~~ Business as usual
cornerstoneTools.setToolActiveForElement(targetElement, 'PanMultiTouch', {
pointers: 2,
});
cornerstoneTools.setToolActiveForElement(targetElement, 'ZoomTouchPinch', {});
// TODO: Add always dashed tool alternative aliases
// TODO: or same name... alternative config?
cornerstoneTools.setToolActiveForElement(targetElement, toolAlias, {
mouseButtonMask: 1,
});
cornerstoneTools.setToolActiveForElement(targetElement, 'Pan', {
mouseButtonMask: 4,
});
cornerstoneTools.setToolActiveForElement(targetElement, 'Zoom', {
mouseButtonMask: 2,
});
cornerstoneTools.setToolActiveForElement(
targetElement,
'StackScrollMouseWheel',
{}
);
};
export default initSRTools;
@@ -0,0 +1,61 @@
import cornerstone from 'cornerstone-core';
const state = {
TrackingUniqueIdentifier: null,
trackingIdentifiersByEnabledElementUUID: {},
};
function setTrackingUniqueIdentifiersForElement(
element,
trackingUniqueIdentifiers,
activeIndex = 0
) {
const enabledElement = cornerstone.getEnabledElement(element);
const { uuid } = enabledElement;
state.trackingIdentifiersByEnabledElementUUID[uuid] = {
trackingUniqueIdentifiers,
activeIndex,
};
}
function setActiveTrackingUniqueIdentifierForElement(
element,
TrackingUniqueIdentifier
) {
const enabledElement = cornerstone.getEnabledElement(element);
const { uuid } = enabledElement;
const trackingIdentifiersForElement =
state.trackingIdentifiersByEnabledElementUUID[uuid];
if (trackingIdentifiersForElement) {
const activeIndex = trackingIdentifiersForElement.trackingUniqueIdentifiers.findIndex(
tuid => tuid === TrackingUniqueIdentifier
);
trackingIdentifiersForElement.activeIndex = activeIndex;
}
}
function getTrackingUniqueIdentifiersForElement(element) {
const enabledElement = cornerstone.getEnabledElement(element);
const { uuid } = enabledElement;
if (state.trackingIdentifiersByEnabledElementUUID[uuid]) {
return state.trackingIdentifiersByEnabledElementUUID[uuid];
}
return { trackingUniqueIdentifiers: [] };
}
export default {
state,
getters: {
trackingUniqueIdentifiersForElement: getTrackingUniqueIdentifiersForElement,
},
setters: {
trackingUniqueIdentifiersForElement: setTrackingUniqueIdentifiersForElement,
activeTrackingUniqueIdentifierForElement: setActiveTrackingUniqueIdentifierForElement,
},
};
@@ -0,0 +1,32 @@
/**
* Get cornerstone tool alias.
*
* @param {string} toolName
* @returns tool alias
*/
export default function getToolAlias(toolName) {
let toolAlias = toolName;
switch (toolName) {
case 'Length':
toolAlias = 'SRLength';
break;
case 'Bidirectional':
toolAlias = 'SRBidirectional';
break;
case 'ArrowAnnotate':
toolAlias = 'SRArrowAnnotate';
break;
case 'EllipticalRoi':
toolAlias = 'SREllipticalRoi';
break;
case 'FreehandRoi':
toolAlias = 'SRFreehandRoi';
break;
case 'RectangleRoi':
toolAlias = 'SRRectangleRoi';
break;
}
return toolAlias;
}
@@ -5,11 +5,12 @@ const SOP_CLASS_UIDS = {
BASIC_TEXT_SR: '1.2.840.10008.5.1.4.1.1.88.11',
ENHANCED_SR: '1.2.840.10008.5.1.4.1.1.88.22',
COMPREHENSIVE_SR: '1.2.840.10008.5.1.4.1.1.88.33',
COMPREHENSIVE_3D_SR: '1.2.840.10008.5.1.4.1.1.88.34',
PROCEDURE_LOG_STORAGE: '1.2.840.10008.5.1.4.1.1.88.40',
MAMMOGRAPHY_CAD_SR: '1.2.840.10008.5.1.4.1.1.88.50',
CHEST_CAD_SR: '1.2.840.10008.5.1.4.1.1.88.65',
X_RAY_RADIATION_DOSE_SR: '1.2.840.10008.5.1.4.1.1.88.67',
ACQUISITION_CONTEXT_SR_STORAGE: '1.2.840.10008.5.1.4.1.1.88.71',
ACQUISITION_CONTEXT_SR_STORAGE: '1.2.840.10008.5.1.4.1.1.88.71'
};
const sopClassUIDs = Object.values(SOP_CLASS_UIDS);
@@ -46,6 +47,8 @@ const OHIFDicomHtmlSopClassHandler = {
SeriesTime,
SeriesNumber,
authorizationHeaders,
sopClassUids: sopClassUIDs,
images: series._instances,
};
},
};