[IDC-1129] - DICOM Tag Viewer extension (#2022)

* WIP render top level tags.

* Add drop down to select series.

* Fix errors with type 2 sequences.

* WIP swap instance.

* Fix formatting and make fullscreen.

* Remove debuggers.

* Finish formatting.

* Fix error with double SeriesNumber deconstruction.

* Address reviewer comments.
This commit is contained in:
James Petts authored and GitHub committed 2020-09-10 12:13:24 +02:00
1 parent a7b5f1847a
commit 0ef88e88eb
23 files changed
+612 -7

No files matched your search

@@ -0,0 +1,58 @@
import React from 'react';
import Select from 'react-select';
const DicomBrowserSelect = ({ value, formatOptionLabel, options }) => (
<Select
value={value}
formatOptionLabel={formatOptionLabel}
styles={dicomBrowserSelectStyles}
options={options}
/>
);
const computedstyle = getComputedStyle(document.body);
const uiGrayDarker = computedstyle.getPropertyValue('--ui-gray-darker');
const activeColor = computedstyle.getPropertyValue('--active-color');
const defaultColor = computedstyle.getPropertyValue('--default-color');
const uiGrayDark = computedstyle.getPropertyValue('--ui-gray-dark');
const dicomBrowserSelectStyles = {
singleValue: (base, state) => ({
...base,
width: '100%',
}),
control: (base, state) => ({
...base,
cursor: 'pointer',
background: uiGrayDarker,
borderRadius: state.isFocused ? '5px 5px 5px 5px' : 5,
borderColor: state.isFocused ? activeColor : defaultColor,
minHeight: '50px',
'&:hover': {
borderColor: activeColor,
},
}),
menu: base => ({
...base,
borderRadius: 5,
background: uiGrayDarker,
}),
option: (base, state) => ({
...base,
cursor: 'pointer',
'&:first-of-type': {
borderTopLeftRadius: 5,
borderTopRightRadius: 5,
},
'&:last-of-type': {
borderBottomLeftRadius: 5,
borderBottomRightRadius: 5,
},
background: state.isSelected ? uiGrayDark : uiGrayDarker,
'&:hover': {
background: uiGrayDark,
},
}),
};
export default DicomBrowserSelect;
@@ -0,0 +1,25 @@
.dcmseg-segmentation-item {
display: flex;
justify-content: start;
margin: 0;
}
.dcmseg-segmentation-item .segmentation-meta {
display: flex;
flex-direction: column;
flex-grow: 1;
overflow: hidden;
}
.dcmseg-segmentation-item .segmentation-meta-title {
text-overflow: ellipsis;
overflow: hidden;
white-space: nowrap;
color: white;
max-width: calc(100% - 30px);
}
.dcmseg-segmentation-item .segmentation-meta-description {
font-size: 12px;
color: var(--text-secondary-color);
}
@@ -0,0 +1,27 @@
import React from 'react';
import PropTypes from 'prop-types';
import './DicomBrowserSelectItem.css';
const DicomBrowserSelectItem = ({ onClick, title, description }) => {
return (
<li className="dcmseg-segmentation-item" onClick={onClick}>
<div className="segmentation-meta">
<div className="segmentation-meta-title">{title}</div>
<div className="segmentation-meta-description">{description}</div>
</div>
</li>
);
};
DicomBrowserSelectItem.propTypes = {
onClick: PropTypes.func.isRequired,
title: PropTypes.string.isRequired,
description: PropTypes.string.isRequired,
};
DicomBrowserSelectItem.defaultProps = {
description: '',
};
export default DicomBrowserSelectItem;
@@ -0,0 +1,27 @@
.dicom-tag-browser-table {
margin-right: auto;
margin-left: auto;
}
.dicom-tag-browser-table td {
padding-left: 10px;
padding-right: 10px;
color: var(--table-text-primary-color);
border-top: 1px solid #ddd;
white-space: nowrap;
}
.dicom-tag-browser-table td.dicom-tag-browser-table-center {
text-align: center;
}
.dicom-tag-browser-table th {
padding-left: 10px;
padding-right: 10px;
text-align: center;
color: var(--active-color);
}
.dicom-tag-browser-table th.dicom-tag-browser-table-left {
text-align: left;
}
@@ -0,0 +1,228 @@
import React, { useState } from 'react';
import { classes } from '@ohif/core';
import dcmjs from 'dcmjs';
import DicomBrowserSelect from './DicomBrowserSelect';
import moment from 'moment';
import './DicomTagBrowser.css';
import DicomBrowserSelectItem from './DicomBrowserSelectItem';
const { ImageSet } = classes;
const { DicomMetaDictionary } = dcmjs.data;
const { nameMap } = DicomMetaDictionary;
const DicomTagBrowser = ({ displaySets, displaySetInstanceUID }) => {
const [
activeDisplaySetInstanceUID,
setActiveDisplaySetInstanceUID,
] = useState(displaySetInstanceUID);
const [activeInstance, setActiveInstance] = useState(0);
const activeDisplaySet = displaySets.find(
ds => ds.displaySetInstanceUID === activeDisplaySetInstanceUID
);
const displaySetList = displaySets.map(displaySet => {
const {
displaySetInstanceUID,
SeriesDate,
SeriesTime,
SeriesNumber,
SeriesDescription,
Modality,
} = displaySet;
/* Map to display representation */
const dateStr = `${SeriesDate}:${SeriesTime}`.split('.')[0];
const date = moment(dateStr, 'YYYYMMDD:HHmmss');
const displayDate = date.format('ddd, MMM Do YYYY');
return {
value: displaySetInstanceUID,
title: `${SeriesNumber} (${Modality}): ${SeriesDescription}`,
description: displayDate,
onClick: () => {
setActiveDisplaySetInstanceUID(displaySetInstanceUID);
setActiveInstance(0);
},
};
});
let metadata;
const isImageStack = activeDisplaySet instanceof ImageSet;
let selectedInstanceValue;
let instanceList;
if (isImageStack) {
const { images } = activeDisplaySet;
const image = images[activeInstance];
instanceList = images.map((image, index) => {
const metadata = image.getData().metadata;
const { InstanceNumber } = metadata;
return {
value: index,
title: `Instance Number: ${InstanceNumber}`,
description: '',
onClick: () => {
setActiveInstance(index);
},
};
});
selectedInstanceValue = instanceList[activeInstance];
metadata = image.getData().metadata;
} else {
metadata = activeDisplaySet.metadata;
}
const selectedDisplaySetValue = displaySetList.find(
ds => ds.value === activeDisplaySetInstanceUID
);
return (
<div>
<DicomBrowserSelect
value={selectedDisplaySetValue}
formatOptionLabel={DicomBrowserSelectItem}
options={displaySetList}
/>
{isImageStack ? (
<DicomBrowserSelect
value={selectedInstanceValue}
formatOptionLabel={DicomBrowserSelectItem}
options={instanceList}
/>
) : null}
<DicomTagTable instanceMetadata={metadata}></DicomTagTable>
</div>
);
};
function DicomTagTable({ instanceMetadata }) {
const rows = getRows(instanceMetadata);
return (
<div>
<table className="dicom-tag-browser-table">
<tr>
<th className="dicom-tag-browser-table-left">Tag</th>
<th className="dicom-tag-browser-table-left">Value Representation</th>
<th className="dicom-tag-browser-table-left">Keyword</th>
<th className="dicom-tag-browser-table-left">Value</th>
</tr>
{rows.map(row => (
<tr>
<td>{row[0]}</td>
<td>{row[1]}</td>
<td>{row[2]}</td>
<td>{row[3]}</td>
</tr>
))}
</table>
</div>
);
}
function getRows(metadata, depth = 0) {
// Tag, Type, Value, Keyword
const keywords = Object.keys(metadata);
let tagIndent = '';
for (let i = 0; i < depth; i++) {
tagIndent += '>';
}
const rows = [];
for (let i = 0; i < keywords.length; i++) {
let keyword = keywords[i];
if (keyword === '_vrMap') {
continue;
}
const tagInfo = nameMap[keyword];
let value = metadata[keyword];
if (tagInfo && tagInfo.vr === 'SQ') {
const sequenceAsArray = toArray(value);
// Push line defining the sequence
rows.push([`${tagIndent}${tagInfo.tag}`, tagInfo.vr, keyword, '']);
if (value === null) {
// Type 2 Sequence
continue;
}
sequenceAsArray.forEach(item => {
const sequenceRows = getRows(item, depth + 1);
sequenceRows.forEach(row => {
rows.push(row);
});
});
continue;
}
if (Array.isArray(value)) {
value = value.join('\\');
}
if (typeof value === 'number') {
value = value.toString();
}
if (typeof value !== 'string') {
if (value === null) {
value = ' ';
} else {
if (typeof value === 'object') {
if (value.InlineBinary) {
value = 'Inline Binary';
} else if (value.BulkDataURI) {
value = `Bulk Data URI`; //: ${value.BulkDataURI}`;
} else if (value.Alphabetic) {
value = value.Alphabetic;
} else {
console.error('Unrecognised Value for element:');
console.error(value);
value = ' ';
}
} else {
console.error('Unrecognised Value for element:');
console.error(value);
value = ' ';
}
}
}
// Remove retired tags
keyword = keyword.replace('RETIRED_', '');
if (tagInfo) {
rows.push([`${tagIndent}${tagInfo.tag}`, tagInfo.vr, keyword, value]);
} else {
// Private tag
const tag = `(${keyword.substring(0, 4)},${keyword.substring(4, 8)})`;
rows.push([`${tagIndent}${tag}`, '', 'Private Tag', value]);
}
}
return rows;
}
function toArray(objectOrArray) {
return Array.isArray(objectOrArray) ? objectOrArray : [objectOrArray];
}
export default DicomTagBrowser;
@@ -0,0 +1,52 @@
import { utils } from '@ohif/core';
import React from 'react';
import DicomTagBrowser from './components/DicomTagBrowser';
const { studyMetadataManager } = utils;
export default function getCommandsModule(servicesManager) {
const actions = {
openDICOMTagViewer({ viewports }) {
const { activeViewportIndex, viewportSpecificData } = viewports;
const activeViewportSpecificData =
viewportSpecificData[activeViewportIndex];
const {
StudyInstanceUID,
displaySetInstanceUID,
} = activeViewportSpecificData;
const studyMetadata = studyMetadataManager.get(StudyInstanceUID);
const displaySets = studyMetadata.getDisplaySets();
const { UIModalService } = servicesManager.services;
const WrappedDicomTagBrowser = function() {
return (
<DicomTagBrowser
displaySets={displaySets}
displaySetInstanceUID={displaySetInstanceUID}
/>
);
};
UIModalService.show({
content: WrappedDicomTagBrowser,
title: `DICOM Tag Browser`,
fullscreen: true,
});
},
};
const definitions = {
openDICOMTagViewer: {
commandFn: actions.openDICOMTagViewer,
storeContexts: ['servers', 'viewports'],
},
};
return {
actions,
definitions,
};
}
+26
View File
@@ -0,0 +1,26 @@
import getCommandsModule from './getCommandsModule';
import toolbarModule from './toolbarModule';
/**
* Constants
*/
/**
* Extension
*/
export default {
/**
* Only required property. Should be a unique value across all extensions.
*/
id: 'dicom-tag-browser',
/**
* MODULE GETTERS
*/
getCommandsModule({ servicesManager }) {
return getCommandsModule(servicesManager);
},
getToolbarModule() {
return toolbarModule;
},
};
@@ -0,0 +1,20 @@
const TOOLBAR_BUTTON_TYPES = {
COMMAND: 'command',
};
const definitions = [
{
id: 'TagBrowser',
label: 'Tag Browser',
icon: 'list',
//
type: TOOLBAR_BUTTON_TYPES.COMMAND,
commandName: 'openDICOMTagViewer',
context: 'VIEWER',
},
];
export default {
definitions,
defaultContext: 'VIEWER',
};