| Measurement Tracking | [Demo](https://viewer.ohif.org/viewer?StudyInstanceUIDs=1.3.6.1.4.1.25403.345050719074.3824.20170125095438.5) |
+| 
| Labelmap Segmentations | [Demo](https://viewer.ohif.org/viewer?StudyInstanceUIDs=1.3.12.2.1107.5.2.32.35162.30000015050317233592200000046) |
+| 
| Fusion and Custom Hanging protocols | [Demo](https://viewer.ohif.org/tmtv?StudyInstanceUIDs=1.3.6.1.4.1.14519.5.2.1.7009.2403.334240657131972136850343327463) |
+| 
| Slide Microscopy | [Demo](https://viewer.ohif.org/microscopy?StudyInstanceUIDs=2.25.275741864483510678566144889372061815320) |
+| 
| Volume Rendering | [Demo](https://viewer.ohif.org/viewer?StudyInstanceUIDs=1.3.6.1.4.1.25403.345050719074.3824.20170125095438.5&hangingprotocolId=mprAnd3DVolumeViewport) |
+
+
## About
@@ -85,17 +94,14 @@ forking).
### Support
-We offer support through
-[GitHub Issues](https://github.com/OHIF/Viewers/issues/new/choose). You can:
-
- [Report a Bug 🐛](https://github.com/OHIF/Viewers/issues/new?assignees=&labels=Community%3A+Report+%3Abug%3A%2CAwaiting+Reproduction&projects=&template=bug-report.yml&title=%5BBug%5D+)
- [Request a Feature 🚀](https://github.com/OHIF/Viewers/issues/new?assignees=&labels=Community%3A+Request+%3Ahand%3A&projects=&template=feature-request.yml&title=%5BFeature+Request%5D+)
- [Ask a Question 🤗](community.ohif.org)
- [Slack Channel](https://join.slack.com/t/cornerstonejs/shared_invite/zt-1r8xb2zau-dOxlD6jit3TN0Uwf928w9Q)
For commercial support, academic collaborations, and answers to common
-questions; please read our
-[documented FAQ](https://docs.ohif.org/faq/index.html#does-ohif-offer-commercial-support).
+questions; please use [Get Support](https://ohif.org/get-support/) to contact
+us.
## Developing
@@ -128,9 +134,6 @@ Here is a schematic representation of our development workflow:
-
-
-
### Requirements
- [Yarn 1.17.3+](https://yarnpkg.com/en/docs/install)
@@ -164,7 +167,7 @@ yarn install
These commands are available from the root directory. Each project directory
also supports a number of commands that can be found in their respective
-`README.md` and `project.json` files.
+`README.md` and `package.json` files.
| Yarn Commands | Description |
| ---------------------------- | ------------------------------------------------------------- |
@@ -222,15 +225,6 @@ you'll see the following:
└── README.md # This file
```
-Want to better understand why and how we've structured this repository? Read
-more about it in our [Architecture Documentation][ohif-architecture].
-
-
-
-| Name | Description | Links |
-| ---------------------------------------------------- | ----------------------------------------------------- | ---------------------- |
-| [@ohif/extension-cornerstone][extension-cornerstone] | 2D image viewing, annotation, and segementation tools | [NPM][cornerstone-npm] |
-
## Acknowledgments
To acknowledge the OHIF Viewer in an academic publication, please cite
@@ -259,7 +253,7 @@ or, for v1, please cite:
> [10.1158/0008-5472.CAN-17-0334](https://www.doi.org/10.1158/0008-5472.CAN-17-0334)
**Note:** If you use or find this repository helpful, please take the time to
-star this repository on Github. This is an easy way for us to assess adoption
+star this repository on GitHub. This is an easy way for us to assess adoption
and it can help us obtain future funding for the project.
This work is supported primarily by the National Institutes of Health, National
@@ -267,7 +261,11 @@ Cancer Institute, Informatics Technology for Cancer Research (ITCR) program,
under a
[grant to Dr. Gordon Harris at Massachusetts General Hospital (U24 CA199460)](https://projectreporter.nih.gov/project_info_description.cfm?aid=8971104).
-This project is tested with BrowserStack. Thank you for supporting open source
+[NCI Imaging Data Commons (IDC) project](https://imaging.datacommons.cancer.gov/) supported the development of new features and bug fixes marked with ["IDC:priority"](https://github.com/OHIF/Viewers/issues?q=is%3Aissue+is%3Aopen+label%3AIDC%3Apriority),
+["IDC:candidate"](https://github.com/OHIF/Viewers/issues?q=is%3Aissue+is%3Aopen+label%3AIDC%3Acandidate) or ["IDC:collaboration"](https://github.com/OHIF/Viewers/issues?q=is%3Aissue+is%3Aopen+label%3AIDC%3Acollaboration). NCI Imaging Data Commons is supported by contract number 19X037Q from
+Leidos Biomedical Research under Task Order HHSN26100071 from NCI. [IDC Viewer](https://learn.canceridc.dev/portal/visualization) is a customized version of the OHIF Viewer.
+
+This project is tested with BrowserStack. Thank you for supporting open-source!
## License
diff --git a/babel.config.js b/babel.config.js
index d2aad74c27..b55cbfdfa0 100644
--- a/babel.config.js
+++ b/babel.config.js
@@ -3,22 +3,22 @@ const { extendDefaultPlugins } = require('svgo');
module.exports = {
babelrcRoots: ['./platform/*', './extensions/*', './modes/*'],
- presets: [
- '@babel/preset-env',
- '@babel/preset-react',
- '@babel/preset-typescript',
- ],
+ presets: ['@babel/preset-env', '@babel/preset-react', '@babel/preset-typescript'],
plugins: [
[
'inline-react-svg',
{
svgo: {
- plugins: extendDefaultPlugins([
+ plugins: [
{
- name: 'removeViewBox',
- active: false,
+ name: 'preset-default',
+ params: {
+ overrides: {
+ removeViewBox: false,
+ },
+ },
},
- ]),
+ ],
},
},
],
diff --git a/commit.txt b/commit.txt
index 39fe445d11..52add76e67 100644
--- a/commit.txt
+++ b/commit.txt
@@ -1 +1 @@
-1d38fe30a490010c7de487c7a0b1a5bfe3bc75a4
\ No newline at end of file
+86f54d0d07042750a863ae876aa8dd5fb16029a5
diff --git a/extensions/_example/src/index.js b/extensions/_example/src/index.js
index c4fdb9eb1c..08b3da8360 100644
--- a/extensions/_example/src/index.js
+++ b/extensions/_example/src/index.js
@@ -54,11 +54,7 @@ const getCommandsModule = () => ({
const ExampleContext = React.createContext();
function ExampleContextProvider({ children }) {
- return (
-
+
{rtIsLoading && (
This Segmentation is loaded in the segmentation panel
- );
+ ToolTipMessage = () => This Segmentation is loaded in the segmentation panel
;
break;
case false:
- StatusIcon = () => Click LOAD to load RTSTRUCT.
;
}
const StatusArea = () => (
-
-
+
+
@@ -44,7 +47,10 @@ export default function _getStatusComponent({ isHydrated, onStatusClick }) {
return (
<>
{ToolTipMessage && (
- setToolActive(TOOL_TYPES.CIRCULAR_BRUSH),
+ options: [
+ {
+ name: 'Radius (mm)',
+ id: 'brush-radius',
+ type: 'range',
+ min: 0.01,
+ max: 100,
+ value: state.Brush.brushSize,
+ step: 0.5,
+ onChange: value => onBrushSizeChange(value, 'Brush'),
+ },
+ {
+ name: 'Mode',
+ type: 'radio',
+ id: 'brush-mode',
+ value: state.Brush.mode,
+ values: [
+ { value: TOOL_TYPES.CIRCULAR_BRUSH, label: 'Circle' },
+ { value: TOOL_TYPES.SPHERE_BRUSH, label: 'Sphere' },
+ ],
+ onChange: value => setToolActive(value),
+ },
+ ],
+ },
+ {
+ name: 'Eraser',
+ icon: 'icon-tool-eraser',
+ disabled: !toolsEnabled,
+ active:
+ state.activeTool === TOOL_TYPES.CIRCULAR_ERASER ||
+ state.activeTool === TOOL_TYPES.SPHERE_ERASER,
+ onClick: () => setToolActive(TOOL_TYPES.CIRCULAR_ERASER),
+ options: [
+ {
+ name: 'Radius (mm)',
+ type: 'range',
+ id: 'eraser-radius',
+ min: 0.01,
+ max: 100,
+ value: state.Eraser.brushSize,
+ step: 0.5,
+ onChange: value => onBrushSizeChange(value, 'Eraser'),
+ },
+ {
+ name: 'Mode',
+ type: 'radio',
+ id: 'eraser-mode',
+ value: state.Eraser.mode,
+ values: [
+ { value: TOOL_TYPES.CIRCULAR_ERASER, label: 'Circle' },
+ { value: TOOL_TYPES.SPHERE_ERASER, label: 'Sphere' },
+ ],
+ onChange: value => setToolActive(value),
+ },
+ ],
+ },
+ {
+ name: 'Scissor',
+ icon: 'icon-tool-scissor',
+ disabled: !toolsEnabled,
+ active:
+ state.activeTool === TOOL_TYPES.CIRCLE_SCISSOR ||
+ state.activeTool === TOOL_TYPES.RECTANGLE_SCISSOR ||
+ state.activeTool === TOOL_TYPES.SPHERE_SCISSOR,
+ onClick: () => setToolActive(TOOL_TYPES.CIRCLE_SCISSOR),
+ options: [
+ {
+ name: 'Mode',
+ type: 'radio',
+ value: state.Scissors.mode,
+ id: 'scissor-mode',
+ values: [
+ { value: TOOL_TYPES.CIRCLE_SCISSOR, label: 'Circle' },
+ { value: TOOL_TYPES.RECTANGLE_SCISSOR, label: 'Rectangle' },
+ { value: TOOL_TYPES.SPHERE_SCISSOR, label: 'Sphere' },
+ ],
+ onChange: value => setToolActive(value),
+ },
+ ],
+ },
+ {
+ name: 'Threshold Tool',
+ icon: 'icon-tool-threshold',
+ disabled: !toolsEnabled,
+ active:
+ state.activeTool === TOOL_TYPES.THRESHOLD_CIRCULAR_BRUSH ||
+ state.activeTool === TOOL_TYPES.THRESHOLD_SPHERE_BRUSH,
+ onClick: () => setToolActive(TOOL_TYPES.THRESHOLD_CIRCULAR_BRUSH),
+ options: [
+ {
+ name: 'Radius (mm)',
+ id: 'threshold-radius',
+ type: 'range',
+ min: 0.01,
+ max: 100,
+ value: state.ThresholdBrush.brushSize,
+ step: 0.5,
+ onChange: value => onBrushSizeChange(value, 'ThresholdBrush'),
+ },
+ {
+ name: 'Mode',
+ type: 'radio',
+ id: 'threshold-mode',
+ value: state.activeTool,
+ values: [
+ { value: TOOL_TYPES.THRESHOLD_CIRCULAR_BRUSH, label: 'Circle' },
+ { value: TOOL_TYPES.THRESHOLD_SPHERE_BRUSH, label: 'Sphere' },
+ ],
+ onChange: value => setToolActive(value),
+ },
+ {
+ type: 'custom',
+ id: 'segmentation-threshold-range',
+ children: () => {
+ return (
+ ;
+ servicesManager: any;
+ referencedDisplaySetInstanceUID?: string;
+}) {
+ const { cornerstoneViewportService, segmentationService, viewportGridService } =
+ servicesManager.services;
+
+ const viewport = getTargetViewport({ viewportId, viewportGridService });
+ const targetViewportId = viewport.viewportOptions.viewportId;
+
+ referencedDisplaySetInstanceUID =
+ referencedDisplaySetInstanceUID || viewport?.displaySetInstanceUIDs[0];
+
+ const updatedViewports = getUpdatedViewportsForSegmentation({
+ servicesManager,
+ viewportId,
+ referencedDisplaySetInstanceUID,
+ });
+
+ // create Segmentation callback which needs to be waited until
+ // the volume is created (if coming from stack)
+ const createSegmentationForVolume = async () => {
+ const segmentationId = await loadFn();
+ segmentationService.hydrateSegmentation(segmentationId);
+ };
+
+ // the reference volume that is used to draw the segmentation. so check if the
+ // volume exists in the cache (the target Viewport is already a volume viewport)
+ const volumeExists = Array.from(cache._volumeCache.keys()).some(volumeId =>
+ volumeId.includes(referencedDisplaySetInstanceUID)
+ );
+
+ updatedViewports.forEach(async viewport => {
+ viewport.viewportOptions = {
+ ...viewport.viewportOptions,
+ viewportType: 'volume',
+ needsRerendering: true,
+ };
+ const viewportId = viewport.viewportId;
+
+ const csViewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
+ const prevCamera = csViewport.getCamera();
+
+ // only run the createSegmentationForVolume for the targetViewportId
+ // since the rest will get handled by cornerstoneViewportService
+ if (volumeExists && viewportId === targetViewportId) {
+ await createSegmentationForVolume();
+ return;
+ }
+
+ const createNewSegmentationWhenVolumeMounts = async evt => {
+ const isTheActiveViewportVolumeMounted = evt.detail.volumeActors?.find(ac =>
+ ac.uid.includes(referencedDisplaySetInstanceUID)
+ );
+
+ // Note: make sure to re-grab the viewport since it might have changed
+ // during the time it took for the volume to be mounted, for instance
+ // the stack viewport has been changed to a volume viewport
+ const volumeViewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
+ volumeViewport.setCamera(prevCamera);
+
+ volumeViewport.element.removeEventListener(
+ Enums.Events.VOLUME_VIEWPORT_NEW_VOLUME,
+ createNewSegmentationWhenVolumeMounts
+ );
+
+ if (!isTheActiveViewportVolumeMounted) {
+ // it means it is one of those other updated viewports so just update the camera
+ return;
+ }
+
+ if (viewportId === targetViewportId) {
+ await createSegmentationForVolume();
+ }
+ };
+
+ csViewport.element.addEventListener(
+ Enums.Events.VOLUME_VIEWPORT_NEW_VOLUME,
+ createNewSegmentationWhenVolumeMounts
+ );
+ });
+
+ // Set the displaySets for the viewports that require to be updated
+ viewportGridService.setDisplaySetsForViewports(updatedViewports);
+
+ return true;
+}
+
+const getTargetViewport = ({ viewportId, viewportGridService }) => {
+ const { viewports, activeViewportId } = viewportGridService.getState();
+ const targetViewportId = viewportId || activeViewportId;
+
+ const viewport = viewports.get(targetViewportId);
+
+ return viewport;
+};
+
+/**
+ * Retrieves a list of viewports that require updates in preparation for segmentation rendering.
+ * This function evaluates viewports based on their compatibility with the provided segmentation's
+ * frame of reference UID and appends them to the updated list if they should render the segmentation.
+ *
+ * @param {Object} params - Parameters for the function.
+ * @param params.viewportId - the ID of the viewport to be updated.
+ * @param params.servicesManager - The services manager
+ * @param params.referencedDisplaySetInstanceUID - Optional UID for the referenced display set instance.
+ *
+ * @returns {Array} Returns an array of viewports that require updates for segmentation rendering.
+ */
+function getUpdatedViewportsForSegmentation({
+ viewportId,
+ servicesManager,
+ referencedDisplaySetInstanceUID,
+}) {
+ const { hangingProtocolService, displaySetService, segmentationService, viewportGridService } =
+ servicesManager.services;
+
+ const { viewports } = viewportGridService.getState();
+
+ const viewport = getTargetViewport({ viewportId, viewportGridService });
+ const targetViewportId = viewport.viewportOptions.viewportId;
+
+ const displaySetInstanceUIDs = viewports.get(targetViewportId).displaySetInstanceUIDs;
+
+ const referenceDisplaySetInstanceUID =
+ referencedDisplaySetInstanceUID || displaySetInstanceUIDs[0];
+
+ const referencedDisplaySet = displaySetService.getDisplaySetByUID(referenceDisplaySetInstanceUID);
+ const segmentationFrameOfReferenceUID = referencedDisplaySet.instances[0].FrameOfReferenceUID;
+
+ const updatedViewports = hangingProtocolService.getViewportsRequireUpdate(
+ targetViewportId,
+ referenceDisplaySetInstanceUID
+ );
+
+ viewports.forEach((viewport, viewportId) => {
+ if (
+ targetViewportId === viewportId ||
+ updatedViewports.find(v => v.viewportId === viewportId)
+ ) {
+ return;
+ }
+
+ const shouldDisplaySeg = segmentationService.shouldRenderSegmentation(
+ viewport.displaySetInstanceUIDs,
+ segmentationFrameOfReferenceUID
+ );
+
+ if (shouldDisplaySeg) {
+ updatedViewports.push({
+ viewportId,
+ displaySetInstanceUIDs: viewport.displaySetInstanceUIDs,
+ viewportOptions: {
+ viewportType: 'volume',
+ needsRerendering: true,
+ },
+ });
+ }
+ });
+ return updatedViewports;
+}
+
+export {
+ updateViewportsForSegmentationRendering,
+ getUpdatedViewportsForSegmentation,
+ getTargetViewport,
+};
diff --git a/extensions/cornerstone-dicom-seg/src/utils/initSEGToolGroup.ts b/extensions/cornerstone-dicom-seg/src/utils/initSEGToolGroup.ts
index e032542f13..8ddc088c6c 100644
--- a/extensions/cornerstone-dicom-seg/src/utils/initSEGToolGroup.ts
+++ b/extensions/cornerstone-dicom-seg/src/utils/initSEGToolGroup.ts
@@ -1,12 +1,7 @@
-function createSEGToolGroupAndAddTools(
- ToolGroupService,
- customizationService,
- toolGroupId
-) {
- const { tools } =
- customizationService.get('cornerstone.overlayViewportTools') ?? {};
+function createSEGToolGroupAndAddTools(ToolGroupService, customizationService, toolGroupId) {
+ const { tools } = customizationService.get('cornerstone.overlayViewportTools') ?? {};
- return ToolGroupService.createToolGroupAndAddTools(toolGroupId, tools, {});
+ return ToolGroupService.createToolGroupAndAddTools(toolGroupId, tools);
}
export default createSEGToolGroupAndAddTools;
diff --git a/extensions/cornerstone-dicom-seg/src/utils/promptHydrateSEG.ts b/extensions/cornerstone-dicom-seg/src/utils/promptHydrateSEG.ts
index c0b9385f13..9f8c1dddf7 100644
--- a/extensions/cornerstone-dicom-seg/src/utils/promptHydrateSEG.ts
+++ b/extensions/cornerstone-dicom-seg/src/utils/promptHydrateSEG.ts
@@ -1,4 +1,4 @@
-import hydrateSEGDisplaySet from './_hydrateSEG';
+import { ButtonEnums } from '@ohif/ui';
const RESPONSE = {
NO_NEVER: -1,
@@ -9,21 +9,23 @@ const RESPONSE = {
function promptHydrateSEG({
servicesManager,
segDisplaySet,
- viewportIndex,
+ viewportId,
+ preHydrateCallbacks,
+ hydrateSEGDisplaySet,
}) {
const { uiViewportDialogService } = servicesManager.services;
- return new Promise(async function(resolve, reject) {
- const promptResult = await _askHydrate(
- uiViewportDialogService,
- viewportIndex
- );
+ return new Promise(async function (resolve, reject) {
+ const promptResult = await _askHydrate(uiViewportDialogService, viewportId);
if (promptResult === RESPONSE.HYDRATE_SEG) {
+ preHydrateCallbacks?.forEach(callback => {
+ callback();
+ });
+
const isHydrated = await hydrateSEGDisplaySet({
segDisplaySet,
- viewportIndex,
- servicesManager,
+ viewportId,
});
resolve(isHydrated);
@@ -31,17 +33,17 @@ function promptHydrateSEG({
});
}
-function _askHydrate(uiViewportDialogService, viewportIndex) {
- return new Promise(function(resolve, reject) {
+function _askHydrate(uiViewportDialogService, viewportId) {
+ return new Promise(function (resolve, reject) {
const message = 'Do you want to open this Segmentation?';
const actions = [
{
- type: 'secondary',
+ type: ButtonEnums.type.secondary,
text: 'No',
value: RESPONSE.CANCEL,
},
{
- type: 'primary',
+ type: ButtonEnums.type.primary,
text: 'Yes',
value: RESPONSE.HYDRATE_SEG,
},
@@ -52,7 +54,7 @@ function _askHydrate(uiViewportDialogService, viewportIndex) {
};
uiViewportDialogService.show({
- viewportIndex,
+ viewportId,
type: 'info',
message,
actions,
diff --git a/extensions/cornerstone-dicom-seg/src/viewports/OHIFCornerstoneSEGViewport.tsx b/extensions/cornerstone-dicom-seg/src/viewports/OHIFCornerstoneSEGViewport.tsx
index 08ed004f07..fb39f8c36f 100644
--- a/extensions/cornerstone-dicom-seg/src/viewports/OHIFCornerstoneSEGViewport.tsx
+++ b/extensions/cornerstone-dicom-seg/src/viewports/OHIFCornerstoneSEGViewport.tsx
@@ -2,14 +2,9 @@ import PropTypes from 'prop-types';
import React, { useCallback, useEffect, useRef, useState } from 'react';
import { useTranslation } from 'react-i18next';
import OHIF, { utils } from '@ohif/core';
-import {
- LoadingIndicatorTotalPercent,
- useViewportGrid,
- ViewportActionBar,
-} from '@ohif/ui';
+import { LoadingIndicatorTotalPercent, useViewportGrid, ViewportActionBar } from '@ohif/ui';
import createSEGToolGroupAndAddTools from '../utils/initSEGToolGroup';
import promptHydrateSEG from '../utils/promptHydrateSEG';
-import hydrateSEGDisplaySet from '../utils/_hydrateSEG';
import _getStatusComponent from './_getStatusComponent';
const { formatDate } = utils;
@@ -20,13 +15,14 @@ function OHIFCornerstoneSEGViewport(props) {
children,
displaySets,
viewportOptions,
- viewportIndex,
viewportLabel,
servicesManager,
extensionManager,
+ commandsManager,
} = props;
const { t } = useTranslation('SEGViewport');
+ const viewportId = viewportOptions.viewportId;
const {
displaySetService,
@@ -36,7 +32,7 @@ function OHIFCornerstoneSEGViewport(props) {
customizationService,
} = servicesManager.services;
- const toolGroupId = `${SEG_TOOLGROUP_BASE_NAME}-${viewportIndex}`;
+ const toolGroupId = `${SEG_TOOLGROUP_BASE_NAME}-${viewportId}`;
// SEG viewport will always have a single display set
if (displaySets.length > 1) {
@@ -48,7 +44,6 @@ function OHIFCornerstoneSEGViewport(props) {
const [viewportGrid, viewportGridService] = useViewportGrid();
// States
- const [isToolGroupCreated, setToolGroupCreated] = useState(false);
const [selectedSegment, setSelectedSegment] = useState(1);
// Hydration means that the SEG is opened and segments are loaded into the
@@ -67,11 +62,12 @@ function OHIFCornerstoneSEGViewport(props) {
// refs
const referencedDisplaySetRef = useRef(null);
- const { viewports, activeViewportIndex } = viewportGrid;
+ const { viewports, activeViewportId } = viewportGrid;
const referencedDisplaySet = segDisplaySet.getReferenceDisplaySet();
const referencedDisplaySetMetadata = _getReferencedDisplaySetMetadata(
- referencedDisplaySet
+ referencedDisplaySet,
+ segDisplaySet
);
referencedDisplaySetRef.current = {
@@ -92,14 +88,20 @@ function OHIFCornerstoneSEGViewport(props) {
setElement(null);
};
+ const storePresentationState = useCallback(() => {
+ viewportGrid?.viewports.forEach(({ viewportId }) => {
+ commandsManager.runCommand('storePresentation', {
+ viewportId,
+ });
+ });
+ }, [viewportGrid]);
+
const getCornerstoneViewport = useCallback(() => {
const { component: Component } = extensionManager.getModuleEntry(
'@ohif/extension-cornerstone.viewportModule.cornerstone'
);
- const {
- displaySet: referencedDisplaySet,
- } = referencedDisplaySetRef.current;
+ const { displaySet: referencedDisplaySet } = referencedDisplaySetRef.current;
// Todo: jump to the center of the first segment
return (
@@ -117,7 +119,7 @@ function OHIFCornerstoneSEGViewport(props) {
// initialImageIndex={initialImageIndex}
>
);
- }, [viewportIndex, segDisplaySet, toolGroupId]);
+ }, [viewportId, segDisplaySet, toolGroupId]);
const onSegmentChange = useCallback(
direction => {
@@ -139,11 +141,7 @@ function OHIFCornerstoneSEGViewport(props) {
newSelectedSegmentIndex = numberOfSegments - 1;
}
- segmentationService.jumpToSegmentCenter(
- segmentationId,
- newSelectedSegmentIndex,
- toolGroupId
- );
+ segmentationService.jumpToSegmentCenter(segmentationId, newSelectedSegmentIndex, toolGroupId);
setSelectedSegment(newSelectedSegmentIndex);
},
[selectedSegment]
@@ -156,31 +154,29 @@ function OHIFCornerstoneSEGViewport(props) {
promptHydrateSEG({
servicesManager,
- viewportIndex,
+ viewportId,
segDisplaySet,
+ preHydrateCallbacks: [storePresentationState],
+ hydrateSEGDisplaySet,
}).then(isHydrated => {
if (isHydrated) {
setIsHydrated(true);
}
});
- }, [servicesManager, viewportIndex, segDisplaySet, segIsLoading]);
+ }, [servicesManager, viewportId, segDisplaySet, segIsLoading]);
useEffect(() => {
const { unsubscribe } = segmentationService.subscribe(
segmentationService.EVENTS.SEGMENTATION_LOADING_COMPLETE,
evt => {
- if (
- evt.segDisplaySet.displaySetInstanceUID ===
- segDisplaySet.displaySetInstanceUID
- ) {
+ if (evt.segDisplaySet.displaySetInstanceUID === segDisplaySet.displaySetInstanceUID) {
setSegIsLoading(false);
}
if (evt.overlappingSegments) {
uiNotificationService.show({
title: 'Overlapping Segments',
- message:
- 'Overlapping segments detected which is not currently supported',
+ message: 'Overlapping segments detected which is not currently supported',
type: 'warning',
});
}
@@ -215,12 +211,10 @@ function OHIFCornerstoneSEGViewport(props) {
const onDisplaySetsRemovedSubscription = displaySetService.subscribe(
displaySetService.EVENTS.DISPLAY_SETS_REMOVED,
({ displaySetInstanceUIDs }) => {
- const activeViewport = viewports[activeViewportIndex];
- if (
- displaySetInstanceUIDs.includes(activeViewport.displaySetInstanceUID)
- ) {
+ const activeViewport = viewports.get(activeViewportId);
+ if (displaySetInstanceUIDs.includes(activeViewport.displaySetInstanceUID)) {
viewportGridService.setDisplaySetsForViewport({
- viewportIndex: activeViewportIndex,
+ viewportId: activeViewportId,
displaySetInstanceUIDs: [],
});
}
@@ -241,19 +235,11 @@ function OHIFCornerstoneSEGViewport(props) {
// This creates a custom tool group which has the lifetime of this view
// only, and does NOT interfere with currently displayed segmentations.
- toolGroup = createSEGToolGroupAndAddTools(
- toolGroupService,
- customizationService,
- toolGroupId
- );
-
- setToolGroupCreated(true);
+ toolGroup = createSEGToolGroupAndAddTools(toolGroupService, customizationService, toolGroupId);
return () => {
// remove the segmentation representations if seg displayset changed
- segmentationService.removeSegmentationRepresentationFromToolGroup(
- toolGroupId
- );
+ segmentationService.removeSegmentationRepresentationFromToolGroup(toolGroupId);
// Only destroy the viewport specific implementation
toolGroupService.destroyToolGroup(toolGroupId);
@@ -265,9 +251,7 @@ function OHIFCornerstoneSEGViewport(props) {
return () => {
// remove the segmentation representations if seg displayset changed
- segmentationService.removeSegmentationRepresentationFromToolGroup(
- toolGroupId
- );
+ segmentationService.removeSegmentationRepresentationFromToolGroup(toolGroupId);
referencedDisplaySetRef.current = null;
};
}, [segDisplaySet]);
@@ -288,7 +272,7 @@ function OHIFCornerstoneSEGViewport(props) {
return (
child &&
React.cloneElement(child, {
- viewportIndex,
+ viewportId,
key: index,
})
);
@@ -307,16 +291,28 @@ function OHIFCornerstoneSEGViewport(props) {
SpacingBetweenSlices,
} = referencedDisplaySetRef.current.metadata;
+ const hydrateSEGDisplaySet = ({ segDisplaySet, viewportId }) => {
+ commandsManager.runCommand('loadSegmentationDisplaySetsForViewport', {
+ displaySets: [segDisplaySet],
+ viewportId,
+ });
+ };
+
const onStatusClick = async () => {
+ // Before hydrating a SEG and make it added to all viewports in the grid
+ // that share the same frameOfReferenceUID, we need to store the viewport grid
+ // presentation state, so that we can restore it after hydrating the SEG. This is
+ // required if the user has changed the viewport (other viewport than SEG viewport)
+ // presentation state (w/l and invert) and then opens the SEG. If we don't store
+ // the presentation state, the viewport will be reset to the default presentation
+ storePresentationState();
const isHydrated = await hydrateSEGDisplaySet({
segDisplaySet,
- viewportIndex,
- servicesManager,
+ viewportId,
});
setIsHydrated(isHydrated);
};
-
return (
<>
- {/* show segmentation table */}
- {segmentations?.length ? (
+ <>
+
- _setSegmentationConfiguration(
- selectedSegmentationId,
- 'renderOutline',
- value
- )
+ _setSegmentationConfiguration(selectedSegmentationId, 'renderOutline', value)
}
setOutlineOpacityActive={value =>
- _setSegmentationConfiguration(
- selectedSegmentationId,
- 'outlineOpacity',
- value
- )
+ _setSegmentationConfiguration(selectedSegmentationId, 'outlineOpacity', value)
}
setRenderFill={value =>
- _setSegmentationConfiguration(
- selectedSegmentationId,
- 'renderFill',
- value
- )
+ _setSegmentationConfiguration(selectedSegmentationId, 'renderFill', value)
}
setRenderInactiveSegmentations={value =>
_setSegmentationConfiguration(
@@ -238,29 +256,17 @@ export default function PanelSegmentation({
)
}
setOutlineWidthActive={value =>
- _setSegmentationConfiguration(
- selectedSegmentationId,
- 'outlineWidthActive',
- value
- )
+ _setSegmentationConfiguration(selectedSegmentationId, 'outlineWidthActive', value)
}
setFillAlpha={value =>
- _setSegmentationConfiguration(
- selectedSegmentationId,
- 'fillAlpha',
- value
- )
+ _setSegmentationConfiguration(selectedSegmentationId, 'fillAlpha', value)
}
setFillAlphaInactive={value =>
- _setSegmentationConfiguration(
- selectedSegmentationId,
- 'fillAlphaInactive',
- value
- )
+ _setSegmentationConfiguration(selectedSegmentationId, 'fillAlphaInactive', value)
}
/>
- ) : null}
-
+
+
);
}
diff --git a/extensions/cornerstone-dicom-seg/src/panels/SegmentationToolbox.tsx b/extensions/cornerstone-dicom-seg/src/panels/SegmentationToolbox.tsx
new file mode 100644
index 0000000000..674ae3d2e6
--- /dev/null
+++ b/extensions/cornerstone-dicom-seg/src/panels/SegmentationToolbox.tsx
@@ -0,0 +1,405 @@
+import React, { useCallback, useEffect, useState, useReducer } from 'react';
+import { AdvancedToolbox, InputDoubleRange, useViewportGrid } from '@ohif/ui';
+import { Types } from '@ohif/extension-cornerstone';
+import { utilities } from '@cornerstonejs/tools';
+
+const { segmentation: segmentationUtils } = utilities;
+
+const TOOL_TYPES = {
+ CIRCULAR_BRUSH: 'CircularBrush',
+ SPHERE_BRUSH: 'SphereBrush',
+ CIRCULAR_ERASER: 'CircularEraser',
+ SPHERE_ERASER: 'SphereEraser',
+ CIRCLE_SCISSOR: 'CircleScissor',
+ RECTANGLE_SCISSOR: 'RectangleScissor',
+ SPHERE_SCISSOR: 'SphereScissor',
+ THRESHOLD_CIRCULAR_BRUSH: 'ThresholdCircularBrush',
+ THRESHOLD_SPHERE_BRUSH: 'ThresholdSphereBrush',
+};
+
+const ACTIONS = {
+ SET_TOOL_CONFIG: 'SET_TOOL_CONFIG',
+ SET_ACTIVE_TOOL: 'SET_ACTIVE_TOOL',
+};
+
+const initialState = {
+ Brush: {
+ brushSize: 15,
+ mode: 'CircularBrush', // Can be 'CircularBrush' or 'SphereBrush'
+ },
+ Eraser: {
+ brushSize: 15,
+ mode: 'CircularEraser', // Can be 'CircularEraser' or 'SphereEraser'
+ },
+ Scissors: {
+ brushSize: 15,
+ mode: 'CircleScissor', // E.g., 'CircleScissor', 'RectangleScissor', or 'SphereScissor'
+ },
+ ThresholdBrush: {
+ brushSize: 15,
+ thresholdRange: [-500, 500],
+ },
+ activeTool: null,
+};
+
+function toolboxReducer(state, action) {
+ switch (action.type) {
+ case ACTIONS.SET_TOOL_CONFIG:
+ const { tool, config } = action.payload;
+ return {
+ ...state,
+ [tool]: {
+ ...state[tool],
+ ...config,
+ },
+ };
+ case ACTIONS.SET_ACTIVE_TOOL:
+ return { ...state, activeTool: action.payload };
+ default:
+ return state;
+ }
+}
+
+function SegmentationToolbox({ servicesManager, extensionManager }) {
+ const { toolbarService, segmentationService, toolGroupService } =
+ servicesManager.services as Types.CornerstoneServices;
+
+ const [viewportGrid] = useViewportGrid();
+ const { viewports, activeViewportId } = viewportGrid;
+
+ const [toolsEnabled, setToolsEnabled] = useState(false);
+ const [state, dispatch] = useReducer(toolboxReducer, initialState);
+
+ const updateActiveTool = useCallback(() => {
+ if (!viewports?.size || activeViewportId === undefined) {
+ return;
+ }
+ const viewport = viewports.get(activeViewportId);
+
+ if (!viewport) {
+ return;
+ }
+
+ dispatch({
+ type: ACTIONS.SET_ACTIVE_TOOL,
+ payload: toolGroupService.getActiveToolForViewport(viewport.viewportId),
+ });
+ }, [activeViewportId, viewports, toolGroupService, dispatch]);
+
+ const setToolActive = useCallback(
+ toolName => {
+ toolbarService.recordInteraction({
+ interactionType: 'tool',
+ commands: [
+ {
+ commandName: 'setToolActive',
+ commandOptions: {
+ toolName,
+ },
+ },
+ ],
+ });
+
+ dispatch({ type: ACTIONS.SET_ACTIVE_TOOL, payload: toolName });
+ },
+ [toolbarService, dispatch]
+ );
+
+ /**
+ * sets the tools enabled IF there are segmentations
+ */
+ useEffect(() => {
+ const events = [
+ segmentationService.EVENTS.SEGMENTATION_ADDED,
+ segmentationService.EVENTS.SEGMENTATION_UPDATED,
+ segmentationService.EVENTS.SEGMENTATION_REMOVED,
+ ];
+
+ const unsubscriptions = [];
+
+ events.forEach(event => {
+ const { unsubscribe } = segmentationService.subscribe(event, () => {
+ const segmentations = segmentationService.getSegmentations();
+
+ const activeSegmentation = segmentations?.find(seg => seg.isActive);
+
+ setToolsEnabled(activeSegmentation?.segmentCount > 0);
+ });
+
+ unsubscriptions.push(unsubscribe);
+ });
+
+ updateActiveTool();
+
+ return () => {
+ unsubscriptions.forEach(unsubscribe => unsubscribe());
+ };
+ }, [activeViewportId, viewports, segmentationService, updateActiveTool]);
+
+ /**
+ * Update the active tool when the toolbar state changes
+ */
+ useEffect(() => {
+ const { unsubscribe } = toolbarService.subscribe(
+ toolbarService.EVENTS.TOOL_BAR_STATE_MODIFIED,
+ () => {
+ updateActiveTool();
+ }
+ );
+
+ return () => {
+ unsubscribe();
+ };
+ }, [toolbarService, updateActiveTool]);
+
+ useEffect(() => {
+ // if the active tool is not a brush tool then do nothing
+ if (!Object.values(TOOL_TYPES).includes(state.activeTool)) {
+ return;
+ }
+
+ // if the tool is Segmentation and it is enabled then do nothing
+ if (toolsEnabled) {
+ return;
+ }
+
+ // if the tool is Segmentation and it is disabled, then switch
+ // back to the window level tool to not confuse the user when no
+ // segmentation is active or when there is no segment in the segmentation
+ setToolActive('WindowLevel');
+ }, [toolsEnabled, state.activeTool, setToolActive]);
+
+ const updateBrushSize = useCallback(
+ (toolName, brushSize) => {
+ toolGroupService.getToolGroupIds()?.forEach(toolGroupId => {
+ segmentationUtils.setBrushSizeForToolGroup(toolGroupId, brushSize, toolName);
+ });
+ },
+ [toolGroupService]
+ );
+
+ const onBrushSizeChange = useCallback(
+ (valueAsStringOrNumber, toolCategory) => {
+ const value = Number(valueAsStringOrNumber);
+
+ _getToolNamesFromCategory(toolCategory).forEach(toolName => {
+ updateBrushSize(toolName, value);
+ });
+
+ dispatch({
+ type: ACTIONS.SET_TOOL_CONFIG,
+ payload: {
+ tool: toolCategory,
+ config: { brushSize: value },
+ },
+ });
+ },
+ [toolGroupService, dispatch]
+ );
+
+ const handleRangeChange = useCallback(
+ newRange => {
+ if (
+ newRange[0] === state.ThresholdBrush.thresholdRange[0] &&
+ newRange[1] === state.ThresholdBrush.thresholdRange[1]
+ ) {
+ return;
+ }
+
+ const toolNames = _getToolNamesFromCategory('ThresholdBrush');
+
+ toolNames.forEach(toolName => {
+ toolGroupService.getToolGroupIds()?.forEach(toolGroupId => {
+ const toolGroup = toolGroupService.getToolGroup(toolGroupId);
+ toolGroup.setToolConfiguration(toolName, {
+ strategySpecificConfiguration: {
+ THRESHOLD_INSIDE_CIRCLE: {
+ threshold: newRange,
+ },
+ },
+ });
+ });
+ });
+
+ dispatch({
+ type: ACTIONS.SET_TOOL_CONFIG,
+ payload: {
+ tool: 'ThresholdBrush',
+ config: { thresholdRange: newRange },
+ },
+ });
+ },
+ [toolGroupService, dispatch, state.ThresholdBrush.thresholdRange]
+ );
+
+ return (
+
+
+
+ );
+ },
+ },
+ ],
+ },
+ ]}
+ />
+ );
+}
+
+function _getToolNamesFromCategory(category) {
+ let toolNames = [];
+ switch (category) {
+ case 'Brush':
+ toolNames = ['CircularBrush', 'SphereBrush'];
+ break;
+ case 'Eraser':
+ toolNames = ['CircularEraser', 'SphereEraser'];
+ break;
+ case 'ThresholdBrush':
+ toolNames = ['ThresholdCircularBrush', 'ThresholdSphereBrush'];
+ break;
+ default:
+ break;
+ }
+
+ return toolNames;
+}
+
+export default SegmentationToolbox;
diff --git a/extensions/cornerstone-dicom-seg/src/panels/callInputDialog.tsx b/extensions/cornerstone-dicom-seg/src/panels/callInputDialog.tsx
index 69c3034697..6de2470d8b 100644
--- a/extensions/cornerstone-dicom-seg/src/panels/callInputDialog.tsx
+++ b/extensions/cornerstone-dicom-seg/src/panels/callInputDialog.tsx
@@ -1,5 +1,5 @@
import React from 'react';
-import { Input, Dialog } from '@ohif/ui';
+import { Input, Dialog, ButtonEnums } from '@ohif/ui';
function callInputDialog(uiDialogService, label, callback) {
const dialogId = 'enter-segment-label';
@@ -29,8 +29,8 @@ function callInputDialog(uiDialogService, label, callback) {
noCloseButton: true,
onClose: () => uiDialogService.dismiss({ id: dialogId }),
actions: [
- { id: 'cancel', text: 'Cancel', type: 'primary' },
- { id: 'save', text: 'Confirm', type: 'secondary' },
+ { id: 'cancel', text: 'Cancel', type: ButtonEnums.type.secondary },
+ { id: 'save', text: 'Confirm', type: ButtonEnums.type.primary },
],
onSubmit: onSubmitHandler,
body: ({ value, setValue }) => {
@@ -39,7 +39,7 @@ function callInputDialog(uiDialogService, label, callback) {
label="Enter the segment label"
labelClassName="text-white text-[14px] leading-[1.2]"
autoFocus
- className="bg-black border-primary-main"
+ className="border-primary-main bg-black"
type="text"
value={value.label}
onChange={event => {
diff --git a/extensions/cornerstone-dicom-seg/src/panels/colorPickerDialog.css b/extensions/cornerstone-dicom-seg/src/panels/colorPickerDialog.css
new file mode 100644
index 0000000000..1c6bb20670
--- /dev/null
+++ b/extensions/cornerstone-dicom-seg/src/panels/colorPickerDialog.css
@@ -0,0 +1,3 @@
+.chrome-picker {
+ background: #090c29 !important;
+}
diff --git a/extensions/cornerstone-dicom-seg/src/panels/colorPickerDialog.tsx b/extensions/cornerstone-dicom-seg/src/panels/colorPickerDialog.tsx
new file mode 100644
index 0000000000..38e85efb29
--- /dev/null
+++ b/extensions/cornerstone-dicom-seg/src/panels/colorPickerDialog.tsx
@@ -0,0 +1,58 @@
+import React from 'react';
+import { Dialog } from '@ohif/ui';
+import { ChromePicker } from 'react-color';
+
+import './colorPickerDialog.css';
+
+function callColorPickerDialog(uiDialogService, rgbaColor, callback) {
+ const dialogId = 'pick-color';
+
+ const onSubmitHandler = ({ action, value }) => {
+ switch (action.id) {
+ case 'save':
+ callback(value.rgbaColor, action.id);
+ break;
+ case 'cancel':
+ callback('', action.id);
+ break;
+ }
+ uiDialogService.dismiss({ id: dialogId });
+ };
+
+ if (uiDialogService) {
+ uiDialogService.create({
+ id: dialogId,
+ centralize: true,
+ isDraggable: false,
+ showOverlay: true,
+ content: Dialog,
+ contentProps: {
+ title: 'Segment Color',
+ value: { rgbaColor },
+ noCloseButton: true,
+ onClose: () => uiDialogService.dismiss({ id: dialogId }),
+ actions: [
+ { id: 'cancel', text: 'Cancel', type: 'primary' },
+ { id: 'save', text: 'Save', type: 'secondary' },
+ ],
+ onSubmit: onSubmitHandler,
+ body: ({ value, setValue }) => {
+ const handleChange = color => {
+ setValue({ rgbaColor: color.rgb });
+ };
+
+ return (
+ Threshold
+
+
{segIsLoading && (
This Segmentation is loaded in the segmentation panel
- );
+ ToolTipMessage = () => This Segmentation is loaded in the segmentation panel
;
break;
- case false:
- StatusIcon = () => Click LOAD to load segmentation.
;
}
const StatusArea = () => (
-
-
+
+
>(
- utilities.math.ellipse.getCanvasEllipseCorners([
- canvasCoordinates[2],
- canvasCoordinates[3],
- canvasCoordinates[0],
- canvasCoordinates[1],
- ])
- );
+ canvasCorners = utilities.math.ellipse.getCanvasEllipseCorners([
+ canvasCoordinates[2],
+ canvasCoordinates[3],
+ canvasCoordinates[0],
+ canvasCoordinates[1],
+ ]) as Array;
} else {
- canvasCorners = >(
- utilities.math.ellipse.getCanvasEllipseCorners(canvasCoordinates)
- );
+ canvasCorners = utilities.math.ellipse.getCanvasEllipseCorners(
+ canvasCoordinates
+ ) as Array;
}
const lineUID = `${index}`;
@@ -368,23 +337,14 @@ export default class DICOMSRDisplayTool extends AnnotationTool {
adaptedCanvasCoordinates = canvasCoordinatesAdapter(canvasCoordinates);
}
const textLines = this._getTextBoxLinesFromLabels(label);
- const canvasTextBoxCoords = utilities.drawing.getTextBoxCoordsCanvas(
- adaptedCanvasCoordinates
- );
+ const canvasTextBoxCoords = utilities.drawing.getTextBoxCoordsCanvas(adaptedCanvasCoordinates);
- annotation.data.handles.textBox.worldPosition = viewport.canvasToWorld(
- canvasTextBoxCoords
- );
+ annotation.data.handles.textBox.worldPosition = viewport.canvasToWorld(canvasTextBoxCoords);
- const textBoxPosition = viewport.worldToCanvas(
- annotation.data.handles.textBox.worldPosition
- );
+ const textBoxPosition = viewport.worldToCanvas(annotation.data.handles.textBox.worldPosition);
const textBoxUID = '1';
- const textBoxOptions = this.getLinkedTextBoxStyle(
- styleSpecifier,
- annotation
- );
+ const textBoxOptions = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
const boundingBox = drawing.drawLinkedTextBox(
svgDrawingHelper,
diff --git a/extensions/cornerstone-dicom-sr/src/tools/modules/dicomSRModule.js b/extensions/cornerstone-dicom-sr/src/tools/modules/dicomSRModule.js
index f359e3d273..5636e6563d 100644
--- a/extensions/cornerstone-dicom-sr/src/tools/modules/dicomSRModule.js
+++ b/extensions/cornerstone-dicom-sr/src/tools/modules/dicomSRModule.js
@@ -27,15 +27,11 @@ function setTrackingUniqueIdentifiersForElement(
};
}
-function setActiveTrackingUniqueIdentifierForElement(
- element,
- TrackingUniqueIdentifier
-) {
+function setActiveTrackingUniqueIdentifierForElement(element, TrackingUniqueIdentifier) {
const enabledElement = getEnabledElement(element);
const { viewport } = enabledElement;
- const trackingIdentifiersForElement =
- state.trackingIdentifiersByViewportId[viewport.id];
+ const trackingIdentifiersForElement = state.trackingIdentifiersByViewportId[viewport.id];
if (trackingIdentifiersForElement) {
const activeIndex = trackingIdentifiersForElement.trackingUniqueIdentifiers.findIndex(
diff --git a/extensions/cornerstone-dicom-sr/src/utils/addMeasurement.ts b/extensions/cornerstone-dicom-sr/src/utils/addMeasurement.ts
index ac8e43003f..e78b3c7f15 100644
--- a/extensions/cornerstone-dicom-sr/src/utils/addMeasurement.ts
+++ b/extensions/cornerstone-dicom-sr/src/utils/addMeasurement.ts
@@ -8,11 +8,7 @@ const EPSILON = 1e-4;
const supportedLegacyCornerstoneTags = ['cornerstoneTools@^4.0.0'];
-export default function addMeasurement(
- measurement,
- imageId,
- displaySetInstanceUID
-) {
+export default function addMeasurement(measurement, imageId, displaySetInstanceUID) {
// TODO -> Render rotated ellipse .
const toolName = toolNames.DICOMSRDisplay;
@@ -31,12 +27,7 @@ export default function addMeasurement(
}
measurementData.renderableData[GraphicType].push(
- _getRenderableData(
- GraphicType,
- GraphicData,
- imageId,
- measurement.TrackingIdentifier
- )
+ _getRenderableData(GraphicType, GraphicData, imageId, measurement.TrackingIdentifier)
);
});
@@ -86,12 +77,7 @@ export default function addMeasurement(
delete measurement.coords;
}
-function _getRenderableData(
- GraphicType,
- GraphicData,
- imageId,
- TrackingIdentifier
-) {
+function _getRenderableData(GraphicType, GraphicData, imageId, TrackingIdentifier) {
const [cornerstoneTag, toolName] = TrackingIdentifier.split(':');
let renderableData: csTypes.Point3[];
@@ -207,38 +193,22 @@ function _getRenderableData(
throw new Error('imageId does not have imagePlaneModule metadata');
}
- const {
- columnCosines,
- }: { columnCosines: csTypes.Point3 } = imagePlaneModule;
+ const { columnCosines }: { columnCosines: csTypes.Point3 } = imagePlaneModule;
// find which axis is parallel to the columnCosines
const columnCosinesVec = vec3.fromValues(...columnCosines);
- const projectedMajorAxisOnColVec = Math.abs(
- vec3.dot(columnCosinesVec, majorAxisVec)
- );
- const projectedMinorAxisOnColVec = Math.abs(
- vec3.dot(columnCosinesVec, minorAxisVec)
- );
+ const projectedMajorAxisOnColVec = Math.abs(vec3.dot(columnCosinesVec, majorAxisVec));
+ const projectedMinorAxisOnColVec = Math.abs(vec3.dot(columnCosinesVec, minorAxisVec));
const absoluteOfMajorDotProduct = Math.abs(projectedMajorAxisOnColVec);
const absoluteOfMinorDotProduct = Math.abs(projectedMinorAxisOnColVec);
renderableData = [];
if (Math.abs(absoluteOfMajorDotProduct - 1) < EPSILON) {
- renderableData = [
- pointsWorld[0],
- pointsWorld[1],
- pointsWorld[2],
- pointsWorld[3],
- ];
+ renderableData = [pointsWorld[0], pointsWorld[1], pointsWorld[2], pointsWorld[3]];
} else if (Math.abs(absoluteOfMinorDotProduct - 1) < EPSILON) {
- renderableData = [
- pointsWorld[2],
- pointsWorld[3],
- pointsWorld[0],
- pointsWorld[1],
- ];
+ renderableData = [pointsWorld[2], pointsWorld[3], pointsWorld[0], pointsWorld[1]];
} else {
console.warn('OBLIQUE ELLIPSE NOT YET SUPPORTED');
}
diff --git a/extensions/cornerstone-dicom-sr/src/utils/addToolInstance.ts b/extensions/cornerstone-dicom-sr/src/utils/addToolInstance.ts
index 889926d812..bd4cf2d1e9 100644
--- a/extensions/cornerstone-dicom-sr/src/utils/addToolInstance.ts
+++ b/extensions/cornerstone-dicom-sr/src/utils/addToolInstance.ts
@@ -1,10 +1,6 @@
import { addTool } from '@cornerstonejs/tools';
-export default function addToolInstance(
- name: string,
- toolClass,
- configuration?
-): void {
+export default function addToolInstance(name: string, toolClass, configuration?): void {
class InstanceClass extends toolClass {
static toolName = name;
}
diff --git a/extensions/cornerstone-dicom-sr/src/utils/createReferencedImageDisplaySet.ts b/extensions/cornerstone-dicom-sr/src/utils/createReferencedImageDisplaySet.ts
index a1dd42d2c2..7241641651 100644
--- a/extensions/cornerstone-dicom-sr/src/utils/createReferencedImageDisplaySet.ts
+++ b/extensions/cornerstone-dicom-sr/src/utils/createReferencedImageDisplaySet.ts
@@ -3,12 +3,11 @@ import { DisplaySetService, classes } from '@ohif/core';
const ImageSet = classes.ImageSet;
const findInstance = (measurement, displaySetService: DisplaySetService) => {
- const { displaySetInstanceUID, ReferencedSOPInstanceUID: sopUid } =
- measurement;
- const referencedDisplaySet = displaySetService.getDisplaySetByUID(
- displaySetInstanceUID
- );
- if (!referencedDisplaySet.images) return;
+ const { displaySetInstanceUID, ReferencedSOPInstanceUID: sopUid } = measurement;
+ const referencedDisplaySet = displaySetService.getDisplaySetByUID(displaySetInstanceUID);
+ if (!referencedDisplaySet.images) {
+ return;
+ }
return referencedDisplaySet.images.find(it => it.SOPInstanceUID === sopUid);
};
@@ -16,16 +15,17 @@ const findInstance = (measurement, displaySetService: DisplaySetService) => {
* contained within the provided display set.
* @return an array of instances referenced.
*/
-const findReferencedInstances = (
- displaySetService: DisplaySetService,
- displaySet
-) => {
+const findReferencedInstances = (displaySetService: DisplaySetService, displaySet) => {
const instances = [];
const instanceById = {};
for (const measurement of displaySet.measurements) {
const { imageId } = measurement;
- if (!imageId) continue;
- if (instanceById[imageId]) continue;
+ if (!imageId) {
+ continue;
+ }
+ if (instanceById[imageId]) {
+ continue;
+ }
const instance = findInstance(measurement, displaySetService);
if (!instance) {
@@ -50,7 +50,7 @@ const findReferencedInstances = (
const createReferencedImageDisplaySet = (displaySetService, displaySet) => {
const instances = findReferencedInstances(displaySetService, displaySet);
// This will be a member function of the created image set
- const updateInstances = function() {
+ const updateInstances = function () {
this.images.splice(
0,
this.images.length,
diff --git a/extensions/cornerstone-dicom-sr/src/utils/findInstanceMetadataBySopInstanceUid.js b/extensions/cornerstone-dicom-sr/src/utils/findInstanceMetadataBySopInstanceUid.js
index 99ffbe0b54..30e6815765 100644
--- a/extensions/cornerstone-dicom-sr/src/utils/findInstanceMetadataBySopInstanceUid.js
+++ b/extensions/cornerstone-dicom-sr/src/utils/findInstanceMetadataBySopInstanceUid.js
@@ -9,11 +9,12 @@ const findInstanceMetadataBySopInstanceUID = (displaySets, SOPInstanceUID) => {
let instanceFound;
displaySets.find(displaySet => {
- if (!displaySet.images) return false;
+ if (!displaySet.images) {
+ return false;
+ }
instanceFound = displaySet.images.find(
- instanceMetadata =>
- instanceMetadata.getSOPInstanceUID() === SOPInstanceUID
+ instanceMetadata => instanceMetadata.getSOPInstanceUID() === SOPInstanceUID
);
return !!instanceFound;
diff --git a/extensions/cornerstone-dicom-sr/src/utils/findMostRecentStructuredReport.js b/extensions/cornerstone-dicom-sr/src/utils/findMostRecentStructuredReport.js
index 9f8a3129ad..138d72df98 100644
--- a/extensions/cornerstone-dicom-sr/src/utils/findMostRecentStructuredReport.js
+++ b/extensions/cornerstone-dicom-sr/src/utils/findMostRecentStructuredReport.js
@@ -18,10 +18,7 @@ const findMostRecentStructuredReport = studies => {
}
if (isStructuredReportSeries(series)) {
- if (
- !mostRecentStructuredReport ||
- compareSeriesDate(series, mostRecentStructuredReport)
- ) {
+ if (!mostRecentStructuredReport || compareSeriesDate(series, mostRecentStructuredReport)) {
mostRecentStructuredReport = series;
}
}
@@ -38,10 +35,7 @@ const findMostRecentStructuredReport = studies => {
* @returns {boolean}
*/
const isStructuredReportSeries = series => {
- const supportedSopClassUIDs = [
- '1.2.840.10008.5.1.4.1.1.88.22',
- '1.2.840.10008.5.1.4.1.1.11.1',
- ];
+ const supportedSopClassUIDs = ['1.2.840.10008.5.1.4.1.1.88.22', '1.2.840.10008.5.1.4.1.1.11.1'];
const firstInstance = series.getFirstInstance();
const SOPClassUID = firstInstance.getData().metadata.SOPClassUID;
@@ -50,7 +44,7 @@ const isStructuredReportSeries = series => {
};
/**
- * Checkes if series1 is newer than series2
+ * Checks if series1 is newer than series2
*
* @param {Object} series1 - Series Metadata 1
* @param {Object} series2 - Series Metadata 2
diff --git a/extensions/cornerstone-dicom-sr/src/utils/getFilteredCornerstoneToolState.ts b/extensions/cornerstone-dicom-sr/src/utils/getFilteredCornerstoneToolState.ts
index 18c5b8465e..2c28311d57 100644
--- a/extensions/cornerstone-dicom-sr/src/utils/getFilteredCornerstoneToolState.ts
+++ b/extensions/cornerstone-dicom-sr/src/utils/getFilteredCornerstoneToolState.ts
@@ -2,17 +2,12 @@ import OHIF from '@ohif/core';
import { annotation } from '@cornerstonejs/tools';
const { log } = OHIF;
-function getFilteredCornerstoneToolState(
- measurementData,
- additionalFindingTypes
-) {
+function getFilteredCornerstoneToolState(measurementData, additionalFindingTypes) {
const filteredToolState = {};
function addToFilteredToolState(annotation, toolType) {
if (!annotation.metadata?.referencedImageId) {
- log.warn(
- `[DICOMSR] No referencedImageId found for ${toolType} ${annotation.id}`
- );
+ log.warn(`[DICOMSR] No referencedImageId found for ${toolType} ${annotation.id}`);
return;
}
@@ -30,9 +25,7 @@ function getFilteredCornerstoneToolState(
};
}
- const measurementDataI = measurementData.find(
- md => md.uid === annotation.annotationUID
- );
+ const measurementDataI = measurementData.find(md => md.uid === annotation.annotationUID);
const toolData = imageIdSpecificToolState[toolType].data;
let { finding } = measurementDataI;
@@ -77,9 +70,7 @@ function getFilteredCornerstoneToolState(
for (let i = 0; i < framesOfReference.length; i++) {
const frameOfReference = framesOfReference[i];
- const frameOfReferenceAnnotations = annotationManager.getAnnotations(
- frameOfReference
- );
+ const frameOfReferenceAnnotations = annotationManager.getAnnotations(frameOfReference);
const toolTypes = Object.keys(frameOfReferenceAnnotations);
@@ -91,9 +82,7 @@ function getFilteredCornerstoneToolState(
if (annotations) {
for (let k = 0; k < annotations.length; k++) {
const annotation = annotations[k];
- const uidIndex = uids.findIndex(
- uid => uid === annotation.annotationUID
- );
+ const uidIndex = uids.findIndex(uid => uid === annotation.annotationUID);
if (uidIndex !== -1) {
addToFilteredToolState(annotation, toolType);
diff --git a/extensions/cornerstone-dicom-sr/src/utils/getLabelFromDCMJSImportedToolData.js b/extensions/cornerstone-dicom-sr/src/utils/getLabelFromDCMJSImportedToolData.js
index 18a2ad1f5c..1fa18ee9c5 100644
--- a/extensions/cornerstone-dicom-sr/src/utils/getLabelFromDCMJSImportedToolData.js
+++ b/extensions/cornerstone-dicom-sr/src/utils/getLabelFromDCMJSImportedToolData.js
@@ -9,9 +9,7 @@
export default function getLabelFromDCMJSImportedToolData(toolData) {
const { findingSites = [], finding } = toolData;
- let freeTextLabel = findingSites.find(
- fs => fs.CodeValue === 'CORNERSTONEFREETEXT'
- );
+ let freeTextLabel = findingSites.find(fs => fs.CodeValue === 'CORNERSTONEFREETEXT');
if (freeTextLabel) {
return freeTextLabel.CodeMeaning;
diff --git a/extensions/cornerstone-dicom-sr/src/utils/hydrateStructuredReport.js b/extensions/cornerstone-dicom-sr/src/utils/hydrateStructuredReport.js
index 346bfc5db1..17216a8442 100644
--- a/extensions/cornerstone-dicom-sr/src/utils/hydrateStructuredReport.js
+++ b/extensions/cornerstone-dicom-sr/src/utils/hydrateStructuredReport.js
@@ -2,6 +2,8 @@ import { utilities, metaData } from '@cornerstonejs/core';
import OHIF, { DicomMetadataStore } from '@ohif/core';
import getLabelFromDCMJSImportedToolData from './getLabelFromDCMJSImportedToolData';
import { adaptersSR } from '@cornerstonejs/adapters';
+import { annotation as CsAnnotation } from '@cornerstonejs/tools';
+const { locking } = CsAnnotation;
const { guid } = OHIF.utils;
const { MeasurementReport, CORNERSTONE_3D_TAG } = adaptersSR.Cornerstone3D;
@@ -12,20 +14,26 @@ const CORNERSTONE_3D_TOOLS_SOURCE_VERSION = '0.1';
const supportedLegacyCornerstoneTags = ['cornerstoneTools@^4.0.0'];
const convertCode = (codingValues, code) => {
- if (!code || code.CodingSchemeDesignator === 'CORNERSTONEJS') return;
+ if (!code || code.CodingSchemeDesignator === 'CORNERSTONEJS') {
+ return;
+ }
const ref = `${code.CodingSchemeDesignator}:${code.CodeValue}`;
const ret = { ...codingValues[ref], ref, ...code, text: code.CodeMeaning };
return ret;
};
const convertSites = (codingValues, sites) => {
- if (!sites || !sites.length) return;
+ if (!sites || !sites.length) {
+ return;
+ }
const ret = [];
// Do as a loop to convert away from Proxy instances
for (let i = 0; i < sites.length; i++) {
// Deal with irregular conversion from dcmjs
const site = convertCode(codingValues, sites[i][0] || sites[i]);
- if (site) ret.push(site);
+ if (site) {
+ ret.push(site);
+ }
}
return (ret.length && ret) || undefined;
};
@@ -35,23 +43,16 @@ const convertSites = (codingValues, sites) => {
*
*/
export default function hydrateStructuredReport(
- { servicesManager, extensionManager },
+ { servicesManager, extensionManager, appConfig },
displaySetInstanceUID
) {
+ const annotationManager = CsAnnotation.state.getAnnotationManager();
+ const disableEditing = appConfig?.disableEditing;
const dataSource = extensionManager.getActiveDataSource()[0];
- const {
- measurementService,
- displaySetService,
- customizationService,
- } = servicesManager.services;
-
- const codingValues = customizationService.getCustomization(
- 'codingValues',
- {}
- );
- const displaySet = displaySetService.getDisplaySetByUID(
- displaySetInstanceUID
- );
+ const { measurementService, displaySetService, customizationService } = servicesManager.services;
+
+ const codingValues = customizationService.getCustomization('codingValues', {});
+ const displaySet = displaySetService.getDisplaySetByUID(displaySetInstanceUID);
// TODO -> We should define a strict versioning somewhere.
const mappings = measurementService.getSourceMappings(
@@ -115,16 +116,14 @@ export default function hydrateStructuredReport(
// TODO: notification if no hydratable?
Object.keys(hydratableMeasurementsInSR).forEach(annotationType => {
- const toolDataForAnnotationType =
- hydratableMeasurementsInSR[annotationType];
+ const toolDataForAnnotationType = hydratableMeasurementsInSR[annotationType];
toolDataForAnnotationType.forEach(toolData => {
// Add the measurement to toolState
// dcmjs and Cornerstone3D has structural defect in supporting multi-frame
// files, and looking up the imageId from sopInstanceUIDToImageId results
// in the wrong value.
- const frameNumber =
- (toolData.annotation.data && toolData.annotation.data.frameNumber) || 1;
+ const frameNumber = (toolData.annotation.data && toolData.annotation.data.frameNumber) || 1;
const imageId =
imageIdsForToolState[toolData.sopInstanceUid][frameNumber] ||
sopInstanceUIDToImageId[toolData.sopInstanceUid];
@@ -140,10 +139,7 @@ export default function hydrateStructuredReport(
for (let i = 0; i < imageIds.length; i++) {
const imageId = imageIds[i];
- const { SeriesInstanceUID, StudyInstanceUID } = metaData.get(
- 'instance',
- imageId
- );
+ const { SeriesInstanceUID, StudyInstanceUID } = metaData.get('instance', imageId);
if (!SeriesInstanceUIDs.includes(SeriesInstanceUID)) {
SeriesInstanceUIDs.push(SeriesInstanceUID);
@@ -152,23 +148,19 @@ export default function hydrateStructuredReport(
if (!targetStudyInstanceUID) {
targetStudyInstanceUID = StudyInstanceUID;
} else if (targetStudyInstanceUID !== StudyInstanceUID) {
- console.warn(
- 'NO SUPPORT FOR SRs THAT HAVE MEASUREMENTS FROM MULTIPLE STUDIES.'
- );
+ console.warn('NO SUPPORT FOR SRs THAT HAVE MEASUREMENTS FROM MULTIPLE STUDIES.');
}
}
Object.keys(hydratableMeasurementsInSR).forEach(annotationType => {
- const toolDataForAnnotationType =
- hydratableMeasurementsInSR[annotationType];
+ const toolDataForAnnotationType = hydratableMeasurementsInSR[annotationType];
toolDataForAnnotationType.forEach(toolData => {
// Add the measurement to toolState
// dcmjs and Cornerstone3D has structural defect in supporting multi-frame
// files, and looking up the imageId from sopInstanceUIDToImageId results
// in the wrong value.
- const frameNumber =
- (toolData.annotation.data && toolData.annotation.data.frameNumber) || 1;
+ const frameNumber = (toolData.annotation.data && toolData.annotation.data.frameNumber) || 1;
const imageId =
imageIdsForToolState[toolData.sopInstanceUid][frameNumber] ||
sopInstanceUIDToImageId[toolData.sopInstanceUid];
@@ -198,21 +190,13 @@ export default function hydrateStructuredReport(
CORNERSTONE_3D_TOOLS_SOURCE_VERSION
);
annotation.data.label = getLabelFromDCMJSImportedToolData(toolData);
- annotation.data.finding = convertCode(
- codingValues,
- toolData.finding?.[0]
- );
- annotation.data.findingSites = convertSites(
- codingValues,
- toolData.findingSites
- );
+ annotation.data.finding = convertCode(codingValues, toolData.finding?.[0]);
+ annotation.data.findingSites = convertSites(codingValues, toolData.findingSites);
annotation.data.site = annotation.data.findingSites?.[0];
- const matchingMapping = mappings.find(
- m => m.annotationType === annotationType
- );
+ const matchingMapping = mappings.find(m => m.annotationType === annotationType);
- measurementService.addRawMeasurement(
+ const newAnnotationUID = measurementService.addRawMeasurement(
source,
annotationType,
{ annotation },
@@ -220,6 +204,11 @@ export default function hydrateStructuredReport(
dataSource
);
+ if (disableEditing) {
+ const addedAnnotation = annotationManager.getAnnotation(newAnnotationUID);
+ locking.setAnnotationLocked(addedAnnotation, true);
+ }
+
if (!imageIds.includes(imageId)) {
imageIds.push(imageId);
}
@@ -245,15 +234,14 @@ function _mapLegacyDataSet(dataset) {
);
// Retrieve the Measurements themselves
- const measurementGroups = toArray(
- imagingMeasurementContent.ContentSequence
- ).filter(codeMeaningEquals(GROUP));
+ 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 cornerstoneToolClasses = MeasurementReport.CORNERSTONE_TOOL_CLASSES_BY_UTILITY_TYPE;
const registeredToolClasses = [];
@@ -263,13 +251,10 @@ function _mapLegacyDataSet(dataset) {
});
measurementGroups.forEach((measurementGroup, index) => {
- const measurementGroupContentSequence = toArray(
- measurementGroup.ContentSequence
- );
+ const measurementGroupContentSequence = toArray(measurementGroup.ContentSequence);
const TrackingIdentifierGroup = measurementGroupContentSequence.find(
- contentItem =>
- contentItem.ConceptNameCodeSequence.CodeMeaning === TRACKING_IDENTIFIER
+ contentItem => contentItem.ConceptNameCodeSequence.CodeMeaning === TRACKING_IDENTIFIER
);
const TrackingIdentifier = TrackingIdentifierGroup.TextValue;
diff --git a/extensions/cornerstone-dicom-sr/src/utils/isRehydratable.js b/extensions/cornerstone-dicom-sr/src/utils/isRehydratable.js
index 41602dd257..d6f6a74841 100644
--- a/extensions/cornerstone-dicom-sr/src/utils/isRehydratable.js
+++ b/extensions/cornerstone-dicom-sr/src/utils/isRehydratable.js
@@ -1,8 +1,7 @@
import { adaptersSR } from '@cornerstonejs/adapters';
const cornerstoneAdapters =
- adaptersSR.Cornerstone3D.MeasurementReport
- .CORNERSTONE_TOOL_CLASSES_BY_UTILITY_TYPE;
+ adaptersSR.Cornerstone3D.MeasurementReport.CORNERSTONE_TOOL_CLASSES_BY_UTILITY_TYPE;
const supportedLegacyCornerstoneTags = ['cornerstoneTools@^4.0.0'];
const CORNERSTONE_3D_TAG = cornerstoneAdapters.CORNERSTONE_3D_TAG;
@@ -24,8 +23,7 @@ export default function isRehydratable(displaySet, mappings) {
const adapterKeys = Object.keys(cornerstoneAdapters).filter(
adapterKey =>
- typeof cornerstoneAdapters[adapterKey]
- .isValidCornerstoneTrackingIdentifier === 'function'
+ typeof cornerstoneAdapters[adapterKey].isValidCornerstoneTrackingIdentifier === 'function'
);
const adapters = [];
@@ -48,19 +46,13 @@ export default function isRehydratable(displaySet, mappings) {
const mappedTrackingIdentifier = `${cornerstoneTag}:${toolName}`;
- return adapter.isValidCornerstoneTrackingIdentifier(
- mappedTrackingIdentifier
- );
+ return adapter.isValidCornerstoneTrackingIdentifier(mappedTrackingIdentifier);
});
if (hydratable) {
return true;
}
- console.log(
- 'Measurement is not rehydratable',
- TrackingIdentifier,
- measurements[i]
- );
+ console.log('Measurement is not rehydratable', TrackingIdentifier, measurements[i]);
}
console.log('No measurements found which were rehydratable');
diff --git a/extensions/cornerstone-dicom-sr/src/viewports/OHIFCornerstoneSRViewport.tsx b/extensions/cornerstone-dicom-sr/src/viewports/OHIFCornerstoneSRViewport.tsx
index 8d56f400d3..a1e728bdda 100644
--- a/extensions/cornerstone-dicom-sr/src/viewports/OHIFCornerstoneSRViewport.tsx
+++ b/extensions/cornerstone-dicom-sr/src/viewports/OHIFCornerstoneSRViewport.tsx
@@ -7,11 +7,11 @@ import { setTrackingUniqueIdentifiersForElement } from '../tools/modules/dicomSR
import { Icon, Tooltip, useViewportGrid, ViewportActionBar } from '@ohif/ui';
import hydrateStructuredReport from '../utils/hydrateStructuredReport';
+import { useAppConfig } from '@state';
const { formatDate } = utils;
-const MEASUREMENT_TRACKING_EXTENSION_ID =
- '@ohif/extension-measurement-tracking';
+const MEASUREMENT_TRACKING_EXTENSION_ID = '@ohif/extension-measurement-tracking';
const SR_TOOLGROUP_BASE_NAME = 'SRToolGroup';
@@ -20,18 +20,18 @@ function OHIFCornerstoneSRViewport(props) {
children,
dataSource,
displaySets,
- viewportIndex,
viewportLabel,
viewportOptions,
servicesManager,
extensionManager,
} = props;
- const {
- displaySetService,
- cornerstoneViewportService,
- measurementService,
- } = servicesManager.services;
+ const [appConfig] = useAppConfig();
+
+ const { displaySetService, cornerstoneViewportService, measurementService } =
+ servicesManager.services;
+
+ const viewportId = viewportOptions.viewportId;
// SR viewport will always have a single display set
if (displaySets.length > 1) {
@@ -43,15 +43,10 @@ function OHIFCornerstoneSRViewport(props) {
const [viewportGrid, viewportGridService] = useViewportGrid();
const [measurementSelected, setMeasurementSelected] = useState(0);
const [measurementCount, setMeasurementCount] = useState(1);
- const [activeImageDisplaySetData, setActiveImageDisplaySetData] = useState(
- null
- );
- const [
- referencedDisplaySetMetadata,
- setReferencedDisplaySetMetadata,
- ] = useState(null);
+ const [activeImageDisplaySetData, setActiveImageDisplaySetData] = useState(null);
+ const [referencedDisplaySetMetadata, setReferencedDisplaySetMetadata] = useState(null);
const [element, setElement] = useState(null);
- const { viewports, activeViewportIndex } = viewportGrid;
+ const { viewports, activeViewportId } = viewportGrid;
// Optional hook into tracking extension, if present.
let trackedMeasurements;
@@ -76,16 +71,14 @@ function OHIFCornerstoneSRViewport(props) {
sendTrackedMeasurementsEvent = (eventName, { displaySetInstanceUID }) => {
measurementService.clearMeasurements();
const { SeriesInstanceUIDs } = hydrateStructuredReport(
- { servicesManager, extensionManager },
+ { servicesManager, extensionManager, appConfig },
displaySetInstanceUID
);
- const displaySets = displaySetService.getDisplaySetsForSeries(
- SeriesInstanceUIDs[0]
- );
+ const displaySets = displaySetService.getDisplaySetsForSeries(SeriesInstanceUIDs[0]);
if (displaySets.length) {
viewportGridService.setDisplaySetsForViewports([
{
- viewportIndex: activeViewportIndex,
+ viewportId: activeViewportId,
displaySetInstanceUIDs: [displaySets[0].displaySetInstanceUID],
},
]);
@@ -123,11 +116,7 @@ function OHIFCornerstoneSRViewport(props) {
const updateViewport = useCallback(
newMeasurementSelected => {
- const {
- StudyInstanceUID,
- displaySetInstanceUID,
- sopClassUids,
- } = srDisplaySet;
+ const { StudyInstanceUID, displaySetInstanceUID, sopClassUids } = srDisplaySet;
if (!StudyInstanceUID || !displaySetInstanceUID) {
return;
@@ -136,9 +125,7 @@ function OHIFCornerstoneSRViewport(props) {
if (sopClassUids && sopClassUids.length > 1) {
// Todo: what happens if there are multiple SOP Classes? Why we are
// not throwing an error?
- console.warn(
- 'More than one SOPClassUID in the same series is not yet supported.'
- );
+ console.warn('More than one SOPClassUID in the same series is not yet supported.');
}
_getViewportReferencedDisplaySetData(
@@ -160,19 +147,11 @@ function OHIFCornerstoneSRViewport(props) {
// imageIdIndex will handle it by updating the viewport, but if they
// are the same we just need to use measurementService to jump to the
// new measurement
- const viewportInfo = cornerstoneViewportService.getViewportInfoByIndex(
- viewportIndex
- );
-
- const csViewport = cornerstoneViewportService.getCornerstoneViewport(
- viewportInfo.getViewportId()
- );
+ const csViewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
const imageIds = csViewport.getImageIds();
- const imageIdIndex = imageIds.indexOf(
- measurements[newMeasurementSelected].imageId
- );
+ const imageIdIndex = imageIds.indexOf(measurements[newMeasurementSelected].imageId);
if (imageIdIndex !== -1) {
csViewport.setImageIdIndex(imageIdIndex);
@@ -180,7 +159,7 @@ function OHIFCornerstoneSRViewport(props) {
}
});
},
- [dataSource, srDisplaySet, activeImageDisplaySetData, viewportIndex]
+ [dataSource, srDisplaySet, activeImageDisplaySetData, viewportId]
);
const getCornerstoneViewport = useCallback(() => {
@@ -225,9 +204,10 @@ function OHIFCornerstoneSRViewport(props) {
}}
onElementEnabled={onElementEnabled}
initialImageIndex={initialImageIndex}
+ isJumpToMeasurementDisabled={true}
>
);
- }, [activeImageDisplaySetData, viewportIndex, measurementSelected]);
+ }, [activeImageDisplaySetData, viewportId, measurementSelected]);
const onMeasurementChange = useCallback(
direction => {
@@ -250,12 +230,7 @@ function OHIFCornerstoneSRViewport(props) {
setTrackingIdentifiers(newMeasurementSelected);
updateViewport(newMeasurementSelected);
},
- [
- measurementSelected,
- measurementCount,
- updateViewport,
- setTrackingIdentifiers,
- ]
+ [measurementSelected, measurementCount, updateViewport, setTrackingIdentifiers]
);
/**
@@ -265,12 +240,10 @@ function OHIFCornerstoneSRViewport(props) {
const onDisplaySetsRemovedSubscription = displaySetService.subscribe(
displaySetService.EVENTS.DISPLAY_SETS_REMOVED,
({ displaySetInstanceUIDs }) => {
- const activeViewport = viewports[activeViewportIndex];
- if (
- displaySetInstanceUIDs.includes(activeViewport.displaySetInstanceUID)
- ) {
+ const activeViewport = viewports.get(activeViewportId);
+ if (displaySetInstanceUIDs.includes(activeViewport.displaySetInstanceUID)) {
viewportGridService.setDisplaySetsForViewport({
- viewportIndex: activeViewportIndex,
+ viewportId: activeViewportId,
displaySetInstanceUIDs: [],
});
}
@@ -337,7 +310,7 @@ function OHIFCornerstoneSRViewport(props) {
return (
child &&
React.cloneElement(child, {
- viewportIndex,
+ viewportId,
key: index,
})
);
@@ -369,7 +342,7 @@ function OHIFCornerstoneSRViewport(props) {
getStatusComponent={() =>
_getStatusComponent({
srDisplaySet,
- viewportIndex,
+ viewportId,
isTracked: false,
isRehydratable: srDisplaySet.isRehydratable,
isLocked,
@@ -383,23 +356,19 @@ function OHIFCornerstoneSRViewport(props) {
currentSeries: SeriesNumber,
seriesDescription: SeriesDescription || '',
patientInformation: {
- patientName: PatientName
- ? OHIF.utils.formatPN(PatientName.Alphabetic)
- : '',
+ patientName: PatientName ? OHIF.utils.formatPN(PatientName.Alphabetic) : '',
patientSex: PatientSex || '',
patientAge: PatientAge || '',
MRN: PatientID || '',
thickness: SliceThickness ? `${SliceThickness.toFixed(2)}mm` : '',
spacing:
- SpacingBetweenSlices !== undefined
- ? `${SpacingBetweenSlices.toFixed(2)}mm`
- : '',
+ SpacingBetweenSlices !== undefined ? `${SpacingBetweenSlices.toFixed(2)}mm` : '',
scanner: ManufacturerModelName || '',
},
}}
/>
-
@@ -42,11 +44,13 @@ export default function _getStatusComponent({ isHydrated, onStatusClick }) {
);
-
return (
<>
{ToolTipMessage && (
-
+
{getCornerstoneViewport()}
{childrenWithProps}
@@ -409,7 +378,7 @@ function OHIFCornerstoneSRViewport(props) {
OHIFCornerstoneSRViewport.propTypes = {
displaySets: PropTypes.arrayOf(PropTypes.object),
- viewportIndex: PropTypes.number.isRequired,
+ viewportId: PropTypes.string.isRequired,
dataSource: PropTypes.object,
children: PropTypes.node,
viewportLabel: PropTypes.string,
@@ -434,9 +403,7 @@ async function _getViewportReferencedDisplaySetData(
const { displaySetInstanceUID } = measurement;
- const referencedDisplaySet = displaySetService.getDisplaySetByUID(
- displaySetInstanceUID
- );
+ const referencedDisplaySet = displaySetService.getDisplaySetByUID(displaySetInstanceUID);
const image0 = referencedDisplaySet.images[0];
const referencedDisplaySetMetadata = {
@@ -458,7 +425,7 @@ async function _getViewportReferencedDisplaySetData(
function _getStatusComponent({
srDisplaySet,
- viewportIndex,
+ viewportId,
isRehydratable,
isLocked,
sendTrackedMeasurementsEvent,
@@ -466,7 +433,7 @@ function _getStatusComponent({
const handleMouseUp = () => {
sendTrackedMeasurementsEvent('HYDRATE_SR', {
displaySetInstanceUID: srDisplaySet.displaySetInstanceUID,
- viewportIndex,
+ viewportId,
});
};
@@ -476,8 +443,7 @@ function _getStatusComponent({
// 1 - Incompatible
// 2 - Locked
// 3 - Rehydratable / Open
- const state =
- isRehydratable && !isLocked ? 3 : isRehydratable && isLocked ? 2 : 1;
+ const state = isRehydratable && !isLocked ? 3 : isRehydratable && isLocked ? 2 : 1;
let ToolTipMessage = null;
let StatusIcon = null;
@@ -507,22 +473,25 @@ function _getStatusComponent({
);
break;
case 3:
- StatusIcon = () => {`Click ${loadStr} to restore measurements.`}
+ StatusIcon = () => (
+ {`Click ${loadStr} to restore measurements.`}
;
}
const StatusArea = () => (
-
-
+
+
onImageScrollbarChange(evt, viewportIndex)}
- max={
- imageSliceData.numberOfSlices ? imageSliceData.numberOfSlices - 1 : 0
- }
+ onChange={evt => onImageScrollbarChange(evt, viewportId)}
+ max={imageSliceData.numberOfSlices ? imageSliceData.numberOfSlices - 1 : 0}
height={scrollbarHeight}
value={imageSliceData.imageIndex}
/>
@@ -143,7 +120,7 @@ function CornerstoneImageScrollbar({
CornerstoneImageScrollbar.propTypes = {
viewportData: PropTypes.object,
- viewportIndex: PropTypes.number.isRequired,
+ viewportId: PropTypes.string.isRequired,
element: PropTypes.instanceOf(Element),
scrollbarHeight: PropTypes.string,
imageSliceData: PropTypes.object.isRequired,
diff --git a/extensions/cornerstone/src/Viewport/Overlays/ViewportImageSliceLoadingIndicator.tsx b/extensions/cornerstone/src/Viewport/Overlays/ViewportImageSliceLoadingIndicator.tsx
index fc483b5f47..70e03e534c 100644
--- a/extensions/cornerstone/src/Viewport/Overlays/ViewportImageSliceLoadingIndicator.tsx
+++ b/extensions/cornerstone/src/Viewport/Overlays/ViewportImageSliceLoadingIndicator.tsx
@@ -33,26 +33,14 @@ function ViewportImageSliceLoadingIndicator({ viewportData, element }) {
};
useEffect(() => {
- element.addEventListener(
- Enums.Events.STACK_VIEWPORT_SCROLL,
- setLoadingState
- );
+ element.addEventListener(Enums.Events.STACK_VIEWPORT_SCROLL, setLoadingState);
element.addEventListener(Enums.Events.IMAGE_LOAD_ERROR, setErrorState);
- element.addEventListener(
- Enums.Events.STACK_NEW_IMAGE,
- setFinishLoadingState
- );
+ element.addEventListener(Enums.Events.STACK_NEW_IMAGE, setFinishLoadingState);
return () => {
- element.removeEventListener(
- Enums.Events.STACK_VIEWPORT_SCROLL,
- setLoadingState
- );
+ element.removeEventListener(Enums.Events.STACK_VIEWPORT_SCROLL, setLoadingState);
- element.removeEventListener(
- Enums.Events.STACK_NEW_IMAGE,
- setFinishLoadingState
- );
+ element.removeEventListener(Enums.Events.STACK_NEW_IMAGE, setFinishLoadingState);
element.removeEventListener(Enums.Events.IMAGE_LOAD_ERROR, setErrorState);
};
@@ -61,8 +49,8 @@ function ViewportImageSliceLoadingIndicator({ viewportData, element }) {
if (error) {
return (
<>
-
@@ -535,7 +504,10 @@ function _getStatusComponent({
return (
<>
{ToolTipMessage && (
-
- cineService.setCine({
- id: activeViewportIndex,
- isPlaying,
- })
- }
- onFrameRateChange={frameRate =>
- cineService.setCine({
- id: activeViewportIndex,
- frameRate,
- })
- }
- />
- )}
+
- {viewportDialogState.viewportIndex === viewportIndex && (
+ {viewportDialogState.viewportId === viewportId && (
displaySet.displaySetInstanceUID
- );
const { unsubscribe } = measurementService.subscribe(
MeasurementService.EVENTS.JUMP_TO_MEASUREMENT_VIEWPORT,
props => {
cacheJumpToMeasurementEvent = props;
- const { viewportIndex: jumpIndex, measurement, isConsumed } = props;
- if (!measurement || isConsumed) return;
+ const { viewportId: jumpId, measurement, isConsumed } = props;
+ if (!measurement || isConsumed) {
+ return;
+ }
if (cacheJumpToMeasurementEvent.cornerstoneViewport === undefined) {
// Decide on which viewport should handle this
- cacheJumpToMeasurementEvent.cornerstoneViewport = cornerstoneViewportService.getViewportIndexToJump(
- jumpIndex,
- measurement.displaySetInstanceUID,
- { referencedImageId: measurement.referencedImageId }
- );
+ cacheJumpToMeasurementEvent.cornerstoneViewport =
+ cornerstoneViewportService.getViewportIdToJump(
+ jumpId,
+ measurement.displaySetInstanceUID,
+ { referencedImageId: measurement.referencedImageId }
+ );
}
- if (cacheJumpToMeasurementEvent.cornerstoneViewport !== viewportIndex) {
+ if (cacheJumpToMeasurementEvent.cornerstoneViewport !== viewportId) {
return;
}
_jumpToMeasurement(
measurement,
elementRef,
- viewportIndex,
+ viewportId,
measurementService,
displaySetService,
viewportGridService,
@@ -590,20 +438,22 @@ function _checkForCachedJumpToMeasurementEvents(
measurementService,
displaySetService,
elementRef,
- viewportIndex,
+ viewportId,
displaySets,
viewportGridService,
cornerstoneViewportService
) {
- if (!cacheJumpToMeasurementEvent) return;
+ if (!cacheJumpToMeasurementEvent) {
+ return;
+ }
if (cacheJumpToMeasurementEvent.isConsumed) {
cacheJumpToMeasurementEvent = null;
return;
}
- const displaysUIDs = displaySets.map(
- displaySet => displaySet.displaySetInstanceUID
- );
- if (!displaysUIDs?.length) return;
+ const displaysUIDs = displaySets.map(displaySet => displaySet.displaySetInstanceUID);
+ if (!displaysUIDs?.length) {
+ return;
+ }
// Jump to measurement if the measurement exists
const { measurement } = cacheJumpToMeasurementEvent;
@@ -612,7 +462,7 @@ function _checkForCachedJumpToMeasurementEvents(
_jumpToMeasurement(
measurement,
elementRef,
- viewportIndex,
+ viewportId,
measurementService,
displaySetService,
viewportGridService,
@@ -625,7 +475,7 @@ function _checkForCachedJumpToMeasurementEvents(
function _jumpToMeasurement(
measurement,
targetElementRef,
- viewportIndex,
+ viewportId,
measurementService,
displaySetService,
viewportGridService,
@@ -639,27 +489,19 @@ function _jumpToMeasurement(
return;
}
- const referencedDisplaySet = displaySetService.getDisplaySetByUID(
- displaySetInstanceUID
- );
+ const referencedDisplaySet = displaySetService.getDisplaySetByUID(displaySetInstanceUID);
// Todo: setCornerstoneMeasurementActive should be handled by the toolGroupManager
// to set it properly
// setCornerstoneMeasurementActive(measurement);
- viewportGridService.setActiveViewportIndex(viewportIndex);
+ viewportGridService.setActiveViewportId(viewportId);
const enabledElement = getEnabledElement(targetElement);
- const viewportInfo = cornerstoneViewportService.getViewportInfoByIndex(
- viewportIndex
- );
-
if (enabledElement) {
// See how the jumpToSlice() of Cornerstone3D deals with imageIdx param.
- const viewport = enabledElement.viewport as
- | IStackViewport
- | IVolumeViewport;
+ const viewport = enabledElement.viewport as IStackViewport | IVolumeViewport;
let imageIdIndex = 0;
let viewportCameraDirectionMatch = true;
@@ -667,14 +509,9 @@ function _jumpToMeasurement(
if (viewport instanceof StackViewport) {
const imageIds = viewport.getImageIds();
imageIdIndex = imageIds.findIndex(imageId => {
- const {
- SOPInstanceUID: aSOPInstanceUID,
- frameNumber: aFrameNumber,
- } = getSOPInstanceAttributes(imageId);
- return (
- aSOPInstanceUID === SOPInstanceUID &&
- (!frameNumber || frameNumber === aFrameNumber)
- );
+ const { SOPInstanceUID: aSOPInstanceUID, frameNumber: aFrameNumber } =
+ getSOPInstanceAttributes(imageId);
+ return aSOPInstanceUID === SOPInstanceUID && (!frameNumber || frameNumber === aFrameNumber);
});
} else {
// for volume viewport we can't rely on the imageIdIndex since it can be
@@ -689,10 +526,7 @@ function _jumpToMeasurement(
// should compare abs for both planes since the direction can be flipped
if (
measurementViewPlane &&
- !csUtils.isEqual(
- measurementViewPlane.map(Math.abs),
- viewportViewPlane.map(Math.abs)
- )
+ !csUtils.isEqual(measurementViewPlane.map(Math.abs), viewportViewPlane.map(Math.abs))
) {
viewportCameraDirectionMatch = false;
}
@@ -716,21 +550,22 @@ function _jumpToMeasurement(
// Component displayName
OHIFCornerstoneViewport.displayName = 'OHIFCornerstoneViewport';
+OHIFCornerstoneViewport.defaultProps = {
+ isJumpToMeasurementDisabled: false,
+};
+
OHIFCornerstoneViewport.propTypes = {
- viewportIndex: PropTypes.number.isRequired,
displaySets: PropTypes.array.isRequired,
dataSource: PropTypes.object.isRequired,
viewportOptions: PropTypes.object,
displaySetOptions: PropTypes.arrayOf(PropTypes.any),
servicesManager: PropTypes.object.isRequired,
onElementEnabled: PropTypes.func,
+ isJumpToMeasurementDisabled: PropTypes.bool,
// Note: you SHOULD NOT use the initialImageIdOrIndex for manipulation
// of the imageData in the OHIFCornerstoneViewport. This prop is used
// to set the initial state of the viewport's first image to render
- initialImageIdOrIndex: PropTypes.oneOfType([
- PropTypes.string,
- PropTypes.number,
- ]),
+ initialImageIdOrIndex: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
};
export default OHIFCornerstoneViewport;
diff --git a/extensions/cornerstone/src/Viewport/Overlays/CornerstoneOverlays.tsx b/extensions/cornerstone/src/Viewport/Overlays/CornerstoneOverlays.tsx
index ea0c42cb90..69f7b10faa 100644
--- a/extensions/cornerstone/src/Viewport/Overlays/CornerstoneOverlays.tsx
+++ b/extensions/cornerstone/src/Viewport/Overlays/CornerstoneOverlays.tsx
@@ -6,7 +6,7 @@ import ViewportOrientationMarkers from './ViewportOrientationMarkers';
import ViewportImageSliceLoadingIndicator from './ViewportImageSliceLoadingIndicator';
function CornerstoneOverlays(props) {
- const { viewportIndex, element, scrollbarHeight, servicesManager } = props;
+ const { viewportId, element, scrollbarHeight, servicesManager } = props;
const { cornerstoneViewportService } = servicesManager.services;
const [imageSliceData, setImageSliceData] = useState({
imageIndex: 0,
@@ -18,7 +18,7 @@ function CornerstoneOverlays(props) {
const { unsubscribe } = cornerstoneViewportService.subscribe(
cornerstoneViewportService.EVENTS.VIEWPORT_DATA_CHANGED,
props => {
- if (props.viewportIndex !== viewportIndex) {
+ if (props.viewportId !== viewportId) {
return;
}
@@ -29,15 +29,14 @@ function CornerstoneOverlays(props) {
return () => {
unsubscribe();
};
- }, [viewportIndex]);
+ }, [viewportId]);
if (!element) {
return null;
}
if (viewportData) {
- const viewportInfo =
- cornerstoneViewportService.getViewportInfoByIndex(viewportIndex);
+ const viewportInfo = cornerstoneViewportService.getViewportInfo(viewportId);
if (viewportInfo?.viewportOptions?.customViewportProps?.hideOverlays) {
return null;
@@ -47,7 +46,7 @@ function CornerstoneOverlays(props) {
return (
);
}
@@ -114,14 +104,11 @@ function CustomizableViewportOverlay({
element,
viewportData,
imageSliceData,
- viewportIndex,
+ viewportId,
servicesManager,
}) {
- const {
- toolbarService,
- cornerstoneViewportService,
- customizationService,
- } = servicesManager.services;
+ const { toolbarService, cornerstoneViewportService, customizationService } =
+ servicesManager.services;
const [voi, setVOI] = useState({ windowCenter: null, windowWidth: null });
const [scale, setScale] = useState(1);
const [activeTools, setActiveTools] = useState([]);
@@ -150,15 +137,10 @@ function CustomizableViewportOverlay({
const instanceNumber = useMemo(() => {
if (viewportData != null) {
- return _getInstanceNumber(
- viewportData,
- viewportIndex,
- imageIndex,
- cornerstoneViewportService
- );
+ return _getInstanceNumber(viewportData, viewportId, imageIndex, cornerstoneViewportService);
}
return null;
- }, [viewportData, viewportIndex, imageIndex, cornerstoneViewportService]);
+ }, [viewportData, viewportId, imageIndex, cornerstoneViewportService]);
/**
* Initial toolbar state
@@ -179,10 +161,7 @@ function CustomizableViewportOverlay({
}
const { lower, upper } = range;
- const { windowWidth, windowCenter } = utilities.windowLevel.toWindowLevel(
- lower,
- upper
- );
+ const { windowWidth, windowCenter } = utilities.windowLevel.toWindowLevel(lower, upper);
setVOI({ windowCenter, windowWidth });
};
@@ -192,7 +171,7 @@ function CustomizableViewportOverlay({
return () => {
element.removeEventListener(Enums.Events.VOI_MODIFIED, updateVOI);
};
- }, [viewportIndex, viewportData, voi, element]);
+ }, [viewportId, viewportData, voi, element]);
/**
* Updating the scale when the viewport changes its zoom
@@ -205,9 +184,7 @@ function CustomizableViewportOverlay({
previousCamera.parallelScale !== camera.parallelScale ||
previousCamera.scale !== camera.scale
) {
- const viewport = cornerstoneViewportService.getCornerstoneViewportByIndex(
- viewportIndex
- );
+ const viewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
if (!viewport) {
return;
@@ -226,8 +203,7 @@ function CustomizableViewportOverlay({
const { spacing } = imageData;
// convert parallel scale to scale
- const scale =
- (element.clientHeight * spacing[0] * 0.5) / camera.parallelScale;
+ const scale = (element.clientHeight * spacing[0] * 0.5) / camera.parallelScale;
setScale(scale);
}
};
@@ -237,7 +213,7 @@ function CustomizableViewportOverlay({
return () => {
element.removeEventListener(Enums.Events.CAMERA_MODIFIED, updateScale);
};
- }, [viewportIndex, viewportData, cornerstoneViewportService, element]);
+ }, [viewportId, viewportData, cornerstoneViewportService, element]);
/**
* Updating the active tools when the toolbar changes
@@ -262,7 +238,7 @@ function CustomizableViewportOverlay({
element,
viewportData,
imageSliceData,
- viewportIndex,
+ viewportId,
servicesManager,
customization: item,
formatters: {
@@ -296,7 +272,7 @@ function CustomizableViewportOverlay({
element,
viewportData,
imageSliceData,
- viewportIndex,
+ viewportId,
servicesManager,
customizationService,
instance,
@@ -343,9 +319,7 @@ function CustomizableViewportOverlay({
return (
<>
{items.map((item, i) => (
-
- {_renderOverlayItem(item)}
-
+ {_renderOverlayItem(item)}
))}
);
@@ -356,9 +330,7 @@ function CustomizableViewportOverlay({
return (
<>
{items.map((item, i) => (
-
- {_renderOverlayItem(item)}
-
+ {_renderOverlayItem(item)}
))}
);
@@ -379,7 +351,7 @@ function _getViewportInstance(viewportData, imageIndex) {
if (viewportData.viewportType === Enums.ViewportType.STACK) {
imageId = viewportData.data.imageIds[imageIndex];
} else if (viewportData.viewportType === Enums.ViewportType.ORTHOGRAPHIC) {
- const volumes = viewportData.volumes;
+ const volumes = viewportData.data;
if (volumes && volumes.length == 1) {
const volume = volumes[0];
imageId = volume.imageIds[imageIndex];
@@ -388,12 +360,7 @@ function _getViewportInstance(viewportData, imageIndex) {
return imageId ? metaData.get('instance', imageId) || {} : {};
}
-function _getInstanceNumber(
- viewportData,
- viewportIndex,
- imageIndex,
- cornerstoneViewportService
-) {
+function _getInstanceNumber(viewportData, viewportId, imageIndex, cornerstoneViewportService) {
let instanceNumber;
if (viewportData.viewportType === Enums.ViewportType.STACK) {
@@ -406,7 +373,7 @@ function _getInstanceNumber(
instanceNumber = _getInstanceNumberFromVolume(
viewportData,
imageIndex,
- viewportIndex,
+ viewportId,
cornerstoneViewportService
);
}
@@ -436,12 +403,7 @@ function _getInstanceNumberFromStack(viewportData, imageIndex) {
// Since volume viewports can be in any view direction, they can render
// a reconstructed image which don't have imageIds; therefore, no instance and instanceNumber
// Here we check if viewport is in the acquisition direction and if so, we get the instanceNumber
-function _getInstanceNumberFromVolume(
- viewportData,
- imageIndex,
- viewportIndex,
- cornerstoneViewportService
-) {
+function _getInstanceNumberFromVolume(viewportData, viewportId, cornerstoneViewportService) {
const volumes = viewportData.volumes;
// Todo: support fusion of acquisition plane which has instanceNumber
@@ -452,9 +414,7 @@ function _getInstanceNumberFromVolume(
const volume = volumes[0];
const { direction, imageIds } = volume;
- const cornerstoneViewport = cornerstoneViewportService.getCornerstoneViewportByIndex(
- viewportIndex
- );
+ const cornerstoneViewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
if (!cornerstoneViewport) {
return;
@@ -477,8 +437,7 @@ function _getInstanceNumberFromVolume(
return {};
}
- const { instanceNumber } =
- metaData.get('generalImageModule', imageId) || {};
+ const { instanceNumber } = metaData.get('generalImageModule', imageId) || {};
return parseInt(instanceNumber);
}
}
@@ -486,7 +445,7 @@ function _getInstanceNumberFromVolume(
CustomizableViewportOverlay.propTypes = {
viewportData: PropTypes.object,
imageIndex: PropTypes.number,
- viewportIndex: PropTypes.number,
+ viewportId: PropTypes.string,
};
export default CustomizableViewportOverlay;
diff --git a/extensions/cornerstone/src/Viewport/Overlays/ViewportImageScrollbar.tsx b/extensions/cornerstone/src/Viewport/Overlays/ViewportImageScrollbar.tsx
index 074e0a969f..2f7b71a45d 100644
--- a/extensions/cornerstone/src/Viewport/Overlays/ViewportImageScrollbar.tsx
+++ b/extensions/cornerstone/src/Viewport/Overlays/ViewportImageScrollbar.tsx
@@ -7,34 +7,24 @@ import { ServicesManger } from '@ohif/core';
function CornerstoneImageScrollbar({
viewportData,
- viewportIndex,
+ viewportId,
element,
imageSliceData,
setImageSliceData,
scrollbarHeight,
servicesManager,
}) {
- const {
- cineService,
- cornerstoneViewportService,
- } = (servicesManager as ServicesManger).services;
+ const { cineService, cornerstoneViewportService } = (servicesManager as ServicesManger).services;
- const onImageScrollbarChange = (imageIndex, viewportIndex) => {
- const viewportInfo = cornerstoneViewportService.getViewportInfoByIndex(
- viewportIndex
- );
-
- const viewportId = viewportInfo.getViewportId();
- const viewport = cornerstoneViewportService.getCornerstoneViewport(
- viewportId
- );
+ const onImageScrollbarChange = (imageIndex, viewportId) => {
+ const viewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
const { isCineEnabled } = cineService.getState();
if (isCineEnabled) {
// on image scrollbar change, stop the CINE if it is playing
cineService.stopClip(element);
- cineService.setCine({ id: viewportIndex, isPlaying: false });
+ cineService.setCine({ id: viewportId, isPlaying: false });
}
csToolsUtils.jumpToSlice(viewport.element, {
@@ -48,9 +38,7 @@ function CornerstoneImageScrollbar({
return;
}
- const viewport = cornerstoneViewportService.getCornerstoneViewportByIndex(
- viewportIndex
- );
+ const viewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
if (!viewport) {
return;
@@ -79,7 +67,7 @@ function CornerstoneImageScrollbar({
const { imageIndex, numberOfSlices } = sliceData;
setImageSliceData({ imageIndex, numberOfSlices });
}
- }, [viewportIndex, viewportData]);
+ }, [viewportId, viewportData]);
useEffect(() => {
if (viewportData?.viewportType !== Enums.ViewportType.STACK) {
@@ -95,16 +83,10 @@ function CornerstoneImageScrollbar({
});
};
- element.addEventListener(
- Enums.Events.STACK_VIEWPORT_SCROLL,
- updateStackIndex
- );
+ element.addEventListener(Enums.Events.STACK_VIEWPORT_SCROLL, updateStackIndex);
return () => {
- element.removeEventListener(
- Enums.Events.STACK_VIEWPORT_SCROLL,
- updateStackIndex
- );
+ element.removeEventListener(Enums.Events.STACK_VIEWPORT_SCROLL, updateStackIndex);
};
}, [viewportData, element]);
@@ -122,19 +104,14 @@ function CornerstoneImageScrollbar({
element.addEventListener(Enums.Events.VOLUME_NEW_IMAGE, updateVolumeIndex);
return () => {
- element.removeEventListener(
- Enums.Events.VOLUME_NEW_IMAGE,
- updateVolumeIndex
- );
+ element.removeEventListener(Enums.Events.VOLUME_NEW_IMAGE, updateVolumeIndex);
};
}, [viewportData, element]);
return (
-
+
+
Error Loading Image
An error has occurred.
@@ -78,8 +66,8 @@ function ViewportImageSliceLoadingIndicator({ viewportData, element }) { return ( // IMPORTANT: we need to use the pointer-events-none class to prevent the loading indicator from // interacting with the mouse, since scrolling should propagate to the viewport underneath -
-
+ {
- const viewportInfo = cornerstoneViewportService.getViewportInfo(
- viewportId
- );
+ const viewportInfo = cornerstoneViewportService.getViewportInfo(viewportId);
if (!viewportInfo) {
console.warn('No viewport found for viewportId:', viewportId);
return;
}
- const viewportIndex = viewportInfo.getViewportIndex();
- viewportGridService.setActiveViewportIndex(viewportIndex);
+ viewportGridService.setActiveViewportId(viewportId);
},
arrowTextCallback: ({ callback, data }) => {
callInputDialog(uiDialogService, data, callback);
@@ -249,9 +230,7 @@ function commandsModule({
const { isCineEnabled } = cineService.getState();
cineService.setIsCineEnabled(!isCineEnabled);
toolbarService.setButton('Cine', { props: { isActive: !isCineEnabled } });
- viewports.forEach((_, index) =>
- cineService.setCine({ id: index, isPlaying: false })
- );
+ viewports.forEach((_, index) => cineService.setCine({ id: index, isPlaying: false }));
},
setWindowLevel({ window, level, toolGroupId }) {
// convert to numbers
@@ -259,9 +238,7 @@ function commandsModule({
const windowCenterNum = Number(level);
const { viewportId } = _getActiveViewportEnabledElement();
- const viewportToolGroupId = toolGroupService.getToolGroupForViewport(
- viewportId
- );
+ const viewportToolGroupId = toolGroupService.getToolGroupForViewport(viewportId);
if (toolGroupId && toolGroupId !== viewportToolGroupId) {
return;
@@ -271,10 +248,7 @@ function commandsModule({
const renderingEngine = cornerstoneViewportService.getRenderingEngine();
const viewport = renderingEngine.getViewport(viewportId);
- const { lower, upper } = csUtils.windowLevel.toLowHighRange(
- windowWidthNum,
- windowCenterNum
- );
+ const { lower, upper } = csUtils.windowLevel.toLowHighRange(windowWidthNum, windowCenterNum);
viewport.setProperties({
voiRange: {
@@ -291,8 +265,7 @@ function commandsModule({
toolbarServiceRecordInteraction: props => {
toolbarService.recordInteraction(props);
},
-
- setToolActive: ({ toolName, toolGroupId = null }) => {
+ setToolActive: ({ toolName, toolGroupId = null, toggledState }) => {
if (toolName === 'Crosshairs') {
const activeViewportToolGroup = toolGroupService.getToolGroup(null);
@@ -309,9 +282,11 @@ function commandsModule({
}
}
- const { viewports } = viewportGridService.getState() || {
- viewports: [],
- };
+ const { viewports } = viewportGridService.getState();
+
+ if (!viewports.size) {
+ return;
+ }
const toolGroup = toolGroupService.getToolGroup(toolGroupId);
const toolGroupViewportIds = toolGroup?.getViewportIds?.();
@@ -321,14 +296,8 @@ function commandsModule({
return;
}
- const filteredViewports = viewports.filter(viewport => {
- if (!viewport.viewportOptions) {
- return false;
- }
-
- return toolGroupViewportIds.includes(
- viewport.viewportOptions.viewportId
- );
+ const filteredViewports = Array.from(viewports.values()).filter(viewport => {
+ return toolGroupViewportIds.includes(viewport.viewportId);
});
if (!filteredViewports.length) {
@@ -357,6 +326,14 @@ function commandsModule({
toolGroup.setToolPassive(activeToolName);
}
}
+
+ // If there is a toggle state, then simply set the enabled/disabled state without
+ // setting the tool active.
+ if (toggledState != null) {
+ toggledState ? toolGroup.setToolEnabled(toolName) : toolGroup.setToolDisabled(toolName);
+ return;
+ }
+
// Set the new toolName to be active
toolGroup.setToolActive(toolName, {
bindings: [
@@ -367,13 +344,9 @@ function commandsModule({
});
},
showDownloadViewportModal: () => {
- const { activeViewportIndex } = viewportGridService.getState();
+ const { activeViewportId } = viewportGridService.getState();
- if (
- !cornerstoneViewportService.getCornerstoneViewportByIndex(
- activeViewportIndex
- )
- ) {
+ if (!cornerstoneViewportService.getCornerstoneViewport(activeViewportId)) {
// Cannot download a non-cornerstone viewport (image).
uiNotificationService.show({
title: 'Download Image',
@@ -390,7 +363,7 @@ function commandsModule({
content: CornerstoneViewportDownloadForm,
title: 'Download High Quality Image',
contentProps: {
- activeViewportIndex,
+ activeViewportId,
onClose: uiModalService.hide,
cornerstoneViewportService,
},
@@ -457,11 +430,9 @@ function commandsModule({
const { viewport } = enabledElement;
- if (viewport instanceof StackViewport) {
- const { invert } = viewport.getProperties();
- viewport.setProperties({ invert: !invert });
- viewport.render();
- }
+ const { invert } = viewport.getProperties();
+ viewport.setProperties({ invert: !invert });
+ viewport.render();
},
resetViewport: () => {
const enabledElement = _getActiveViewportEnabledElement();
@@ -514,9 +485,7 @@ function commandsModule({
}
viewport = enabledElement.viewport;
} else {
- viewport = cornerstoneViewportService.getCornerstoneViewport(
- gridViewport.id
- );
+ viewport = cornerstoneViewportService.getCornerstoneViewport(gridViewport.id);
}
// Get number of slices
@@ -526,14 +495,12 @@ function commandsModule({
if (viewport instanceof StackViewport) {
numberOfSlices = viewport.getImageIds().length;
} else if (viewport instanceof VolumeViewport) {
- numberOfSlices = csUtils.getImageSliceDataForVolumeViewport(viewport)
- .numberOfSlices;
+ numberOfSlices = csUtils.getImageSliceDataForVolumeViewport(viewport).numberOfSlices;
} else {
throw new Error('Unsupported viewport type');
}
- const jumpIndex =
- imageIndex < 0 ? numberOfSlices + imageIndex : imageIndex;
+ const jumpIndex = imageIndex < 0 ? numberOfSlices + imageIndex : imageIndex;
if (jumpIndex >= numberOfSlices || jumpIndex < 0) {
throw new Error(`Can't jump to ${imageIndex}`);
}
@@ -554,15 +521,8 @@ function commandsModule({
cstUtils.scroll(viewport, options);
},
- setViewportColormap: ({
- viewportIndex,
- displaySetInstanceUID,
- colormap,
- immediate = false,
- }) => {
- const viewport = cornerstoneViewportService.getCornerstoneViewportByIndex(
- viewportIndex
- );
+ setViewportColormap: ({ viewportId, displaySetInstanceUID, colormap, immediate = false }) => {
+ const viewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
const actorEntries = viewport.getActors();
@@ -578,17 +538,15 @@ function commandsModule({
viewport.render();
}
},
- incrementActiveViewport: () => {
- const { activeViewportIndex, viewports } = viewportGridService.getState();
- const nextViewportIndex = (activeViewportIndex + 1) % viewports.length;
- viewportGridService.setActiveViewportIndex(nextViewportIndex);
- },
- decrementActiveViewport: () => {
- const { activeViewportIndex, viewports } = viewportGridService.getState();
+ changeActiveViewport: ({ direction = 1 }) => {
+ const { activeViewportId, viewports } = viewportGridService.getState();
+ const viewportIds = Array.from(viewports.keys());
+ const currentIndex = viewportIds.indexOf(activeViewportId);
const nextViewportIndex =
- (activeViewportIndex - 1 + viewports.length) % viewports.length;
- viewportGridService.setActiveViewportIndex(nextViewportIndex);
+ (currentIndex + direction + viewportIds.length) % viewportIds.length;
+ viewportGridService.setActiveViewportId(viewportIds[nextViewportIndex] as string);
},
+
toggleStackImageSync: ({ toggledState }) => {
toggleStackImageSync({
getEnabledElement,
@@ -596,19 +554,13 @@ function commandsModule({
toggledState,
});
},
- toggleReferenceLines: ({ toggledState }) => {
- const { activeViewportIndex } = viewportGridService.getState();
- const viewportInfo = cornerstoneViewportService.getViewportInfoByIndex(
- activeViewportIndex
- );
+ setSourceViewportForReferenceLinesTool: ({ toggledState }) => {
+ const { activeViewportId } = viewportGridService.getState();
+ const viewportInfo = cornerstoneViewportService.getViewportInfo(activeViewportId);
const viewportId = viewportInfo.getViewportId();
const toolGroup = toolGroupService.getToolGroupForViewport(viewportId);
- if (!toggledState) {
- toolGroup.setToolDisabled(ReferenceLinesTool.toolName);
- }
-
toolGroup.setToolConfiguration(
ReferenceLinesTool.toolName,
{
@@ -616,7 +568,9 @@ function commandsModule({
},
true // overwrite
);
- toolGroup.setToolEnabled(ReferenceLinesTool.toolName);
+ },
+ storePresentation: ({ viewportId }) => {
+ cornerstoneViewportService.storePresentation({ viewportId });
},
};
@@ -673,10 +627,11 @@ function commandsModule({
options: { rotation: -90 },
},
incrementActiveViewport: {
- commandFn: actions.incrementActiveViewport,
+ commandFn: actions.changeActiveViewport,
},
decrementActiveViewport: {
- commandFn: actions.decrementActiveViewport,
+ commandFn: actions.changeActiveViewport,
+ options: { direction: -1 },
},
flipViewportHorizontal: {
commandFn: actions.flipViewportHorizontal,
@@ -739,8 +694,13 @@ function commandsModule({
toggleStackImageSync: {
commandFn: actions.toggleStackImageSync,
},
- toggleReferenceLines: {
- commandFn: actions.toggleReferenceLines,
+ setSourceViewportForReferenceLinesTool: {
+ commandFn: actions.setSourceViewportForReferenceLinesTool,
+ },
+ storePresentation: {
+ commandFn: actions.storePresentation,
+ storeContexts: [],
+ options: {},
},
};
diff --git a/extensions/cornerstone/src/components/CinePlayer/CinePlayer.tsx b/extensions/cornerstone/src/components/CinePlayer/CinePlayer.tsx
new file mode 100644
index 0000000000..92bb151032
--- /dev/null
+++ b/extensions/cornerstone/src/components/CinePlayer/CinePlayer.tsx
@@ -0,0 +1,97 @@
+import React, { useEffect } from 'react';
+import { CinePlayer, useCine, useViewportGrid } from '@ohif/ui';
+import { Enums, eventTarget } from '@cornerstonejs/core';
+
+function WrappedCinePlayer({ enabledVPElement, viewportId, servicesManager }) {
+ const { toolbarService, customizationService } = servicesManager.services;
+ const [{ isCineEnabled, cines }, cineService] = useCine();
+ const [{ activeViewportId }] = useViewportGrid();
+
+ const { component: CinePlayerComponent = CinePlayer } =
+ customizationService.get('cinePlayer') ?? {};
+
+ const handleCineClose = () => {
+ toolbarService.recordInteraction({
+ groupId: 'MoreTools',
+ interactionType: 'toggle',
+ commands: [
+ {
+ commandName: 'toggleCine',
+ commandOptions: {},
+ toolName: 'cine',
+ context: 'CORNERSTONE',
+ },
+ ],
+ });
+ };
+
+ const cineHandler = () => {
+ if (!cines || !cines[viewportId] || !enabledVPElement) {
+ return;
+ }
+
+ const cine = cines[viewportId];
+ const isPlaying = cine.isPlaying || false;
+ const frameRate = cine.frameRate || 24;
+
+ const validFrameRate = Math.max(frameRate, 1);
+
+ if (isPlaying) {
+ cineService.playClip(enabledVPElement, {
+ framesPerSecond: validFrameRate,
+ });
+ } else {
+ cineService.stopClip(enabledVPElement);
+ }
+ };
+
+ useEffect(() => {
+ eventTarget.addEventListener(Enums.Events.STACK_VIEWPORT_NEW_STACK, cineHandler);
+
+ return () => {
+ cineService.setCine({ id: viewportId, isPlaying: false });
+ eventTarget.removeEventListener(Enums.Events.STACK_VIEWPORT_NEW_STACK, cineHandler);
+ };
+ }, [enabledVPElement]);
+
+ useEffect(() => {
+ if (!cines || !cines[viewportId] || !enabledVPElement) {
+ return;
+ }
+
+ cineHandler();
+
+ return () => {
+ if (enabledVPElement && cines?.[viewportId]?.isPlaying) {
+ cineService.stopClip(enabledVPElement);
+ }
+ };
+ }, [cines, viewportId, cineService, enabledVPElement, cineHandler]);
+
+ const cine = cines[viewportId];
+ const isPlaying = (cine && cine.isPlaying) || false;
+
+ return (
+ isCineEnabled && (
+
+ cineService.setCine({
+ id: activeViewportId,
+ isPlaying,
+ })
+ }
+ onFrameRateChange={frameRate =>
+ cineService.setCine({
+ id: activeViewportId,
+ frameRate,
+ })
+ }
+ />
+ )
+ );
+}
+
+export default WrappedCinePlayer;
diff --git a/extensions/cornerstone/src/components/CinePlayer/index.ts b/extensions/cornerstone/src/components/CinePlayer/index.ts
new file mode 100644
index 0000000000..d31d4bed76
--- /dev/null
+++ b/extensions/cornerstone/src/components/CinePlayer/index.ts
@@ -0,0 +1,3 @@
+import CinePlayer from './CinePlayer';
+
+export default CinePlayer;
diff --git a/extensions/cornerstone/src/components/DicomUpload/DicomUpload.css b/extensions/cornerstone/src/components/DicomUpload/DicomUpload.css
index 55ddf7922e..d37d2a6a64 100644
--- a/extensions/cornerstone/src/components/DicomUpload/DicomUpload.css
+++ b/extensions/cornerstone/src/components/DicomUpload/DicomUpload.css
@@ -1,6 +1,23 @@
.dicom-upload-drop-area-border-dash {
- background-image: repeating-linear-gradient(to right, #7BB2CE 0%, #7BB2CE 50%, transparent 50%, transparent 100%), repeating-linear-gradient(to right, #7BB2CE 0%, #7BB2CE 50%, transparent 50%, transparent 100%), repeating-linear-gradient(to bottom, #7BB2CE 0%, #7BB2CE 50%, transparent 50%, transparent 100%), repeating-linear-gradient(to bottom, #7BB2CE 0%, #7BB2CE 50%, transparent 50%, transparent 100%);
- background-position: left top, left bottom, left top, right top;
+ background-image: repeating-linear-gradient(
+ to right,
+ #7bb2ce 0%,
+ #7bb2ce 50%,
+ transparent 50%,
+ transparent 100%
+ ),
+ repeating-linear-gradient(to right, #7bb2ce 0%, #7bb2ce 50%, transparent 50%, transparent 100%),
+ repeating-linear-gradient(to bottom, #7bb2ce 0%, #7bb2ce 50%, transparent 50%, transparent 100%),
+ repeating-linear-gradient(to bottom, #7bb2ce 0%, #7bb2ce 50%, transparent 50%, transparent 100%);
+ background-position:
+ left top,
+ left bottom,
+ left top,
+ right top;
background-repeat: repeat-x, repeat-x, repeat-y, repeat-y;
- background-size: 20px 3px, 20px 3px, 3px 20px, 3px 20px;
+ background-size:
+ 20px 3px,
+ 20px 3px,
+ 3px 20px,
+ 3px 20px;
}
diff --git a/extensions/cornerstone/src/components/DicomUpload/DicomUpload.tsx b/extensions/cornerstone/src/components/DicomUpload/DicomUpload.tsx
index 26e596e952..8284ee0705 100644
--- a/extensions/cornerstone/src/components/DicomUpload/DicomUpload.tsx
+++ b/extensions/cornerstone/src/components/DicomUpload/DicomUpload.tsx
@@ -5,7 +5,7 @@ import PropTypes from 'prop-types';
import classNames from 'classnames';
import DicomFileUploader from '../../utils/DicomFileUploader';
import DicomUploadProgress from './DicomUploadProgress';
-import { Button } from '@ohif/ui';
+import { Button, ButtonEnums } from '@ohif/ui';
import './DicomUpload.css';
type DicomUploadProps = {
@@ -14,19 +14,13 @@ type DicomUploadProps = {
onStarted: () => void;
};
-function DicomUpload({
- dataSource,
- onComplete,
- onStarted,
-}: DicomUploadProps): ReactElement {
+function DicomUpload({ dataSource, onComplete, onStarted }: DicomUploadProps): ReactElement {
const baseClassNames = 'min-h-[480px] flex flex-col bg-black select-none';
const [dicomFileUploaderArr, setDicomFileUploaderArr] = useState([]);
const onDrop = useCallback(async acceptedFiles => {
onStarted();
- setDicomFileUploaderArr(
- acceptedFiles.map(file => new DicomFileUploader(file, dataSource))
- );
+ setDicomFileUploaderArr(acceptedFiles.map(file => new DicomFileUploader(file, dataSource)));
}, []);
const getDropZoneComponent = (): ReactElement => {
@@ -40,15 +34,16 @@ function DicomUpload({
{({ getRootProps }) => (
) : (
- (0);
@@ -83,15 +73,13 @@ function DicomUploadProgress({
let intervalStartTime = Date.now();
const setUploadRateRef = () => {
- const uploadSizeFromStartOfInterval =
- currentUploadSizeRef.current - intervalStartUploadSize;
+ const uploadSizeFromStartOfInterval = currentUploadSizeRef.current - intervalStartUploadSize;
const now = Date.now();
const timeSinceStartOfInterval = now - intervalStartTime;
// Calculate and set the upload rate (ref)
- uploadRateRef.current =
- uploadSizeFromStartOfInterval / timeSinceStartOfInterval;
+ uploadRateRef.current = uploadSizeFromStartOfInterval / timeSinceStartOfInterval;
// Reset the interval starting values.
intervalStartUploadSize = currentUploadSizeRef.current;
@@ -134,28 +122,19 @@ function DicomUploadProgress({
const updateProgress = (percentComplete: number) => {
const previousFileUploadSize = currentFileUploadSize;
- currentFileUploadSize = Math.round(
- (percentComplete / 100) * fileUploader.getFileSize()
- );
+ currentFileUploadSize = Math.round((percentComplete / 100) * fileUploader.getFileSize());
currentUploadSizeRef.current = Math.min(
totalUploadSize,
- currentUploadSizeRef.current -
- previousFileUploadSize +
- currentFileUploadSize
+ currentUploadSizeRef.current - previousFileUploadSize + currentFileUploadSize
);
- setPercentComplete(
- (currentUploadSizeRef.current / totalUploadSize) * 100
- );
+ setPercentComplete((currentUploadSizeRef.current / totalUploadSize) * 100);
if (uploadRateRef.current !== 0) {
- const uploadSizeRemaining =
- totalUploadSize - currentUploadSizeRef.current;
+ const uploadSizeRemaining = totalUploadSize - currentUploadSizeRef.current;
- const timeRemaining = Math.round(
- uploadSizeRemaining / uploadRateRef.current
- );
+ const timeRemaining = Math.round(uploadSizeRemaining / uploadRateRef.current);
if (currentTimeRemaining === null) {
currentTimeRemaining = timeRemaining;
@@ -168,9 +147,7 @@ function DicomUploadProgress({
// due to rounding, inaccuracies in the estimate and slight variations
// in upload rates over time.
if (timeRemaining < ONE_MINUTE) {
- const currentSecondsRemaining = Math.ceil(
- currentTimeRemaining / ONE_SECOND
- );
+ const currentSecondsRemaining = Math.ceil(currentTimeRemaining / ONE_SECOND);
const secondsRemaining = Math.ceil(timeRemaining / ONE_SECOND);
const delta = secondsRemaining - currentSecondsRemaining;
if (delta < 0 || delta > 2) {
@@ -181,9 +158,7 @@ function DicomUploadProgress({
}
if (timeRemaining < ONE_HOUR) {
- const currentMinutesRemaining = Math.ceil(
- currentTimeRemaining / ONE_MINUTE
- );
+ const currentMinutesRemaining = Math.ceil(currentTimeRemaining / ONE_MINUTE);
const minutesRemaining = Math.ceil(timeRemaining / ONE_MINUTE);
const delta = minutesRemaining - currentMinutesRemaining;
if (delta < 0 || delta > 2) {
@@ -199,9 +174,7 @@ function DicomUploadProgress({
}
};
- const progressCallback = (
- progressEvent: DicomFileUploaderProgressEvent
- ) => {
+ const progressCallback = (progressEvent: DicomFileUploaderProgressEvent) => {
updateProgress(progressEvent.percentComplete);
};
@@ -249,16 +222,12 @@ function DicomUploadProgress({
if (timeRemaining < ONE_MINUTE) {
const secondsRemaining = Math.ceil(timeRemaining / ONE_SECOND);
- return `${secondsRemaining} ${
- secondsRemaining === 1 ? 'second' : 'seconds'
- }`;
+ return `${secondsRemaining} ${secondsRemaining === 1 ? 'second' : 'seconds'}`;
}
if (timeRemaining < ONE_HOUR) {
const minutesRemaining = Math.ceil(timeRemaining / ONE_MINUTE);
- return `${minutesRemaining} ${
- minutesRemaining === 1 ? 'minute' : 'minutes'
- }`;
+ return `${minutesRemaining} ${minutesRemaining === 1 ? 'minute' : 'minutes'}`;
}
const hoursRemaining = Math.ceil(timeRemaining / ONE_HOUR);
@@ -278,9 +247,7 @@ function DicomUploadProgress({
const showInfiniteProgressBar = useCallback((): boolean => {
return (
getPercentCompleteRounded() < 1 &&
- (progressBarContainerRef?.current?.offsetWidth ?? 0) *
- (percentComplete / 100) <
- 1
+ (progressBarContainerRef?.current?.offsetWidth ?? 0) * (percentComplete / 100) < 1
);
}, [getPercentCompleteRounded, percentComplete]);
@@ -300,17 +267,13 @@ function DicomUploadProgress({
const getNumCompletedAndTimeRemainingComponent = (): ReactElement => {
return (
-
+
diff --git a/extensions/cornerstone/src/Viewport/Overlays/ViewportOrientationMarkers.tsx b/extensions/cornerstone/src/Viewport/Overlays/ViewportOrientationMarkers.tsx
index 8e431ac525..2f33456a42 100644
--- a/extensions/cornerstone/src/Viewport/Overlays/ViewportOrientationMarkers.tsx
+++ b/extensions/cornerstone/src/Viewport/Overlays/ViewportOrientationMarkers.tsx
@@ -13,16 +13,13 @@ import { vec3 } from 'gl-matrix';
import './ViewportOrientationMarkers.css';
-const {
- getOrientationStringLPS,
- invertOrientationStringLPS,
-} = utilities.orientation;
+const { getOrientationStringLPS, invertOrientationStringLPS } = utilities.orientation;
function ViewportOrientationMarkers({
element,
viewportData,
imageSliceData,
- viewportIndex,
+ viewportId,
servicesManager,
orientationMarkers = ['top', 'left'],
}) {
@@ -33,9 +30,7 @@ function ViewportOrientationMarkers({
const { cornerstoneViewportService } = servicesManager.services;
useEffect(() => {
- const cameraModifiedListener = (
- evt: Types.EventTypes.CameraModifiedEvent
- ) => {
+ const cameraModifiedListener = (evt: Types.EventTypes.CameraModifiedEvent) => {
const { rotation, previousCamera, camera } = evt.detail;
if (rotation !== undefined) {
@@ -57,16 +52,10 @@ function ViewportOrientationMarkers({
}
};
- element.addEventListener(
- Enums.Events.CAMERA_MODIFIED,
- cameraModifiedListener
- );
+ element.addEventListener(Enums.Events.CAMERA_MODIFIED, cameraModifiedListener);
return () => {
- element.removeEventListener(
- Enums.Events.CAMERA_MODIFIED,
- cameraModifiedListener
- );
+ element.removeEventListener(Enums.Events.CAMERA_MODIFIED, cameraModifiedListener);
};
}, []);
@@ -85,8 +74,7 @@ function ViewportOrientationMarkers({
return false;
}
- ({ rowCosines, columnCosines } =
- metaData.get('imagePlaneModule', imageId) || {});
+ ({ rowCosines, columnCosines } = metaData.get('imagePlaneModule', imageId) || {});
} else {
if (!element || !getEnabledElement(element)) {
return '';
@@ -114,9 +102,7 @@ function ViewportOrientationMarkers({
flipHorizontal
);
- const ohifViewport = cornerstoneViewportService.getViewportInfoByIndex(
- viewportIndex
- );
+ const ohifViewport = cornerstoneViewportService.getViewportInfo(viewportId);
if (!ohifViewport) {
console.log('ViewportOrientationMarkers::No viewport');
@@ -126,9 +112,7 @@ function ViewportOrientationMarkers({
// Todo: probably this can be done in a better way in which we identify bright
// background
- const isLight = backgroundColor
- ? csUtils.isEqual(backgroundColor, [1, 1, 1])
- : false;
+ const isLight = backgroundColor ? csUtils.isEqual(backgroundColor, [1, 1, 1]) : false;
return orientationMarkers.map((m, index) => (
Loading...
{
element.removeEventListener(Enums.Events.VOI_MODIFIED, updateVOI);
};
- }, [viewportIndex, viewportData, voi, element]);
+ }, [viewportId, viewportData, voi, element]);
/**
* Updating the scale when the viewport changes its zoom
@@ -86,9 +80,7 @@ function CornerstoneViewportOverlay({
previousCamera.parallelScale !== camera.parallelScale ||
previousCamera.scale !== camera.scale
) {
- const viewport = cornerstoneViewportService.getCornerstoneViewportByIndex(
- viewportIndex
- );
+ const viewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
if (!viewport) {
return;
@@ -107,8 +99,7 @@ function CornerstoneViewportOverlay({
const { spacing } = imageData;
// convert parallel scale to scale
- const scale =
- (element.clientHeight * spacing[0] * 0.5) / camera.parallelScale;
+ const scale = (element.clientHeight * spacing[0] * 0.5) / camera.parallelScale;
setScale(scale);
}
};
@@ -118,7 +109,7 @@ function CornerstoneViewportOverlay({
return () => {
element.removeEventListener(Enums.Events.CAMERA_MODIFIED, updateScale);
};
- }, [viewportIndex, viewportData]);
+ }, [viewportId, viewportData]);
const getTopLeftContent = useCallback(() => {
const { windowWidth, windowCenter } = voi;
@@ -168,7 +159,7 @@ function CornerstoneViewportOverlay({
instanceNumber = _getInstanceNumberFromVolume(
viewportData,
imageIndex,
- viewportIndex,
+ viewportId,
cornerstoneViewportService
);
}
@@ -183,15 +174,13 @@ function CornerstoneViewportOverlay({
);
- }, [imageSliceData, viewportData, viewportIndex]);
+ }, [imageSliceData, viewportData, viewportId]);
if (!viewportData) {
return null;
}
- const ohifViewport = cornerstoneViewportService.getViewportInfoByIndex(
- viewportIndex
- );
+ const ohifViewport = cornerstoneViewportService.getViewportInfo(viewportId);
if (!ohifViewport) {
return null;
@@ -201,9 +190,7 @@ function CornerstoneViewportOverlay({
// Todo: probably this can be done in a better way in which we identify bright
// background
- const isLight = backgroundColor
- ? utilities.isEqual(backgroundColor, [1, 1, 1])
- : false;
+ const isLight = backgroundColor ? utilities.isEqual(backgroundColor, [1, 1, 1]) : false;
return (
-
+
{({ getRootProps, getInputProps }) => (
)}
-
+
{({ getRootProps, getInputProps }) => (
)}
@@ -99,9 +93,7 @@ function DicomUpload({
/>
or drag images or folders here
-
- (DICOM files supported)
-
+ (DICOM files supported)
- {getDropZoneComponent()}
-
+ {getDropZoneComponent()}
)}
);
diff --git a/extensions/cornerstone/src/components/DicomUpload/DicomUploadProgress.tsx b/extensions/cornerstone/src/components/DicomUpload/DicomUploadProgress.tsx
index d16ee4b9f0..c09d969881 100644
--- a/extensions/cornerstone/src/components/DicomUpload/DicomUploadProgress.tsx
+++ b/extensions/cornerstone/src/components/DicomUpload/DicomUploadProgress.tsx
@@ -1,10 +1,4 @@
-import React, {
- useCallback,
- useEffect,
- useRef,
- useState,
- ReactElement,
-} from 'react';
+import React, { useCallback, useEffect, useRef, useState, ReactElement } from 'react';
import PropTypes from 'prop-types';
import { Button, Icon, ProgressLoadingBar } from '@ohif/ui';
import DicomFileUploader, {
@@ -39,18 +33,14 @@ const BASE_INTERVAL_TIME = 15000;
// calculate the upload rate.
const UPLOAD_RATE_THRESHOLD = 75;
-const NO_WRAP_ELLIPSIS_CLASS_NAMES =
- 'text-ellipsis whitespace-nowrap overflow-hidden';
+const NO_WRAP_ELLIPSIS_CLASS_NAMES = 'text-ellipsis whitespace-nowrap overflow-hidden';
function DicomUploadProgress({
dicomFileUploaderArr,
onComplete,
}: DicomUploadProgressProps): ReactElement {
const [totalUploadSize] = useState(
- dicomFileUploaderArr.reduce(
- (acc, fileUploader) => acc + fileUploader.getFileSize(),
- 0
- )
+ dicomFileUploaderArr.reduce((acc, fileUploader) => acc + fileUploader.getFileSize(), 0)
);
const currentUploadSizeRef = useRef
+
{numFilesCompleted === dicomFileUploaderArr.length ? (
<>
- {`${
- dicomFileUploaderArr.length
- } ${
+ {`${dicomFileUploaderArr.length} ${
dicomFileUploaderArr.length > 1 ? 'files' : 'file'
} completed.`}
+ {' files completed.'}
- {' files completed.'}
-
-
- {timeRemaining
- ? `Less than ${getFormattedTimeRemaining()} remaining. `
- : ''}
+ {timeRemaining ? `Less than ${getFormattedTimeRemaining()} remaining. ` : ''}
@@ -351,14 +310,13 @@ function DicomUploadProgress({
const getShowFailedOnlyIconComponent = (): ReactElement => {
return (
-
+
{numFails > 0 && (
-
- setShowFailedOnly(currentShowFailedOnly => !currentShowFailedOnly)
- }
- >
-
@@ -367,31 +325,28 @@ function DicomUploadProgress({
const getPercentCompleteComponent = (): ReactElement => {
return (
- setShowFailedOnly(currentShowFailedOnly => !currentShowFailedOnly)}>
+
)}
-
+
+
{numFilesCompleted === dicomFileUploaderArr.length ? (
<>
-
+
{numFails > 0
- ? `Completed with ${numFails} ${
- numFails > 1 ? 'errors' : 'error'
- }!`
+ ? `Completed with ${numFails} ${numFails > 1 ? 'errors' : 'error'}!`
: 'Completed!'}
{getShowFailedOnlyIconComponent()}
) : (
<>
-
+
+
@@ -403,16 +358,15 @@ function DicomUploadProgress({
};
return (
-
{`${getPercentCompleteRounded()}%`}
{getShowFailedOnlyIconComponent()}
+
{getNumCompletedAndTimeRemainingComponent()}
-
+
{getPercentCompleteComponent()}
-
+
{dicomFileUploaderArr
.filter(
dicomFileUploader =>
- !showFailedOnly ||
- dicomFileUploader.getStatus() === UploadStatus.Failed
+ !showFailedOnly || dicomFileUploader.getStatus() === UploadStatus.Failed
)
.map(dicomFileUploader => (
{
- const [percentComplete, setPercentComplete] = useState(
- dicomFileUploader.getPercentComplete()
- );
+ const [percentComplete, setPercentComplete] = useState(dicomFileUploader.getPercentComplete());
const [failedReason, setFailedReason] = useState('');
const [status, setStatus] = useState(dicomFileUploader.getStatus());
- console.info(`${dicomFileUploader.getFileId()}`);
const isComplete = useCallback(() => {
return (
status === UploadStatus.Failed ||
@@ -63,7 +54,10 @@ const DicomUploadProgressItem = memo(
switch (dicomFileUploader.getStatus()) {
case UploadStatus.Success:
return (
-
-
+
+
-
-
- {getStatusIcon()}
-
-
+
{failedReason && {getStatusIcon()}
+
{dicomFileUploader.getFileName()}
{failedReason}
}
+
{!isComplete() && (
<>
{dicomFileUploader.getStatus() === UploadStatus.InProgress && (
{percentComplete}%
)}
-
+
{
+ preRegistration: function (props: Types.Extensions.ExtensionParams): Promise {
const { servicesManager } = props;
servicesManager.registerService(CornerstoneViewportService.REGISTRATION);
servicesManager.registerService(ToolGroupService.REGISTRATION);
@@ -141,5 +135,10 @@ const cornerstoneExtension: Types.Extensions.Extension = {
};
export type { PublicViewportOptions };
-export { measurementMappingUtils, CornerstoneExtensionTypes, toolNames , getActiveViewportEnabledElement};
+export {
+ measurementMappingUtils,
+ CornerstoneExtensionTypes as Types,
+ toolNames,
+ getActiveViewportEnabledElement,
+};
export default cornerstoneExtension;
diff --git a/extensions/cornerstone/src/init.tsx b/extensions/cornerstone/src/init.tsx
index 4a07f4e635..f052b6e019 100644
--- a/extensions/cornerstone/src/init.tsx
+++ b/extensions/cornerstone/src/init.tsx
@@ -12,6 +12,7 @@ import {
imageLoadPoolManager,
Settings,
utilities as csUtilities,
+ Enums as csEnums,
} from '@cornerstonejs/core';
import { Enums, utilities, ReferenceLinesTool } from '@cornerstonejs/tools';
import { cornerstoneStreamingImageVolumeLoader } from '@cornerstonejs/streaming-image-volume-loader';
@@ -26,6 +27,7 @@ import nthLoader from './utils/nthLoader';
import interleaveTopToBottom from './utils/interleaveTopToBottom';
import initContextMenu from './initContextMenu';
import initDoubleClick from './initDoubleClick';
+import { CornerstoneServices } from './types';
// TODO: Cypress tests are currently grabbing this from the window?
window.cornerstone = cornerstone;
@@ -40,39 +42,49 @@ export default async function init({
configuration,
appConfig,
}: Types.Extensions.ExtensionParams): Promise {
- await cs3DInit();
+
+ await cs3DInit({
+ rendering: {
+ preferSizeOverAccuracy: Boolean(appConfig.use16BitDataType),
+ useNorm16Texture: Boolean(appConfig.use16BitDataType),
+ },
+ });
// For debugging e2e tests that are failing on CI
cornerstone.setUseCPURendering(Boolean(appConfig.useCPURendering));
+
+ switch (appConfig.useSharedArrayBuffer) {
+ case 'AUTO':
+ cornerstone.setUseSharedArrayBuffer(csEnums.SharedArrayBufferModes.AUTO);
+ break;
+ case 'FALSE':
+ cornerstone.setUseSharedArrayBuffer(csEnums.SharedArrayBufferModes.FALSE);
+ break;
+ default:
+ cornerstone.setUseSharedArrayBuffer(csEnums.SharedArrayBufferModes.TRUE);
+ }
+
cornerstone.setConfiguration({
...cornerstone.getConfiguration(),
rendering: {
...cornerstone.getConfiguration().rendering,
- strictZSpacingForVolumeViewport:
- appConfig.strictZSpacingForVolumeViewport,
+ strictZSpacingForVolumeViewport: appConfig.strictZSpacingForVolumeViewport,
},
});
- // For debugging large datasets
- const MAX_CACHE_SIZE_1GB = 1073741824;
- const maxCacheSize = appConfig.maxCacheSize;
- cornerstone.cache.setMaxCacheSize(
- maxCacheSize ? maxCacheSize : MAX_CACHE_SIZE_1GB
- );
+ // For debugging large datasets, otherwise prefer the defaults
+ const { maxCacheSize } = appConfig;
+ if (maxCacheSize) {
+ cornerstone.cache.setMaxCacheSize(maxCacheSize);
+ }
initCornerstoneTools();
- Settings.getRuntimeSettings().set(
- 'useCursors',
- Boolean(appConfig.useCursors)
- );
+ Settings.getRuntimeSettings().set('useCursors', Boolean(appConfig.useCursors));
const {
userAuthenticationService,
- measurementService,
customizationService,
- displaySetService,
- uiDialogService,
uiModalService,
uiNotificationService,
cineService,
@@ -81,28 +93,21 @@ export default async function init({
toolGroupService,
viewportGridService,
stateSyncService,
- } = servicesManager.services;
+ } = servicesManager.services as CornerstoneServices;
window.services = servicesManager.services;
window.extensionManager = extensionManager;
window.commandsManager = commandsManager;
- if (
- appConfig.showWarningMessageForCrossOrigin &&
- !window.crossOriginIsolated
- ) {
+ if (appConfig.showWarningMessageForCrossOrigin && !window.crossOriginIsolated) {
uiNotificationService.show({
title: 'Cross Origin Isolation',
- message:
- 'Cross Origin Isolation is not enabled, volume rendering will not work (e.g., MPR)',
+ message: 'Cross Origin Isolation is not enabled, volume rendering will not work (e.g., MPR)',
type: 'warning',
});
}
- if (
- appConfig.showCPUFallbackMessage &&
- cornerstone.getShouldUseCPURendering()
- ) {
+ if (appConfig.showCPUFallbackMessage && cornerstone.getShouldUseCPURendering()) {
_showCPURenderingModal(uiModalService, hangingProtocolService);
}
@@ -122,18 +127,14 @@ export default async function init({
clearOnModeExit: true,
});
- const labelmapRepresentation =
- cornerstoneTools.Enums.SegmentationRepresentations.Labelmap;
+ const labelmapRepresentation = cornerstoneTools.Enums.SegmentationRepresentations.Labelmap;
- cornerstoneTools.segmentation.config.setGlobalRepresentationConfig(
- labelmapRepresentation,
- {
- fillAlpha: 0.3,
- fillAlphaInactive: 0.2,
- outlineOpacity: 1,
- outlineOpacityInactive: 0.65,
- }
- );
+ cornerstoneTools.segmentation.config.setGlobalRepresentationConfig(labelmapRepresentation, {
+ fillAlpha: 0.3,
+ fillAlphaInactive: 0.2,
+ outlineOpacity: 1,
+ outlineOpacityInactive: 0.65,
+ });
const metadataProvider = OHIF.classes.MetadataProvider;
@@ -142,14 +143,8 @@ export default async function init({
cornerstoneStreamingImageVolumeLoader
);
- hangingProtocolService.registerImageLoadStrategy(
- 'interleaveCenter',
- interleaveCenterLoader
- );
- hangingProtocolService.registerImageLoadStrategy(
- 'interleaveTopToBottom',
- interleaveTopToBottom
- );
+ hangingProtocolService.registerImageLoadStrategy('interleaveCenter', interleaveCenterLoader);
+ hangingProtocolService.registerImageLoadStrategy('interleaveTopToBottom', interleaveTopToBottom);
hangingProtocolService.registerImageLoadStrategy('nth', nthLoader);
// add metadata providers
@@ -166,12 +161,10 @@ export default async function init({
prefetch: appConfig?.maxNumRequests?.prefetch || 10,
};
- initWADOImageLoader(userAuthenticationService, appConfig);
+ initWADOImageLoader(userAuthenticationService, appConfig, extensionManager);
/* Measurement Service */
- this.measurementServiceSource = connectToolsToMeasurementService(
- servicesManager
- );
+ this.measurementServiceSource = connectToolsToMeasurementService(servicesManager);
initCineService(cineService);
@@ -181,31 +174,18 @@ export default async function init({
volumeInputArrayMap => {
for (const entry of volumeInputArrayMap.entries()) {
const [viewportId, volumeInputArray] = entry;
- const viewport = cornerstoneViewportService.getCornerstoneViewport(
- viewportId
- );
-
- const ohifViewport = cornerstoneViewportService.getViewportInfo(
- viewportId
- );
-
- const {
- lutPresentationStore,
- positionPresentationStore,
- } = stateSyncService.getState();
+ const viewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
+
+ const ohifViewport = cornerstoneViewportService.getViewportInfo(viewportId);
+
+ const { lutPresentationStore, positionPresentationStore } = stateSyncService.getState();
const { presentationIds } = ohifViewport.getViewportOptions();
const presentations = {
- positionPresentation:
- positionPresentationStore[presentationIds?.positionPresentationId],
- lutPresentation:
- lutPresentationStore[presentationIds?.lutPresentationId],
+ positionPresentation: positionPresentationStore[presentationIds?.positionPresentationId],
+ lutPresentation: lutPresentationStore[presentationIds?.lutPresentationId],
};
- cornerstoneViewportService.setVolumesForViewport(
- viewport,
- volumeInputArray,
- presentations
- );
+ cornerstoneViewportService.setVolumesForViewport(viewport, volumeInputArray, presentations);
}
}
);
@@ -228,9 +208,7 @@ export default async function init({
const resetCrosshairs = evt => {
const { element } = evt.detail;
- const { viewportId, renderingEngineId } = cornerstone.getEnabledElement(
- element
- );
+ const { viewportId, renderingEngineId } = cornerstone.getEnabledElement(element);
const toolGroup = cornerstoneTools.ToolGroupManager.getToolGroupForViewport(
viewportId,
@@ -256,10 +234,7 @@ export default async function init({
const { element } = evt.detail;
element.addEventListener(EVENTS.CAMERA_RESET, resetCrosshairs);
- eventTarget.addEventListener(
- EVENTS.STACK_VIEWPORT_NEW_STACK,
- newStackCallback
- );
+ eventTarget.addEventListener(EVENTS.STACK_VIEWPORT_NEW_STACK, newStackCallback);
}
function elementDisabledHandler(evt) {
@@ -274,20 +249,13 @@ export default async function init({
// );
}
- eventTarget.addEventListener(
- EVENTS.ELEMENT_ENABLED,
- elementEnabledHandler.bind(null)
- );
+ eventTarget.addEventListener(EVENTS.ELEMENT_ENABLED, elementEnabledHandler.bind(null));
- eventTarget.addEventListener(
- EVENTS.ELEMENT_DISABLED,
- elementDisabledHandler.bind(null)
- );
+ eventTarget.addEventListener(EVENTS.ELEMENT_DISABLED, elementDisabledHandler.bind(null));
viewportGridService.subscribe(
- viewportGridService.EVENTS.ACTIVE_VIEWPORT_INDEX_CHANGED,
- ({ viewportIndex, viewportId }) => {
- viewportId = viewportId || `viewport-${viewportIndex}`;
+ viewportGridService.EVENTS.ACTIVE_VIEWPORT_ID_CHANGED,
+ ({ viewportId }) => {
const toolGroup = toolGroupService.getToolGroupForViewport(viewportId);
if (!toolGroup || !toolGroup._toolInstances?.['ReferenceLines']) {
@@ -296,8 +264,7 @@ export default async function init({
// check if reference lines are active
const referenceLinesEnabled =
- toolGroup._toolInstances['ReferenceLines'].mode ===
- Enums.ToolModes.Enabled;
+ toolGroup._toolInstances['ReferenceLines'].mode === Enums.ToolModes.Enabled;
if (!referenceLinesEnabled) {
return;
@@ -322,10 +289,9 @@ function CPUModal() {
return (
);
diff --git a/extensions/cornerstone/src/initContextMenu.ts b/extensions/cornerstone/src/initContextMenu.ts
index c46e5053e9..488fdf8587 100644
--- a/extensions/cornerstone/src/initContextMenu.ts
+++ b/extensions/cornerstone/src/initContextMenu.ts
@@ -18,6 +18,7 @@ const DEFAULT_CONTEXT_MENU_CLICKS = {
{
commandName: 'showCornerstoneContextMenu',
commandOptions: {
+ requireNearbyToolData: true,
menuId: 'measurementsContextMenu',
},
},
@@ -35,9 +36,15 @@ const DEFAULT_CONTEXT_MENU_CLICKS = {
function getEventName(evt) {
const button = evt.detail.event.which;
const nameArr = [];
- if (evt.detail.event.altKey) nameArr.push('alt');
- if (evt.detail.event.ctrlKey) nameArr.push('ctrl');
- if (evt.detail.event.shiftKey) nameArr.push('shift');
+ if (evt.detail.event.altKey) {
+ nameArr.push('alt');
+ }
+ if (evt.detail.event.ctrlKey) {
+ nameArr.push('ctrl');
+ }
+ if (evt.detail.event.shiftKey) {
+ nameArr.push('shift');
+ }
nameArr.push('button');
nameArr.push(button);
return nameArr.join('');
@@ -54,12 +61,22 @@ function initContextMenu({
*/
const cornerstoneViewportHandleEvent = (name, evt) => {
const customizations =
- customizationService.get('cornerstoneViewportClickCommands') ||
- DEFAULT_CONTEXT_MENU_CLICKS;
+ customizationService.get('cornerstoneViewportClickCommands') || DEFAULT_CONTEXT_MENU_CLICKS;
const toRun = customizations[name];
- console.log('initContextMenu::cornerstoneViewportHandleEvent', name, toRun);
+
+ if (!toRun) {
+ return;
+ }
+
+ // only find nearbyToolData if required, for the click (which closes the context menu
+ // we don't need to find nearbyToolData)
+ let nearbyToolData = null;
+ if (toRun.commands.some(command => command.commandOptions?.requireNearbyToolData)) {
+ nearbyToolData = findNearbyToolData(commandsManager, evt);
+ }
+
const options = {
- nearbyToolData: findNearbyToolData(commandsManager, evt),
+ nearbyToolData,
event: evt,
};
commandsManager.run(toRun, options);
@@ -73,35 +90,24 @@ function initContextMenu({
function elementEnabledHandler(evt) {
const { viewportId, element } = evt.detail;
const viewportInfo = cornerstoneViewportService.getViewportInfo(viewportId);
- if (!viewportInfo) return;
- const viewportIndex = viewportInfo.getViewportIndex();
+ if (!viewportInfo) {
+ return;
+ }
// TODO check update upstream
- setEnabledElement(viewportIndex, element);
+ setEnabledElement(viewportId, element);
- element.addEventListener(
- cs3DToolsEvents.MOUSE_CLICK,
- cornerstoneViewportHandleClick
- );
+ element.addEventListener(cs3DToolsEvents.MOUSE_CLICK, cornerstoneViewportHandleClick);
}
function elementDisabledHandler(evt) {
const { element } = evt.detail;
- element.removeEventListener(
- cs3DToolsEvents.MOUSE_CLICK,
- cornerstoneViewportHandleClick
- );
+ element.removeEventListener(cs3DToolsEvents.MOUSE_CLICK, cornerstoneViewportHandleClick);
}
- eventTarget.addEventListener(
- EVENTS.ELEMENT_ENABLED,
- elementEnabledHandler.bind(null)
- );
+ eventTarget.addEventListener(EVENTS.ELEMENT_ENABLED, elementEnabledHandler.bind(null));
- eventTarget.addEventListener(
- EVENTS.ELEMENT_DISABLED,
- elementDisabledHandler.bind(null)
- );
+ eventTarget.addEventListener(EVENTS.ELEMENT_DISABLED, elementDisabledHandler.bind(null));
}
export default initContextMenu;
diff --git a/extensions/cornerstone/src/initCornerstoneTools.js b/extensions/cornerstone/src/initCornerstoneTools.js
index 9549b17f91..767b607a77 100644
--- a/extensions/cornerstone/src/initCornerstoneTools.js
+++ b/extensions/cornerstone/src/initCornerstoneTools.js
@@ -25,9 +25,13 @@ import {
annotation,
ReferenceLinesTool,
TrackballRotateTool,
+ CircleScissorsTool,
+ RectangleScissorsTool,
+ SphereScissorsTool,
} from '@cornerstonejs/tools';
import CalibrationLineTool from './tools/CalibrationLineTool';
+import ImageOverlayViewerTool from './tools/ImageOverlayViewerTool';
export default function initCornerstoneTools(configuration = {}) {
CrosshairsTool.isAnnotation = false;
@@ -58,6 +62,10 @@ export default function initCornerstoneTools(configuration = {}) {
addTool(ReferenceLinesTool);
addTool(CalibrationLineTool);
addTool(TrackballRotateTool);
+ addTool(CircleScissorsTool);
+ addTool(RectangleScissorsTool);
+ addTool(SphereScissorsTool);
+ addTool(ImageOverlayViewerTool);
// Modify annotation tools to use dashed lines on SR
const annotationStyle = {
@@ -99,6 +107,10 @@ const toolNames = {
ReferenceLines: ReferenceLinesTool.toolName,
CalibrationLine: CalibrationLineTool.toolName,
TrackballRotateTool: TrackballRotateTool.toolName,
+ CircleScissors: CircleScissorsTool.toolName,
+ RectangleScissors: RectangleScissorsTool.toolName,
+ SphereScissors: SphereScissorsTool.toolName,
+ ImageOverlayViewer: ImageOverlayViewerTool.toolName,
};
export { toolNames };
diff --git a/extensions/cornerstone/src/initDoubleClick.ts b/extensions/cornerstone/src/initDoubleClick.ts
index da8fb8fa49..049d72cbee 100644
--- a/extensions/cornerstone/src/initDoubleClick.ts
+++ b/extensions/cornerstone/src/initDoubleClick.ts
@@ -21,9 +21,15 @@ const DEFAULT_DOUBLE_CLICK = {
*/
function getDoubleClickEventName(evt: CustomEvent) {
const nameArr = [];
- if (evt.detail.event.altKey) nameArr.push('alt');
- if (evt.detail.event.ctrlKey) nameArr.push('ctrl');
- if (evt.detail.event.shiftKey) nameArr.push('shift');
+ if (evt.detail.event.altKey) {
+ nameArr.push('alt');
+ }
+ if (evt.detail.event.ctrlKey) {
+ nameArr.push('ctrl');
+ }
+ if (evt.detail.event.shiftKey) {
+ nameArr.push('shift');
+ }
nameArr.push('doubleClick');
return nameArr.join('');
}
@@ -33,10 +39,7 @@ export type initDoubleClickArgs = {
commandsManager: CommandsManager;
};
-function initDoubleClick({
- customizationService,
- commandsManager,
-}: initDoubleClickArgs): void {
+function initDoubleClick({ customizationService, commandsManager }: initDoubleClickArgs): void {
const cornerstoneViewportHandleDoubleClick = (evt: CustomEvent) => {
// Do not allow double click on a tool.
const nearbyToolData = findNearbyToolData(commandsManager, evt);
@@ -48,8 +51,7 @@ function initDoubleClick({
// Allows for the customization of the double click on a viewport.
const customizations =
- customizationService.get('cornerstoneViewportClickCommands') ||
- DEFAULT_DOUBLE_CLICK;
+ customizationService.get('cornerstoneViewportClickCommands') || DEFAULT_DOUBLE_CLICK;
const toRun = customizations[eventName];
@@ -78,15 +80,9 @@ function initDoubleClick({
);
}
- eventTarget.addEventListener(
- EVENTS.ELEMENT_ENABLED,
- elementEnabledHandler.bind(null)
- );
+ eventTarget.addEventListener(EVENTS.ELEMENT_ENABLED, elementEnabledHandler.bind(null));
- eventTarget.addEventListener(
- EVENTS.ELEMENT_DISABLED,
- elementDisabledHandler.bind(null)
- );
+ eventTarget.addEventListener(EVENTS.ELEMENT_DISABLED, elementDisabledHandler.bind(null));
}
export default initDoubleClick;
diff --git a/extensions/cornerstone/src/initMeasurementService.js b/extensions/cornerstone/src/initMeasurementService.js
index 3a883cc79d..2ab5cce55b 100644
--- a/extensions/cornerstone/src/initMeasurementService.js
+++ b/extensions/cornerstone/src/initMeasurementService.js
@@ -127,11 +127,8 @@ const initMeasurementService = (
};
const connectToolsToMeasurementService = servicesManager => {
- const {
- measurementService,
- displaySetService,
- cornerstoneViewportService,
- } = servicesManager.services;
+ const { measurementService, displaySetService, cornerstoneViewportService } =
+ servicesManager.services;
const csTools3DVer1MeasurementSource = initMeasurementService(
measurementService,
displaySetService,
@@ -153,10 +150,7 @@ const connectToolsToMeasurementService = servicesManager => {
} = annotationAddedEventDetail;
const { toolName } = metadata;
- if (
- csToolsEvent.type === completedEvt &&
- toolName === toolNames.CalibrationLine
- ) {
+ if (csToolsEvent.type === completedEvt && toolName === toolNames.CalibrationLine) {
// show modal to input the measurement (mm)
onCompletedCalibrationLine(servicesManager, csToolsEvent)
.then(
@@ -212,10 +206,8 @@ const connectToolsToMeasurementService = servicesManager => {
try {
const annotationSelectionEventDetail = csToolsEvent.detail;
- const {
- added: addedSelectedAnnotationUIDs,
- removed: removedSelectedAnnotationUIDs,
- } = annotationSelectionEventDetail;
+ const { added: addedSelectedAnnotationUIDs, removed: removedSelectedAnnotationUIDs } =
+ annotationSelectionEventDetail;
if (removedSelectedAnnotationUIDs) {
removedSelectedAnnotationUIDs.forEach(annotationUID =>
@@ -283,12 +275,8 @@ const connectMeasurementServiceToTools = (
cornerstoneViewportService,
measurementSource
) => {
- const {
- MEASUREMENT_REMOVED,
- MEASUREMENTS_CLEARED,
- MEASUREMENT_UPDATED,
- RAW_MEASUREMENT_ADDED,
- } = measurementService.EVENTS;
+ const { MEASUREMENT_REMOVED, MEASUREMENTS_CLEARED, MEASUREMENT_UPDATED, RAW_MEASUREMENT_ADDED } =
+ measurementService.EVENTS;
const csTools3DVer1MeasurementSource = measurementService.getSource(
CORNERSTONE_3D_TOOLS_SOURCE_NAME,
@@ -351,11 +339,7 @@ const connectMeasurementServiceToTools = (
return;
}
- const {
- referenceSeriesUID,
- referenceStudyUID,
- SOPInstanceUID,
- } = measurement;
+ const { referenceSeriesUID, referenceStudyUID, SOPInstanceUID } = measurement;
const instance = DicomMetadataStore.getInstance(
referenceStudyUID,
@@ -368,9 +352,7 @@ const connectMeasurementServiceToTools = (
if (measurement?.metadata?.referencedImageId) {
imageId = measurement.metadata.referencedImageId;
- frameNumber = getSOPInstanceAttributes(
- measurement.metadata.referencedImageId
- ).frameNumber;
+ frameNumber = getSOPInstanceAttributes(measurement.metadata.referencedImageId).frameNumber;
} else {
imageId = dataSource.getImageIdsForInstance({ instance });
}
diff --git a/extensions/cornerstone/src/initWADOImageLoader.js b/extensions/cornerstone/src/initWADOImageLoader.js
index f5884643db..1beda3885b 100644
--- a/extensions/cornerstone/src/initWADOImageLoader.js
+++ b/extensions/cornerstone/src/initWADOImageLoader.js
@@ -1,11 +1,9 @@
import * as cornerstone from '@cornerstonejs/core';
import { volumeLoader } from '@cornerstonejs/core';
import { cornerstoneStreamingImageVolumeLoader } from '@cornerstonejs/streaming-image-volume-loader';
-import dicomImageLoader, {
- webWorkerManager,
-} from '@cornerstonejs/dicom-image-loader';
+import dicomImageLoader, { webWorkerManager } from '@cornerstonejs/dicom-image-loader';
import dicomParser from 'dicom-parser';
-import { errorHandler } from '@ohif/core';
+import { errorHandler, utils } from '@ohif/core';
const { registerVolumeLoader } = volumeLoader;
@@ -35,15 +33,13 @@ function initWebWorkers(appConfig) {
export default function initWADOImageLoader(
userAuthenticationService,
- appConfig
+ appConfig,
+ extensionManager
) {
dicomImageLoader.external.cornerstone = cornerstone;
dicomImageLoader.external.dicomParser = dicomParser;
- registerVolumeLoader(
- 'cornerstoneStreamingImageVolume',
- cornerstoneStreamingImageVolumeLoader
- );
+ registerVolumeLoader('cornerstoneStreamingImageVolume', cornerstoneStreamingImageVolumeLoader);
dicomImageLoader.configure({
decodeConfig: {
@@ -53,20 +49,20 @@ export default function initWADOImageLoader(
// Until the default is set to true (which is the case for cornerstone3D),
// we should set this flag to false.
convertFloatPixelDataToInt: false,
+ use16BitDataType: Boolean(appConfig.use16BitDataType),
},
- beforeSend: function(xhr) {
+ beforeSend: function (xhr) {
+ //TODO should be removed in the future and request emitted by DicomWebDataSource
+ const sourceConfig = extensionManager.getActiveDataSource()?.[0].getConfig() ?? {};
const headers = userAuthenticationService.getAuthorizationHeader();
+ const acceptHeader = utils.generateAcceptHeader(
+ sourceConfig.acceptHeader,
+ sourceConfig.requestTransferSyntaxUID,
+ sourceConfig.omitQuotationForMultipartRequest
+ );
- // Request:
- // JPEG-LS Lossless (1.2.840.10008.1.2.4.80) if available, otherwise accept
- // whatever transfer-syntax the origin server provides.
- // For now we use image/jls and image/x-jls because some servers still use the old type
- // http://dicom.nema.org/medical/dicom/current/output/html/part18.html
const xhrRequestHeaders = {
- Accept: appConfig.omitQuotationForMultipartRequest
- ? 'multipart/related; type=application/octet-stream'
- : 'multipart/related; type="application/octet-stream"',
- // 'multipart/related; type="image/x-jls", multipart/related; type="image/jls"; transfer-syntax="1.2.840.10008.1.2.4.80", multipart/related; type="image/x-jls", multipart/related; type="application/octet-stream"; transfer-syntax=*',
+ Accept: acceptHeader,
};
if (headers) {
diff --git a/extensions/cornerstone/src/services/CornerstoneCacheService/CornerstoneCacheService.ts b/extensions/cornerstone/src/services/CornerstoneCacheService/CornerstoneCacheService.ts
index 31ea90cb23..a2fc897601 100644
--- a/extensions/cornerstone/src/services/CornerstoneCacheService/CornerstoneCacheService.ts
+++ b/extensions/cornerstone/src/services/CornerstoneCacheService/CornerstoneCacheService.ts
@@ -1,16 +1,8 @@
import { ServicesManager, Types } from '@ohif/core';
-import {
- cache as cs3DCache,
- Enums,
- volumeLoader,
- utilities as utils,
-} from '@cornerstonejs/core';
+import { cache as cs3DCache, Enums, volumeLoader, utilities as utils } from '@cornerstonejs/core';
import getCornerstoneViewportType from '../../utils/getCornerstoneViewportType';
-import {
- StackViewportData,
- VolumeViewportData,
-} from '../../types/CornerstoneCacheService';
+import { StackViewportData, VolumeViewportData } from '../../types/CornerstoneCacheService';
const VOLUME_LOADER_SCHEME = 'cornerstoneStreamingImageVolume';
@@ -18,9 +10,7 @@ class CornerstoneCacheService {
static REGISTRATION = {
name: 'cornerstoneCacheService',
altName: 'CornerstoneCacheService',
- create: ({
- servicesManager,
- }: Types.Extensions.ExtensionParams): CornerstoneCacheService => {
+ create: ({ servicesManager }: Types.Extensions.ExtensionParams): CornerstoneCacheService => {
return new CornerstoneCacheService(servicesManager);
},
};
@@ -77,11 +67,7 @@ class CornerstoneCacheService {
cs3DViewportType === Enums.ViewportType.ORTHOGRAPHIC ||
cs3DViewportType === Enums.ViewportType.VOLUME_3D
) {
- viewportData = await this._getVolumeViewportData(
- dataSource,
- displaySets,
- cs3DViewportType
- );
+ viewportData = await this._getVolumeViewportData(dataSource, displaySets, cs3DViewportType);
}
viewportData.viewportType = cs3DViewportType;
@@ -134,20 +120,14 @@ class CornerstoneCacheService {
// For Stack Viewport we don't have fusion currently
const displaySet = displaySets[0];
- let stackImageIds = this.stackImageIds.get(
- displaySet.displaySetInstanceUID
- );
+ let stackImageIds = this.stackImageIds.get(displaySet.displaySetInstanceUID);
if (!stackImageIds) {
stackImageIds = this._getCornerstoneStackImageIds(displaySet, dataSource);
this.stackImageIds.set(displaySet.displaySetInstanceUID, stackImageIds);
}
- const {
- displaySetInstanceUID,
- StudyInstanceUID,
- isCompositeStack,
- } = displaySet;
+ const { displaySetInstanceUID, StudyInstanceUID, isCompositeStack } = displaySet;
const StackViewportData: StackViewportData = {
viewportType,
@@ -196,31 +176,22 @@ class CornerstoneCacheService {
continue;
}
- const volumeLoaderSchema =
- displaySet.volumeLoaderSchema ?? VOLUME_LOADER_SCHEME;
+ const volumeLoaderSchema = displaySet.volumeLoaderSchema ?? VOLUME_LOADER_SCHEME;
const volumeId = `${volumeLoaderSchema}:${displaySet.displaySetInstanceUID}`;
- let volumeImageIds = this.volumeImageIds.get(
- displaySet.displaySetInstanceUID
- );
+ let volumeImageIds = this.volumeImageIds.get(displaySet.displaySetInstanceUID);
let volume = cs3DCache.getVolume(volumeId);
if (!volumeImageIds || !volume) {
- volumeImageIds = this._getCornerstoneVolumeImageIds(
- displaySet,
- dataSource
- );
+ volumeImageIds = this._getCornerstoneVolumeImageIds(displaySet, dataSource);
volume = await volumeLoader.createAndCacheVolume(volumeId, {
imageIds: volumeImageIds,
});
- this.volumeImageIds.set(
- displaySet.displaySetInstanceUID,
- volumeImageIds
- );
+ this.volumeImageIds.set(displaySet.displaySetInstanceUID, volumeImageIds);
}
volumeData.push({
@@ -239,7 +210,7 @@ class CornerstoneCacheService {
}
private _shouldRenderSegmentation(displaySets) {
- const { segmentationService } = this.servicesManager.services;
+ const { segmentationService, displaySetService } = this.servicesManager.services;
const viewportDisplaySetInstanceUIDs = displaySets.map(
({ displaySetInstanceUID }) => displaySetInstanceUID
@@ -251,10 +222,11 @@ class CornerstoneCacheService {
for (const segmentation of segmentations) {
const segDisplaySetInstanceUID = segmentation.displaySetInstanceUID;
+ const segDisplaySet = displaySetService.getDisplaySetByUID(segDisplaySetInstanceUID);
const shouldDisplaySeg = segmentationService.shouldRenderSegmentation(
viewportDisplaySetInstanceUIDs,
- segDisplaySetInstanceUID
+ segDisplaySet.instances[0].FrameOfReferenceUID
);
if (shouldDisplaySeg) {
@@ -268,10 +240,7 @@ class CornerstoneCacheService {
}
private _getCornerstoneVolumeImageIds(displaySet, dataSource): string[] {
- const stackImageIds = this._getCornerstoneStackImageIds(
- displaySet,
- dataSource
- );
+ const stackImageIds = this._getCornerstoneStackImageIds(displaySet, dataSource);
return stackImageIds;
}
diff --git a/extensions/cornerstone/src/services/SegmentationService/RTSTRUCT/mapROIContoursToRTStructData.ts b/extensions/cornerstone/src/services/SegmentationService/RTSTRUCT/mapROIContoursToRTStructData.ts
index f17ec5c704..b613074128 100644
--- a/extensions/cornerstone/src/services/SegmentationService/RTSTRUCT/mapROIContoursToRTStructData.ts
+++ b/extensions/cornerstone/src/services/SegmentationService/RTSTRUCT/mapROIContoursToRTStructData.ts
@@ -7,32 +7,27 @@
* @returns An array of object that includes data, id, segmentIndex, color
* and geometry Id
*/
-export function mapROIContoursToRTStructData(
- structureSet: unknown,
- rtDisplaySetUID: unknown
-) {
- return structureSet.ROIContours.map(
- ({ contourPoints, ROINumber, ROIName, colorArray }) => {
- const data = contourPoints.map(({ points, ...rest }) => {
- const newPoints = points.map(({ x, y, z }) => {
- return [x, y, z];
- });
-
- return {
- ...rest,
- points: newPoints,
- };
+export function mapROIContoursToRTStructData(structureSet: unknown, rtDisplaySetUID: unknown) {
+ return structureSet.ROIContours.map(({ contourPoints, ROINumber, ROIName, colorArray }) => {
+ const data = contourPoints.map(({ points, ...rest }) => {
+ const newPoints = points.map(({ x, y, z }) => {
+ return [x, y, z];
});
- const id = ROIName || ROINumber;
-
return {
- data,
- id,
- segmentIndex: ROINumber,
- color: colorArray,
- geometryId: `${rtDisplaySetUID}:${id}:segmentIndex-${ROINumber}`,
+ ...rest,
+ points: newPoints,
};
- }
- );
+ });
+
+ const id = ROIName || ROINumber;
+
+ return {
+ data,
+ id,
+ segmentIndex: ROINumber,
+ color: colorArray,
+ geometryId: `${rtDisplaySetUID}:${id}:segmentIndex-${ROINumber}`,
+ };
+ });
}
diff --git a/extensions/cornerstone/src/services/SegmentationService/SegmentationService.ts b/extensions/cornerstone/src/services/SegmentationService/SegmentationService.ts
index c03b056986..7d61a1dc55 100644
--- a/extensions/cornerstone/src/services/SegmentationService/SegmentationService.ts
+++ b/extensions/cornerstone/src/services/SegmentationService/SegmentationService.ts
@@ -21,11 +21,7 @@ import {
import isEqual from 'lodash.isequal';
import { Types as ohifTypes } from '@ohif/core';
import { easeInOutBell, reverseEaseInOutBell } from '../../utils/transitions';
-import {
- Segment,
- Segmentation,
- SegmentationConfig,
-} from './SegmentationServiceTypes';
+import { Segment, Segmentation, SegmentationConfig } from './SegmentationServiceTypes';
import { mapROIContoursToRTStructData } from './RTSTRUCT/mapROIContoursToRTStructData';
const { COLOR_LUT } = cstConstants;
@@ -42,8 +38,7 @@ const EVENTS = {
// fired when the segmentation is removed
SEGMENTATION_REMOVED: 'event::segmentation_removed',
// fired when the configuration for the segmentation is changed (e.g., brush size, render fill, outline thickness, etc.)
- SEGMENTATION_CONFIGURATION_CHANGED:
- 'event::segmentation_configuration_changed',
+ SEGMENTATION_CONFIGURATION_CHANGED: 'event::segmentation_configuration_changed',
// fired when the active segment is loaded in SEG or RTSTRUCT
SEGMENT_LOADING_COMPLETE: 'event::segment_loading_complete',
// for all segments
@@ -64,9 +59,7 @@ class SegmentationService extends PubSubService {
static REGISTRATION = {
name: 'segmentationService',
altName: 'SegmentationService',
- create: ({
- servicesManager,
- }: OhifTypes.Extensions.ExtensionParams): SegmentationService => {
+ create: ({ servicesManager }: OhifTypes.Extensions.ExtensionParams): SegmentationService => {
return new SegmentationService({ servicesManager });
},
};
@@ -106,42 +99,50 @@ class SegmentationService extends PubSubService {
};
/**
- * It adds a segment to a segmentation, basically just setting the properties for
- * the segment.
- * @param segmentationId - The ID of the segmentation you want to add a
- * segment to.
- * @param segmentIndex - The index of the segment to add.
- * @param properties - The properties of the segment to add including
- * -- label: the label of the segment
- * -- color: the color of the segment
- * -- opacity: the opacity of the segment
- * -- visibility: the visibility of the segment (boolean)
- * -- isLocked: whether the segment is locked for editing
- * -- active: whether the segment is currently the active segment to be edited or not
+ * Adds a new segment to the specified segmentation.
+ * @param segmentationId - The ID of the segmentation to add the segment to.
+ * @param config - An object containing the configuration options for the new segment.
+ * - segmentIndex: (optional) The index of the segment to add. If not provided, the next available index will be used.
+ * - toolGroupId: (optional) The ID of the tool group to associate the new segment with. If not provided, the first available tool group will be used.
+ * - properties: (optional) An object containing the properties of the new segment.
+ * - label: (optional) The label of the new segment. If not provided, a default label will be used.
+ * - color: (optional) The color of the new segment in RGB format. If not provided, a default color will be used.
+ * - opacity: (optional) The opacity of the new segment. If not provided, a default opacity will be used.
+ * - visibility: (optional) Whether the new segment should be visible. If not provided, the segment will be visible by default.
+ * - isLocked: (optional) Whether the new segment should be locked for editing. If not provided, the segment will not be locked by default.
+ * - active: (optional) Whether the new segment should be the active segment to be edited. If not provided, the segment will not be active by default.
*/
public addSegment(
segmentationId: string,
- segmentIndex: number,
- toolGroupId?: string,
- properties?: {
- label?: string;
- color?: ohifTypes.RGB;
- opacity?: number;
- visibility?: boolean;
- isLocked?: boolean;
- active?: boolean;
- }
+ config: {
+ segmentIndex?: number;
+ toolGroupId?: string;
+ properties?: {
+ label?: string;
+ color?: ohifTypes.RGB;
+ opacity?: number;
+ visibility?: boolean;
+ isLocked?: boolean;
+ active?: boolean;
+ };
+ } = {}
): void {
- if (segmentIndex === 0) {
+ if (config?.segmentIndex === 0) {
throw new Error('Segment index 0 is reserved for "no label"');
}
- toolGroupId = toolGroupId ?? this._getFirstToolGroupId();
+ const toolGroupId = config.toolGroupId ?? this._getFirstToolGroupId();
- const {
- segmentationRepresentationUID,
- segmentation,
- } = this._getSegmentationInfo(segmentationId, toolGroupId);
+ const { segmentationRepresentationUID, segmentation } = this._getSegmentationInfo(
+ segmentationId,
+ toolGroupId
+ );
+
+ let segmentIndex = config.segmentIndex;
+ if (!segmentIndex) {
+ // grab the next available segment index
+ segmentIndex = segmentation.segments.length === 0 ? 1 : segmentation.segments.length;
+ }
if (this._getSegmentInfo(segmentation, segmentIndex)) {
throw new Error(`Segment ${segmentIndex} already exists`);
@@ -154,7 +155,7 @@ class SegmentationService extends PubSubService {
);
segmentation.segments[segmentIndex] = {
- label: properties.label,
+ label: config.properties?.label ?? `Segment ${segmentIndex}`,
segmentIndex: segmentIndex,
color: [rgbaColor[0], rgbaColor[1], rgbaColor[2]],
opacity: rgbaColor[3],
@@ -164,34 +165,19 @@ class SegmentationService extends PubSubService {
segmentation.segmentCount++;
+ // make the newly added segment the active segment
+ this._setActiveSegment(segmentationId, segmentIndex);
+
const suppressEvents = true;
- if (properties !== undefined) {
- const {
- color: newColor,
- opacity,
- isLocked,
- visibility,
- active,
- } = properties;
+ if (config.properties !== undefined) {
+ const { color: newColor, opacity, isLocked, visibility, active } = config.properties;
if (newColor !== undefined) {
- this._setSegmentColor(
- segmentationId,
- segmentIndex,
- newColor,
- toolGroupId,
- suppressEvents
- );
+ this._setSegmentColor(segmentationId, segmentIndex, newColor, toolGroupId, suppressEvents);
}
if (opacity !== undefined) {
- this._setSegmentOpacity(
- segmentationId,
- segmentIndex,
- opacity,
- toolGroupId,
- suppressEvents
- );
+ this._setSegmentOpacity(segmentationId, segmentIndex, opacity, toolGroupId, suppressEvents);
}
if (visibility !== undefined) {
@@ -209,12 +195,7 @@ class SegmentationService extends PubSubService {
}
if (isLocked !== undefined) {
- this._setSegmentLocked(
- segmentationId,
- segmentIndex,
- isLocked,
- suppressEvents
- );
+ this._setSegmentLocked(segmentationId, segmentIndex, isLocked, suppressEvents);
}
}
@@ -285,9 +266,7 @@ class SegmentationService extends PubSubService {
if (segmentation.activeSegmentIndex === segmentIndex) {
const segmentIndices = Object.keys(segmentation.segments);
- const newActiveSegmentIndex = segmentIndices.length
- ? Number(segmentIndices[0])
- : 1;
+ const newActiveSegmentIndex = segmentIndices.length ? Number(segmentIndices[0]) : 1;
this._setActiveSegment(segmentationId, newActiveSegmentIndex, true);
}
@@ -313,26 +292,21 @@ class SegmentationService extends PubSubService {
);
}
- public setSegmentLockedForSegmentation(
- segmentationId: string,
- segmentIndex: number,
- isLocked: boolean
- ): void {
+ public setSegmentLocked(segmentationId: string, segmentIndex: number, isLocked: boolean): void {
const suppressEvents = false;
- this._setSegmentLocked(
- segmentationId,
- segmentIndex,
- isLocked,
- suppressEvents
- );
+ this._setSegmentLocked(segmentationId, segmentIndex, isLocked, suppressEvents);
}
- public setSegmentLabel(
- segmentationId: string,
- segmentIndex: number,
- segmentLabel: string
- ): void {
- this._setSegmentLabel(segmentationId, segmentIndex, segmentLabel);
+ /**
+ * Toggles the locked state of a segment in a segmentation.
+ * @param segmentationId - The ID of the segmentation.
+ * @param segmentIndex - The index of the segment to toggle.
+ */
+ public toggleSegmentLocked(segmentationId: string, segmentIndex: number): void {
+ const segmentation = this.getSegmentation(segmentationId);
+ const segment = this._getSegmentInfo(segmentation, segmentIndex);
+ const isLocked = !segment.isLocked;
+ this._setSegmentLocked(segmentationId, segmentIndex, isLocked);
}
public setSegmentColor(
@@ -387,24 +361,14 @@ class SegmentationService extends PubSubService {
this._setSegmentOpacity(segmentationId, segmentIndex, opacity, toolGroupId);
}
- public setActiveSegmentationForToolGroup(
- segmentationId: string,
- toolGroupId?: string
- ): void {
+ public setActiveSegmentationForToolGroup(segmentationId: string, toolGroupId?: string): void {
toolGroupId = toolGroupId ?? this._getFirstToolGroupId();
const suppressEvents = false;
- this._setActiveSegmentationForToolGroup(
- segmentationId,
- toolGroupId,
- suppressEvents
- );
+ this._setActiveSegmentationForToolGroup(segmentationId, toolGroupId, suppressEvents);
}
- public setActiveSegmentForSegmentation(
- segmentationId: string,
- segmentIndex: number
- ): void {
+ public setActiveSegment(segmentationId: string, segmentIndex: number): void {
this._setActiveSegment(segmentationId, segmentIndex, false);
}
@@ -420,9 +384,7 @@ class SegmentationService extends PubSubService {
* @return Array of segmentations
*/
- public getSegmentations(
- filterNonHydratedSegmentations = true
- ): Segmentation[] {
+ public getSegmentations(filterNonHydratedSegmentations = true): Segmentation[] {
const segmentations = this._getSegmentations();
return (
@@ -435,10 +397,7 @@ class SegmentationService extends PubSubService {
private _getSegmentations(): Segmentation[] {
const segmentations = this.arrayOfObjects(this.segmentations);
- return (
- segmentations &&
- segmentations.map(m => this.segmentations[Object.keys(m)[0]])
- );
+ return segmentations && segmentations.map(m => this.segmentations[Object.keys(m)[0]]);
}
/**
@@ -477,8 +436,7 @@ class SegmentationService extends PubSubService {
}
const representationType = segmentation.type;
- const representationData =
- segmentation.representationData[representationType];
+ const representationData = segmentation.representationData[representationType];
cstSegmentation.addSegmentations([
{
segmentationId,
@@ -491,12 +449,14 @@ class SegmentationService extends PubSubService {
},
]);
- // Define a new color LUT and associate it with this segmentation.
- // Todo: need to be generalized to accept custom color LUTs
- const newColorLUT = this.generateNewColorLUT();
- const newColorLUTIndex = this.getNextColorLUTIndex();
-
- cstSegmentation.config.color.addColorLUT(newColorLUT, newColorLUTIndex);
+ // if first segmentation, we can use the default colorLUT, otherwise
+ // we need to generate a new one and use a new colorLUT
+ const colorLUTIndex = 0;
+ if (Object.keys(this.segmentations).length !== 0) {
+ const newColorLUT = this.generateNewColorLUT();
+ const colorLUTIndex = this.getNextColorLUTIndex();
+ cstSegmentation.config.color.addColorLUT(newColorLUT, colorLUTIndex);
+ }
this.segmentations[segmentationId] = {
...segmentation,
@@ -505,8 +465,8 @@ class SegmentationService extends PubSubService {
activeSegmentIndex: segmentation.activeSegmentIndex ?? null,
segmentCount: segmentation.segmentCount ?? 0,
isActive: false,
- colorLUTIndex: newColorLUTIndex,
isVisible: true,
+ colorLUTIndex,
};
cachedSegmentation = this.segmentations[segmentationId];
@@ -542,6 +502,7 @@ class SegmentationService extends PubSubService {
id: segmentationId,
displaySetInstanceUID: segDisplaySet.displaySetInstanceUID,
type: representationType,
+ label: segDisplaySet.SeriesDescription,
representationData: {
[LABELMAP]: {
volumeId: segmentationId,
@@ -562,12 +523,10 @@ class SegmentationService extends PubSubService {
);
}
- const { segments, referencedVolumeId } = segDisplaySet;
+ const { labelmapBufferArray, referencedVolumeId } = segDisplaySet;
- if (!segments || !referencedVolumeId) {
- throw new Error(
- 'To create the segmentation from SEG displaySet, the displaySet should be loaded first, you can perform segDisplaySet.load() before calling this method.'
- );
+ if (!labelmapBufferArray || !referencedVolumeId) {
+ throw new Error('No labelmapBufferArray or referencedVolumeId found for the SEG displaySet');
}
// if the labelmap doesn't exist, we need to create it first from the
@@ -575,105 +534,39 @@ class SegmentationService extends PubSubService {
const referencedVolume = cache.getVolume(referencedVolumeId);
if (!referencedVolume) {
- throw new Error(
- `No volume found for referencedVolumeId: ${referencedVolumeId}`
- );
+ throw new Error(`No volume found for referencedVolumeId: ${referencedVolumeId}`);
}
// Force use of a Uint8Array SharedArrayBuffer for the segmentation to save space and so
// it is easily compressible in worker thread.
- const derivedVolume = await volumeLoader.createAndCacheDerivedVolume(
- referencedVolumeId,
- {
- volumeId: segmentationId,
- targetBuffer: {
- type: 'Uint8Array',
- sharedArrayBuffer: true,
- },
- }
- );
- const [rows, columns] = derivedVolume.dimensions;
+ const derivedVolume = await volumeLoader.createAndCacheDerivedVolume(referencedVolumeId, {
+ volumeId: segmentationId,
+ targetBuffer: {
+ type: 'Uint8Array',
+ sharedArrayBuffer: true,
+ },
+ });
const derivedVolumeScalarData = derivedVolume.getScalarData();
- const { imageIds } = referencedVolume;
- const sopUIDImageIdIndexMap = imageIds.reduce((acc, imageId, index) => {
- const { sopInstanceUid } = metaData.get('generalImageModule', imageId);
- acc[sopInstanceUid] = index;
- return acc;
- }, {} as { [sopUID: string]: number });
-
- const numSegments = Object.keys(segments).length;
- // Note: ideally we could use the TypedArray set method, but since each
- // slice can have multiple segments, we need to loop over each slice and
- // set the segment value for each segment.
- let overlappingSegments = false;
-
- const _segmentInfoUpdate = (segmentInfo, segmentIndex) => {
- const { pixelData: segPixelData } = segmentInfo;
-
- let segmentX = 0;
- let segmentY = 0;
- let segmentZ = 0;
- let count = 0;
-
- for (const [
- functionalGroupIndex,
- functionalGroup,
- ] of segmentInfo.functionalGroups.entries()) {
- const {
- ReferencedSOPInstanceUID,
- } = functionalGroup.DerivationImageSequence.SourceImageSequence;
-
- const imageIdIndex = sopUIDImageIdIndexMap[ReferencedSOPInstanceUID];
-
- if (imageIdIndex === -1) {
- return;
- }
-
- const step = rows * columns;
+ const segmentsInfo = segDisplaySet.segMetadata.data;
+ derivedVolumeScalarData.set(new Uint8Array(labelmapBufferArray[0]));
- // we need a faster way to get the pixel data for the current
- // functional group, which we use typed array view
-
- const functionGroupPixelData = new Uint8Array(
- segPixelData.buffer,
- functionalGroupIndex * step,
- step
- );
-
- const functionalGroupStartIndex = imageIdIndex * step;
- const functionalGroupEndIndex = (imageIdIndex + 1) * step;
-
- // Note: this for loop is not optimized, since DICOM SEG stores
- // each segment as a separate labelmap so if there is a slice
- // that has multiple segments, we will have to loop over each
- // segment and we cannot use the TypedArray set method.
- for (
- let i = functionalGroupStartIndex, j = 0;
- i < functionalGroupEndIndex;
- i++, j++
- ) {
- if (functionGroupPixelData[j] !== 0) {
- if (derivedVolumeScalarData[i] !== 0) {
- overlappingSegments = true;
- }
-
- derivedVolumeScalarData[i] = segmentIndex;
-
- // centroid calculations
- segmentX += i % columns;
- segmentY += Math.floor(i / columns) % rows;
- segmentZ += Math.floor(i / (columns * rows));
- count++;
- }
- }
+ segmentation.segments = segmentsInfo.map((segmentInfo, segmentIndex) => {
+ if (segmentIndex === 0) {
+ return;
}
- // centroid calculations
- const x = Math.floor(segmentX / count);
- const y = Math.floor(segmentY / count);
- const z = Math.floor(segmentZ / count);
-
+ const {
+ SegmentedPropertyCategoryCodeSequence,
+ SegmentNumber,
+ SegmentLabel,
+ SegmentAlgorithmType,
+ SegmentAlgorithmName,
+ SegmentedPropertyTypeCodeSequence,
+ rgba,
+ } = segmentInfo;
+
+ const { x, y, z } = segDisplaySet.centroids.get(segmentIndex);
const centerWorld = derivedVolume.imageData.indexToWorld([x, y, z]);
segmentation.cachedStats = {
@@ -690,65 +583,31 @@ class SegmentationService extends PubSubService {
},
};
- const numInitialized = Object.keys(segmentation.cachedStats.segmentCenter)
- .length;
-
- // Calculate percentage completed
- const percentComplete = Math.round((numInitialized / numSegments) * 100);
-
- this._broadcastEvent(EVENTS.SEGMENT_LOADING_COMPLETE, {
- percentComplete,
- numSegments: numSegments,
- });
- };
-
- const promiseArray = [];
-
- for (const segmentIndex in segments) {
- const segmentInfo = segments[segmentIndex];
-
- // Important: we need a non-blocking way to update the segmentation
- // state, otherwise the UI will freeze and the user will not be able
- // to interact with the app or progress bars will not be updated.
- const promise = new Promise((resolve, reject) => {
- setTimeout(() => {
- _segmentInfoUpdate(segmentInfo, segmentIndex);
- resolve();
- }, 0);
- });
-
- promiseArray.push(promise);
- }
-
- await Promise.all(promiseArray);
-
- segmentation.segmentCount = Object.keys(segments).length;
- segmentation.segments = [null]; // segment 0
-
- Object.keys(segments).forEach(segmentIndex => {
- const segmentInfo = segments[segmentIndex];
- const segIndex = Number(segmentIndex);
-
- segmentation.segments[segIndex] = {
- label: segmentInfo.label || `Segment ${segIndex}`,
- segmentIndex: Number(segmentIndex),
- color: [
- segmentInfo.color[0],
- segmentInfo.color[1],
- segmentInfo.color[2],
- ],
- opacity: segmentInfo.color[3],
+ return {
+ label: SegmentLabel || `Segment ${SegmentNumber}`,
+ segmentIndex: Number(SegmentNumber),
+ category: SegmentedPropertyCategoryCodeSequence
+ ? SegmentedPropertyCategoryCodeSequence.CodeMeaning
+ : '',
+ type: SegmentedPropertyTypeCodeSequence
+ ? SegmentedPropertyTypeCodeSequence.CodeMeaning
+ : '',
+ algorithmType: SegmentAlgorithmType,
+ algorithmName: SegmentAlgorithmName,
+ color: rgba,
+ opacity: 255,
isVisible: true,
isLocked: false,
};
});
+ segmentation.segmentCount = segmentsInfo.length - 1;
+
segDisplaySet.isLoaded = true;
this._broadcastEvent(EVENTS.SEGMENTATION_LOADING_COMPLETE, {
segmentationId,
segDisplaySet,
- overlappingSegments,
});
return this.addOrUpdateSegmentation(segmentation, suppressEvents);
@@ -774,10 +633,7 @@ class SegmentationService extends PubSubService {
const defaultScheme = this._getDefaultSegmentationScheme();
const rtDisplaySetUID = rtDisplaySet.displaySetInstanceUID;
- const allRTStructData = mapROIContoursToRTStructData(
- structureSet,
- rtDisplaySetUID
- );
+ const allRTStructData = mapROIContoursToRTStructData(structureSet, rtDisplaySetUID);
// sort by segmentIndex
allRTStructData.sort((a, b) => a.segmentIndex - b.segmentIndex);
@@ -789,6 +645,7 @@ class SegmentationService extends PubSubService {
id: segmentationId,
displaySetInstanceUID: rtDisplaySetUID,
type: representationType,
+ label: rtDisplaySet.SeriesDescription,
representationData: {
[CONTOUR]: {
geometryIds,
@@ -816,45 +673,49 @@ class SegmentationService extends PubSubService {
const segmentsCachedStats = {};
const initializeContour = async rtStructData => {
const { data, id, color, segmentIndex, geometryId } = rtStructData;
- const geometry = await geometryLoader.createAndCacheGeometry(geometryId, {
- geometryData: {
- data,
- id,
- color,
- frameOfReferenceUID: structureSet.frameOfReferenceUID,
- segmentIndex,
- },
- type: csEnums.GeometryType.CONTOUR,
- });
- const contourSet = geometry.data;
- const centroid = contourSet.getCentroid();
+ // catch error instead of failing to allow loading to continue
+ try {
+ const geometry = await geometryLoader.createAndCacheGeometry(geometryId, {
+ geometryData: {
+ data,
+ id,
+ color,
+ frameOfReferenceUID: structureSet.frameOfReferenceUID,
+ segmentIndex,
+ },
+ type: csEnums.GeometryType.CONTOUR,
+ });
- segmentsCachedStats[segmentIndex] = {
- center: { world: centroid },
- modifiedTime: rtDisplaySet.SeriesDate, // we use the SeriesDate as the modifiedTime since this is the first time we are creating the segmentation
- };
+ const contourSet = geometry.data;
+ const centroid = contourSet.getCentroid();
- segmentation.segments[segmentIndex] = {
- label: id,
- segmentIndex,
- color,
- ...SEGMENT_CONSTANT,
- };
+ segmentsCachedStats[segmentIndex] = {
+ center: { world: centroid },
+ modifiedTime: rtDisplaySet.SeriesDate, // we use the SeriesDate as the modifiedTime since this is the first time we are creating the segmentation
+ };
- const numInitialized = Object.keys(segmentsCachedStats).length;
+ segmentation.segments[segmentIndex] = {
+ label: id,
+ segmentIndex,
+ color,
+ ...SEGMENT_CONSTANT,
+ };
- // Calculate percentage completed
- const percentComplete = Math.round(
- (numInitialized / allRTStructData.length) * 100
- );
+ const numInitialized = Object.keys(segmentsCachedStats).length;
- this._broadcastEvent(EVENTS.SEGMENT_LOADING_COMPLETE, {
- percentComplete,
- // Note: this is not the geometryIds length since there might be
- // some missing ROINumbers
- numSegments: allRTStructData.length,
- });
+ // Calculate percentage completed
+ const percentComplete = Math.round((numInitialized / allRTStructData.length) * 100);
+
+ this._broadcastEvent(EVENTS.SEGMENT_LOADING_COMPLETE, {
+ percentComplete,
+ // Note: this is not the geometryIds length since there might be
+ // some missing ROINumbers
+ numSegments: allRTStructData.length,
+ });
+ } catch (e) {
+ console.warn(e);
+ }
};
const promiseArray = [];
@@ -892,6 +753,97 @@ class SegmentationService extends PubSubService {
return this.addOrUpdateSegmentation(segmentation, suppressEvents);
}
+ // Todo: this should not run on the main thread
+ public calculateCentroids = (
+ segmentationId: string,
+ segmentIndex?: number
+ ): Map => {
+ const segmentation = this.getSegmentation(segmentationId);
+ const volume = this.getLabelmapVolume(segmentationId);
+ const { dimensions, imageData } = volume;
+ const scalarData = volume.getScalarData();
+ const [dimX, dimY, numFrames] = dimensions;
+ const frameLength = dimX * dimY;
+
+ const segmentIndices = segmentIndex
+ ? [segmentIndex]
+ : segmentation.segments
+ .filter(segment => segment?.segmentIndex)
+ .map(segment => segment.segmentIndex);
+
+ const segmentIndicesSet = new Set(segmentIndices);
+
+ const centroids = new Map();
+ for (const index of segmentIndicesSet) {
+ centroids.set(index, { x: 0, y: 0, z: 0, count: 0 });
+ }
+
+ let voxelIndex = 0;
+ for (let frame = 0; frame < numFrames; frame++) {
+ for (let p = 0; p < frameLength; p++) {
+ const segmentIndex = scalarData[voxelIndex++];
+ if (segmentIndicesSet.has(segmentIndex)) {
+ const centroid = centroids.get(segmentIndex);
+ centroid.x += p % dimX;
+ centroid.y += (p / dimX) | 0;
+ centroid.z += frame;
+ centroid.count++;
+ }
+ }
+ }
+
+ const result = new Map();
+ for (const [index, centroid] of centroids) {
+ const count = centroid.count;
+ const normalizedCentroid = {
+ x: centroid.x / count,
+ y: centroid.y / count,
+ z: centroid.z / count,
+ };
+ normalizedCentroid.world = imageData.indexToWorld([
+ normalizedCentroid.x,
+ normalizedCentroid.y,
+ normalizedCentroid.z,
+ ]);
+ result.set(index, normalizedCentroid);
+ }
+
+ this.setCentroids(segmentationId, result);
+ return result;
+ };
+
+ private setCentroids = (
+ segmentationId: string,
+ centroids: Map
+ ): void => {
+ const segmentation = this.getSegmentation(segmentationId);
+ const imageData = this.getLabelmapVolume(segmentationId).imageData; // Assuming this method returns imageData
+
+ if (!segmentation.cachedStats) {
+ segmentation.cachedStats = { segmentCenter: {} };
+ } else if (!segmentation.cachedStats.segmentCenter) {
+ segmentation.cachedStats.segmentCenter = {};
+ }
+
+ for (const [segmentIndex, centroid] of centroids) {
+ let world = centroid.world;
+
+ // If world coordinates are not provided, calculate them
+ if (!world || world.length === 0) {
+ world = imageData.indexToWorld(centroid.image);
+ }
+
+ segmentation.cachedStats.segmentCenter[segmentIndex] = {
+ center: {
+ image: centroid.image,
+ world: world,
+ },
+ };
+ }
+
+ this.addOrUpdateSegmentation(segmentation, true, true);
+ };
+
public jumpToSegmentCenter(
segmentationId: string,
segmentIndex: number,
@@ -905,11 +857,14 @@ class SegmentationService extends PubSubService {
const { toolGroupService } = this.servicesManager.services;
const center = this._getSegmentCenter(segmentationId, segmentIndex);
+ if (!center?.world) {
+ return;
+ }
+
const { world } = center;
// todo: generalize
- toolGroupId =
- toolGroupId || this._getToolGroupIdsWithSegmentation(segmentationId);
+ toolGroupId = toolGroupId || this._getToolGroupIdsWithSegmentation(segmentationId);
const toolGroups = [];
@@ -926,10 +881,7 @@ class SegmentationService extends PubSubService {
// @ts-ignore
for (const { viewportId, renderingEngineId } of viewportsInfo) {
- const { viewport } = getEnabledElementByIds(
- viewportId,
- renderingEngineId
- );
+ const { viewport } = getEnabledElementByIds(viewportId, renderingEngineId);
cstUtils.viewport.jumpToWorld(viewport, world);
}
@@ -972,9 +924,7 @@ class SegmentationService extends PubSubService {
const { segments } = segmentation;
const highlightFn =
- type === LABELMAP
- ? this._highlightLabelmap.bind(this)
- : this._highlightContour.bind(this);
+ type === LABELMAP ? this._highlightLabelmap.bind(this) : this._highlightContour.bind(this);
const adjustedAlpha = type === LABELMAP ? alpha : 1 - alpha;
@@ -993,14 +943,13 @@ class SegmentationService extends PubSubService {
displaySetInstanceUID: string,
options?: {
segmentationId: string;
+ FrameOfReferenceUID: string;
label: string;
}
): Promise => {
const { displaySetService } = this.servicesManager.services;
- const displaySet = displaySetService.getDisplaySetByUID(
- displaySetInstanceUID
- );
+ const displaySet = displaySetService.getDisplaySetByUID(displaySetInstanceUID);
// Todo: we currently only support labelmap for segmentation for a displaySet
const representationType = LABELMAP;
@@ -1029,6 +978,8 @@ class SegmentationService extends PubSubService {
// We should set it as active by default, as it created for display
isActive: true,
type: representationType,
+ FrameOfReferenceUID:
+ options?.FrameOfReferenceUID || displaySet.instances?.[0]?.FrameOfReferenceUID,
representationData: {
LABELMAP: {
volumeId: segmentationId,
@@ -1056,14 +1007,13 @@ class SegmentationService extends PubSubService {
toolGroupId: string,
segmentationId: string,
hydrateSegmentation = false,
- representationType = csToolsEnums.SegmentationRepresentations.Labelmap
+ representationType = csToolsEnums.SegmentationRepresentations.Labelmap,
+ suppressEvents = false
): Promise => {
const segmentation = this.getSegmentation(segmentationId);
if (!segmentation) {
- throw new Error(
- `Segmentation with segmentationId ${segmentationId} not found.`
- );
+ throw new Error(`Segmentation with segmentationId ${segmentationId} not found.`);
}
if (hydrateSegmentation) {
@@ -1103,34 +1053,16 @@ class SegmentationService extends PubSubService {
continue;
}
- const {
- segmentIndex,
- color,
- isLocked,
- isVisible: visibility,
- opacity,
- } = segment;
+ const { segmentIndex, color, isLocked, isVisible: visibility, opacity } = segment;
const suppressEvents = true;
if (color !== undefined) {
- this._setSegmentColor(
- segmentationId,
- segmentIndex,
- color,
- toolGroupId,
- suppressEvents
- );
+ this._setSegmentColor(segmentationId, segmentIndex, color, toolGroupId, suppressEvents);
}
if (opacity !== undefined) {
- this._setSegmentOpacity(
- segmentationId,
- segmentIndex,
- opacity,
- toolGroupId,
- suppressEvents
- );
+ this._setSegmentOpacity(segmentationId, segmentIndex, opacity, toolGroupId, suppressEvents);
}
if (visibility !== undefined) {
@@ -1143,18 +1075,19 @@ class SegmentationService extends PubSubService {
);
}
- if (isLocked !== undefined) {
- this._setSegmentLocked(
- segmentationId,
- segmentIndex,
- isLocked,
- suppressEvents
- );
+ if (isLocked) {
+ this._setSegmentLocked(segmentationId, segmentIndex, isLocked, suppressEvents);
}
}
+
+ if (!suppressEvents) {
+ this._broadcastEvent(this.EVENTS.SEGMENTATION_UPDATED, {
+ segmentation,
+ });
+ }
};
- public setSegmentRGBAColorForSegmentation = (
+ public setSegmentRGBAColor = (
segmentationId: string,
segmentIndex: number,
rgbaColor,
@@ -1186,29 +1119,22 @@ class SegmentationService extends PubSubService {
});
};
- public getToolGroupIdsWithSegmentation = (
- segmentationId: string
- ): string[] => {
- const toolGroupIds = cstSegmentation.state.getToolGroupIdsWithSegmentation(
- segmentationId
- );
+ public getToolGroupIdsWithSegmentation = (segmentationId: string): string[] => {
+ const toolGroupIds = cstSegmentation.state.getToolGroupIdsWithSegmentation(segmentationId);
return toolGroupIds;
};
- public hydrateSegmentation = (
- segmentationId: string,
- suppressEvents = false
- ): void => {
+ public hydrateSegmentation = (segmentationId: string, suppressEvents = false): void => {
const segmentation = this.getSegmentation(segmentationId);
if (!segmentation) {
- throw new Error(
- `Segmentation with segmentationId ${segmentationId} not found.`
- );
+ throw new Error(`Segmentation with segmentationId ${segmentationId} not found.`);
}
-
segmentation.hydrated = true;
+ // Not all segmentations have dipslaysets, some of them are derived in the client
+ this._setDisplaySetIsHydrated(segmentationId, true);
+
if (!suppressEvents) {
this._broadcastEvent(this.EVENTS.SEGMENTATION_UPDATED, {
segmentation,
@@ -1216,6 +1142,18 @@ class SegmentationService extends PubSubService {
}
};
+ private _setDisplaySetIsHydrated(displaySetUID: string, isHydrated: boolean): void {
+ const { displaySetService } = this.servicesManager.services;
+ const displaySet = displaySetService.getDisplaySetByUID(displaySetUID);
+
+ if (!displaySet) {
+ return;
+ }
+
+ displaySet.isHydrated = isHydrated;
+ displaySetService.setDisplaySetMetadataInvalidated(displaySetUID, false);
+ }
+
private _highlightLabelmap(
segmentIndex: number,
alpha: number,
@@ -1329,17 +1267,13 @@ class SegmentationService extends PubSubService {
): void {
const uids = segmentationRepresentationUIDsIds || [];
if (!uids.length) {
- const representations = cstSegmentation.state.getSegmentationRepresentations(
- toolGroupId
- );
+ const representations = cstSegmentation.state.getSegmentationRepresentations(toolGroupId);
if (!representations || !representations.length) {
return;
}
- uids.push(
- ...representations.map(rep => rep.segmentationRepresentationUID)
- );
+ uids.push(...representations.map(rep => rep.segmentationRepresentationUID));
}
cstSegmentation.removeSegmentationsFromToolGroup(toolGroupId, uids);
@@ -1355,14 +1289,11 @@ class SegmentationService extends PubSubService {
const wasActive = segmentation.isActive;
if (!segmentationId || !segmentation) {
- console.warn(
- `No segmentationId provided, or unable to find segmentation by id.`
- );
+ console.warn(`No segmentationId provided, or unable to find segmentation by id.`);
return;
}
const { colorLUTIndex } = segmentation;
-
this._removeSegmentationFromCornerstone(segmentationId);
// Delete associated colormap
@@ -1376,17 +1307,19 @@ class SegmentationService extends PubSubService {
if (wasActive) {
const remainingSegmentations = this._getSegmentations();
- if (remainingSegmentations.length) {
- const { id } = remainingSegmentations[0];
+ const remainingHydratedSegmentations = remainingSegmentations.filter(
+ segmentation => segmentation.hydrated
+ );
- this._setActiveSegmentationForToolGroup(
- id,
- this._getFirstToolGroupId(),
- false
- );
+ if (remainingHydratedSegmentations.length) {
+ const { id } = remainingHydratedSegmentations[0];
+
+ this._setActiveSegmentationForToolGroup(id, this._getFirstToolGroupId(), false);
}
}
+ this._setDisplaySetIsHydrated(segmentationId, false);
+
this._broadcastEvent(this.EVENTS.SEGMENTATION_REMOVED, {
segmentationId,
});
@@ -1405,9 +1338,8 @@ class SegmentationService extends PubSubService {
// toolGroupId
// );
- const segmentationRepresentations = this.getSegmentationRepresentationsForToolGroup(
- toolGroupId
- );
+ const segmentationRepresentations =
+ this.getSegmentationRepresentationsForToolGroup(toolGroupId);
const typeToUse = segmentationRepresentations?.[0]?.type || LABELMAP;
@@ -1465,11 +1397,7 @@ class SegmentationService extends PubSubService {
setConfigValueIfDefined('outlineOpacity', outlineOpacity, v => v / 100);
setConfigValueIfDefined('fillAlpha', fillAlpha, v => v / 100);
setConfigValueIfDefined('renderFill', renderFill);
- setConfigValueIfDefined(
- 'fillAlphaInactive',
- fillAlphaInactive,
- v => v / 100
- );
+ setConfigValueIfDefined('fillAlphaInactive', fillAlphaInactive, v => v / 100);
setConfigValueIfDefined('outlineOpacityInactive', fillAlphaInactive, v =>
Math.max(0.75, v / 100)
);
@@ -1503,10 +1431,7 @@ class SegmentationService extends PubSubService {
// });
// }
- this._broadcastEvent(
- this.EVENTS.SEGMENTATION_CONFIGURATION_CHANGED,
- this.getConfiguration()
- );
+ this._broadcastEvent(this.EVENTS.SEGMENTATION_CONFIGURATION_CHANGED, this.getConfiguration());
};
public getLabelmapVolume = (segmentationId: string) => {
@@ -1517,15 +1442,11 @@ class SegmentationService extends PubSubService {
return cstSegmentation.state.getSegmentationRepresentations(toolGroupId);
};
- public setSegmentLabelForSegmentation(
- segmentationId: string,
- segmentIndex: number,
- label: string
- ) {
- this._setSegmentLabelForSegmentation(segmentationId, segmentIndex, label);
+ public setSegmentLabel(segmentationId: string, segmentIndex: number, label: string) {
+ this._setSegmentLabel(segmentationId, segmentIndex, label);
}
- private _setSegmentLabelForSegmentation(
+ private _setSegmentLabel(
segmentationId: string,
segmentIndex: number,
label: string,
@@ -1540,9 +1461,7 @@ class SegmentationService extends PubSubService {
const segmentInfo = segmentation.segments[segmentIndex];
if (segmentInfo === undefined) {
- throw new Error(
- `Segment ${segmentIndex} not yet added to segmentation: ${segmentationId}`
- );
+ throw new Error(`Segment ${segmentIndex} not yet added to segmentation: ${segmentationId}`);
}
segmentInfo.label = label;
@@ -1555,14 +1474,8 @@ class SegmentationService extends PubSubService {
}
}
- public shouldRenderSegmentation(
- viewportDisplaySetInstanceUIDs,
- segDisplaySetInstanceUID
- ) {
- if (
- !viewportDisplaySetInstanceUIDs ||
- !viewportDisplaySetInstanceUIDs.length
- ) {
+ public shouldRenderSegmentation(viewportDisplaySetInstanceUIDs, segmentationFrameOfReferenceUID) {
+ if (!viewportDisplaySetInstanceUIDs?.length) {
return false;
}
@@ -1570,26 +1483,16 @@ class SegmentationService extends PubSubService {
let shouldDisplaySeg = false;
- const segDisplaySet = displaySetService.getDisplaySetByUID(
- segDisplaySetInstanceUID
- );
-
- const segFrameOfReferenceUID = this._getFrameOfReferenceUIDForSeg(
- segDisplaySet
- );
-
// check if the displaySet is sharing the same frameOfReferenceUID
// with the new segmentation
for (const displaySetInstanceUID of viewportDisplaySetInstanceUIDs) {
- const displaySet = displaySetService.getDisplaySetByUID(
- displaySetInstanceUID
- );
+ const displaySet = displaySetService.getDisplaySetByUID(displaySetInstanceUID);
// Todo: this might not be ideal for use cases such as 4D, since we
// don't want to show the segmentation for all the frames
if (
displaySet.isReconstructable &&
- displaySet?.images?.[0]?.FrameOfReferenceUID === segFrameOfReferenceUID
+ displaySet?.images?.[0]?.FrameOfReferenceUID === segmentationFrameOfReferenceUID
) {
shouldDisplaySeg = true;
break;
@@ -1631,10 +1534,7 @@ class SegmentationService extends PubSubService {
segmentation.isActive = segmentation.id === segmentationId;
});
- const representation = this._getSegmentationRepresentation(
- segmentationId,
- toolGroupId
- );
+ const representation = this._getSegmentationRepresentation(segmentationId, toolGroupId);
cstSegmentation.activeSegmentation.setActiveSegmentationRepresentation(
toolGroupId,
@@ -1648,16 +1548,11 @@ class SegmentationService extends PubSubService {
}
}
- private _toggleSegmentationVisibility = (
- segmentationId: string,
- suppressEvents = false
- ) => {
+ private _toggleSegmentationVisibility = (segmentationId: string, suppressEvents = false) => {
const segmentation = this.segmentations[segmentationId];
if (!segmentation) {
- throw new Error(
- `Segmentation with segmentationId ${segmentationId} not found.`
- );
+ throw new Error(`Segmentation with segmentationId ${segmentationId} not found.`);
}
segmentation.isVisible = !segmentation.isVisible;
@@ -1671,21 +1566,14 @@ class SegmentationService extends PubSubService {
}
};
- private _setActiveSegment(
- segmentationId: string,
- segmentIndex: number,
- suppressEvents = false
- ) {
+ private _setActiveSegment(segmentationId: string, segmentIndex: number, suppressEvents = false) {
const segmentation = this.getSegmentation(segmentationId);
if (segmentation === undefined) {
throw new Error(`no segmentation for segmentationId: ${segmentationId}`);
}
- cstSegmentation.segmentIndex.setActiveSegmentIndex(
- segmentationId,
- segmentIndex
- );
+ cstSegmentation.segmentIndex.setActiveSegmentIndex(segmentationId, segmentIndex);
segmentation.activeSegmentIndex = segmentIndex;
@@ -1709,8 +1597,7 @@ class SegmentationService extends PubSubService {
}
private _getVolumeIdForDisplaySet(displaySet) {
- const volumeLoaderSchema =
- displaySet.volumeLoaderSchema ?? VOLUME_LOADER_SCHEME;
+ const volumeLoaderSchema = displaySet.volumeLoaderSchema ?? VOLUME_LOADER_SCHEME;
return `${volumeLoaderSchema}:${displaySet.displaySetInstanceUID}`;
}
@@ -1731,9 +1618,7 @@ class SegmentationService extends PubSubService {
const segmentInfo = this._getSegmentInfo(segmentation, segmentIndex);
if (segmentInfo === undefined) {
- throw new Error(
- `Segment ${segmentIndex} not yet added to segmentation: ${segmentationId}`
- );
+ throw new Error(`Segment ${segmentIndex} not yet added to segmentation: ${segmentationId}`);
}
toolGroupId = toolGroupId ?? this._getFirstToolGroupId();
@@ -1744,9 +1629,7 @@ class SegmentationService extends PubSubService {
);
if (!segmentationRepresentation) {
- throw new Error(
- 'Must add representation to toolgroup before setting segments'
- );
+ throw new Error('Must add representation to toolgroup before setting segments');
}
const { segmentationRepresentationUID } = segmentationRepresentation;
@@ -1811,18 +1694,12 @@ class SegmentationService extends PubSubService {
const segmentInfo = this._getSegmentInfo(segmentation, segmentIndex);
if (segmentInfo === undefined) {
- throw new Error(
- `Segment ${segmentIndex} not yet added to segmentation: ${segmentationId}`
- );
+ throw new Error(`Segment ${segmentIndex} not yet added to segmentation: ${segmentationId}`);
}
segmentInfo.isLocked = isLocked;
- cstSegmentation.segmentLocking.setSegmentIndexLocked(
- segmentationId,
- segmentIndex,
- isLocked
- );
+ cstSegmentation.segmentLocking.setSegmentIndexLocked(segmentationId, segmentIndex, isLocked);
if (suppressEvents === false) {
this._broadcastEvent(this.EVENTS.SEGMENTATION_UPDATED, {
@@ -1840,10 +1717,10 @@ class SegmentationService extends PubSubService {
) {
toolGroupId = toolGroupId ?? this._getFirstToolGroupId();
- const {
- segmentationRepresentationUID,
- segmentation,
- } = this._getSegmentationInfo(segmentationId, toolGroupId);
+ const { segmentationRepresentationUID, segmentation } = this._getSegmentationInfo(
+ segmentationId,
+ toolGroupId
+ );
if (segmentation === undefined) {
throw new Error(`no segmentation for segmentationId: ${segmentationId}`);
@@ -1852,9 +1729,7 @@ class SegmentationService extends PubSubService {
const segmentInfo = this._getSegmentInfo(segmentation, segmentIndex);
if (segmentInfo === undefined) {
- throw new Error(
- `Segment ${segmentIndex} not yet added to segmentation: ${segmentationId}`
- );
+ throw new Error(`Segment ${segmentIndex} not yet added to segmentation: ${segmentationId}`);
}
segmentInfo.isVisible = isVisible;
@@ -1896,9 +1771,7 @@ class SegmentationService extends PubSubService {
const segmentInfo = this._getSegmentInfo(segmentation, segmentIndex);
if (segmentInfo === undefined) {
- throw new Error(
- `Segment ${segmentIndex} not yet added to segmentation: ${segmentationId}`
- );
+ throw new Error(`Segment ${segmentIndex} not yet added to segmentation: ${segmentationId}`);
}
toolGroupId = toolGroupId ?? this._getFirstToolGroupId();
@@ -1909,9 +1782,7 @@ class SegmentationService extends PubSubService {
);
if (!segmentationRepresentation) {
- throw new Error(
- 'Must add representation to toolgroup before setting segments'
- );
+ throw new Error('Must add representation to toolgroup before setting segments');
}
const { segmentationRepresentationUID } = segmentationRepresentation;
@@ -1952,9 +1823,7 @@ class SegmentationService extends PubSubService {
const segmentInfo = this._getSegmentInfo(segmentation, segmentIndex);
if (segmentInfo === undefined) {
- throw new Error(
- `Segment ${segmentIndex} not yet added to segmentation: ${segmentationId}`
- );
+ throw new Error(`Segment ${segmentIndex} not yet added to segmentation: ${segmentationId}`);
}
segmentInfo.label = segmentLabel;
@@ -1967,11 +1836,10 @@ class SegmentationService extends PubSubService {
}
private _getSegmentationRepresentation(segmentationId, toolGroupId) {
- const segmentationRepresentations = this.getSegmentationRepresentationsForToolGroup(
- toolGroupId
- );
+ const segmentationRepresentations =
+ this.getSegmentationRepresentationsForToolGroup(toolGroupId);
- if (segmentationRepresentations.length === 0) {
+ if (!segmentationRepresentations?.length) {
return;
}
@@ -2042,21 +1910,13 @@ class SegmentationService extends PubSubService {
return;
}
- const segmentationState = cstSegmentation.state.getSegmentation(
- segmentationId
- );
+ const segmentationState = cstSegmentation.state.getSegmentation(segmentationId);
if (!segmentationState) {
return;
}
- const {
- activeSegmentIndex,
- cachedStats,
- segmentsLocked,
- label,
- type,
- } = segmentationState;
+ const { activeSegmentIndex, cachedStats, segmentsLocked, label, type } = segmentationState;
if (![LABELMAP, CONTOUR].includes(type)) {
throw new Error(
@@ -2086,10 +1946,7 @@ class SegmentationService extends PubSubService {
try {
this.addOrUpdateSegmentation(segmentationSchema);
} catch (error) {
- console.warn(
- `Failed to add/update segmentation ${segmentationId}`,
- error
- );
+ console.warn(`Failed to add/update segmentation ${segmentationId}`, error);
}
};
@@ -2105,9 +1962,7 @@ class SegmentationService extends PubSubService {
);
if (!segmentationRepresentation) {
- throw new Error(
- 'Must add representation to toolgroup before setting segments'
- );
+ throw new Error('Must add representation to toolgroup before setting segments');
}
const { segmentationRepresentationUID } = segmentationRepresentation;
@@ -2125,14 +1980,11 @@ class SegmentationService extends PubSubService {
return;
}
- const toolGroupIds = segmentationState.getToolGroupIdsWithSegmentation(
- segmentationId
- );
+ const toolGroupIds = segmentationState.getToolGroupIdsWithSegmentation(segmentationId);
toolGroupIds.forEach(toolGroupId => {
- const segmentationRepresentations = segmentationState.getSegmentationRepresentations(
- toolGroupId
- );
+ const segmentationRepresentations =
+ segmentationState.getSegmentationRepresentations(toolGroupId);
const UIDsToRemove = [];
segmentationRepresentations.forEach(representation => {
@@ -2157,17 +2009,12 @@ class SegmentationService extends PubSubService {
}
}
- private _updateCornerstoneSegmentations({
- segmentationId,
- notYetUpdatedAtSource,
- }) {
+ private _updateCornerstoneSegmentations({ segmentationId, notYetUpdatedAtSource }) {
if (notYetUpdatedAtSource === false) {
return;
}
const segmentationState = cstSegmentation.state;
- const sourceSegmentation = segmentationState.getSegmentation(
- segmentationId
- );
+ const sourceSegmentation = segmentationState.getSegmentation(segmentationId);
const segmentation = this.segmentations[segmentationId];
const { label, cachedStats } = segmentation;
@@ -2183,14 +2030,11 @@ class SegmentationService extends PubSubService {
private _updateCornerstoneSegmentationVisibility = segmentationId => {
const segmentationState = cstSegmentation.state;
- const toolGroupIds = segmentationState.getToolGroupIdsWithSegmentation(
- segmentationId
- );
+ const toolGroupIds = segmentationState.getToolGroupIdsWithSegmentation(segmentationId);
toolGroupIds.forEach(toolGroupId => {
- const segmentationRepresentations = cstSegmentation.state.getSegmentationRepresentations(
- toolGroupId
- );
+ const segmentationRepresentations =
+ cstSegmentation.state.getSegmentationRepresentations(toolGroupId);
if (segmentationRepresentations.length === 0) {
return;
@@ -2214,10 +2058,7 @@ class SegmentationService extends PubSubService {
);
// update segments visibility
- const { segmentation } = this._getSegmentationInfo(
- segmentationId,
- toolGroupId
- );
+ const { segmentation } = this._getSegmentationInfo(segmentationId, toolGroupId);
const segments = segmentation.segments.filter(Boolean);
@@ -2229,9 +2070,7 @@ class SegmentationService extends PubSubService {
private _getToolGroupIdsWithSegmentation(segmentationId: string) {
const segmentationState = cstSegmentation.state;
- const toolGroupIds = segmentationState.getToolGroupIdsWithSegmentation(
- segmentationId
- );
+ const toolGroupIds = segmentationState.getToolGroupIdsWithSegmentation(segmentationId);
return toolGroupIds;
}
diff --git a/extensions/cornerstone/src/services/SegmentationService/SegmentationServiceTypes.ts b/extensions/cornerstone/src/services/SegmentationService/SegmentationServiceTypes.ts
index e170197c36..d6d231fd0a 100644
--- a/extensions/cornerstone/src/services/SegmentationService/SegmentationServiceTypes.ts
+++ b/extensions/cornerstone/src/services/SegmentationService/SegmentationServiceTypes.ts
@@ -39,6 +39,8 @@ type Segmentation = {
isActive: boolean;
// if the segmentation is visible in the viewer
isVisible: boolean;
+ // the frame of reference UID of the segmentation
+ FrameOfReferenceUID: string;
// the label of the segmentation
label: string;
// the number of segments in the segmentation
diff --git a/extensions/cornerstone/src/services/SyncGroupService/SyncGroupService.ts b/extensions/cornerstone/src/services/SyncGroupService/SyncGroupService.ts
index 39e919fc5d..0b1c22fb2b 100644
--- a/extensions/cornerstone/src/services/SyncGroupService/SyncGroupService.ts
+++ b/extensions/cornerstone/src/services/SyncGroupService/SyncGroupService.ts
@@ -1,8 +1,4 @@
-import {
- synchronizers,
- SynchronizerManager,
- Synchronizer,
-} from '@cornerstonejs/tools';
+import { synchronizers, SynchronizerManager, Synchronizer } from '@cornerstonejs/tools';
import { pubSubServiceInterface, Types, ServicesManager } from '@ohif/core';
@@ -14,10 +10,7 @@ const EVENTS = {
* @params options - are an optional set of options associated with the first
* sync group declared.
*/
-export type SyncCreator = (
- type: string,
- options?: Record
-) => Synchronizer;
+export type SyncCreator = (id: string, options?: Record) => Synchronizer;
export type SyncGroup = {
type: string;
@@ -40,9 +33,7 @@ export default class SyncGroupService {
static REGISTRATION = {
name: 'syncGroupService',
altName: 'SyncGroupService',
- create: ({
- servicesManager,
- }: Types.Extensions.ExtensionParams): SyncGroupService => {
+ create: ({ servicesManager }: Types.Extensions.ExtensionParams): SyncGroupService => {
return new SyncGroupService(servicesManager);
},
};
@@ -65,11 +56,7 @@ export default class SyncGroupService {
Object.assign(this, pubSubServiceInterface);
}
- private _createSynchronizer(
- type: string,
- id: string,
- options
- ): Synchronizer | undefined {
+ private _createSynchronizer(type: string, id: string, options): Synchronizer | undefined {
const syncCreator = this.synchronizerCreators[type.toLowerCase()];
if (syncCreator) {
return syncCreator(id, options);
@@ -83,7 +70,7 @@ export default class SyncGroupService {
* @param type is the type of the synchronizer to create
* @param creator
*/
- public setSynchronizer(type: string, creator: SyncCreator): void {
+ public addSynchronizerType(type: string, creator: SyncCreator): void {
this.synchronizerCreators[type.toLowerCase()] = creator;
}
@@ -109,19 +96,11 @@ export default class SyncGroupService {
return;
}
- const syncGroupsArray = Array.isArray(syncGroups)
- ? syncGroups
- : [syncGroups];
+ const syncGroupsArray = Array.isArray(syncGroups) ? syncGroups : [syncGroups];
syncGroupsArray.forEach(syncGroup => {
const syncGroupObj = asSyncGroup(syncGroup);
- const {
- type,
- target = true,
- source = true,
- options = {},
- id = type,
- } = syncGroupObj;
+ const { type, target = true, source = true, options = {}, id = type } = syncGroupObj;
const synchronizer = this._getOrCreateSynchronizer(type, id, options);
synchronizer.setOptions(viewportId, options);
diff --git a/extensions/cornerstone/src/services/ToolGroupService/ToolGroupService.ts b/extensions/cornerstone/src/services/ToolGroupService/ToolGroupService.ts
index b8f6c97098..3a85342b38 100644
--- a/extensions/cornerstone/src/services/ToolGroupService/ToolGroupService.ts
+++ b/extensions/cornerstone/src/services/ToolGroupService/ToolGroupService.ts
@@ -24,9 +24,7 @@ export default class ToolGroupService {
public static REGISTRATION = {
name: 'toolGroupService',
altName: 'ToolGroupService',
- create: ({
- servicesManager,
- }: OhifTypes.Extensions.ExtensionParams): ToolGroupService => {
+ create: ({ servicesManager }: OhifTypes.Extensions.ExtensionParams): ToolGroupService => {
return new ToolGroupService(servicesManager);
},
};
@@ -40,10 +38,7 @@ export default class ToolGroupService {
EVENTS: { [key: string]: string };
constructor(serviceManager) {
- const {
- cornerstoneViewportService,
- viewportGridService,
- } = serviceManager.services;
+ const { cornerstoneViewportService, viewportGridService } = serviceManager.services;
this.cornerstoneViewportService = cornerstoneViewportService;
this.viewportGridService = viewportGridService;
this.listeners = {};
@@ -66,19 +61,14 @@ export default class ToolGroupService {
if (!toolGroupIdToUse) {
// Use the active viewport's tool group if no tool group id is provided
- const enabledElement = getActiveViewportEnabledElement(
- this.viewportGridService
- );
+ const enabledElement = getActiveViewportEnabledElement(this.viewportGridService);
if (!enabledElement) {
return;
}
const { renderingEngineId, viewportId } = enabledElement;
- const toolGroup = ToolGroupManager.getToolGroupForViewport(
- viewportId,
- renderingEngineId
- );
+ const toolGroup = ToolGroupManager.getToolGroupForViewport(viewportId, renderingEngineId);
if (!toolGroup) {
console.warn(
@@ -103,16 +93,13 @@ export default class ToolGroupService {
public getToolGroupForViewport(viewportId: string): Types.IToolGroup | void {
const renderingEngine = this.cornerstoneViewportService.getRenderingEngine();
- return ToolGroupManager.getToolGroupForViewport(
- viewportId,
- renderingEngine.id
- );
+ return ToolGroupManager.getToolGroupForViewport(viewportId, renderingEngine.id);
}
public getActiveToolForViewport(viewportId: string): string {
- const toolGroup = ToolGroupManager.getToolGroupForViewport(viewportId);
+ const toolGroup = this.getToolGroupForViewport(viewportId);
if (!toolGroup) {
- return null;
+ return;
}
return toolGroup.getActivePrimaryMouseButtonTool();
@@ -133,10 +120,7 @@ export default class ToolGroupService {
renderingEngineId: string,
deleteToolGroupIfEmpty?: boolean
): void {
- const toolGroup = ToolGroupManager.getToolGroupForViewport(
- viewportId,
- renderingEngineId
- );
+ const toolGroup = ToolGroupManager.getToolGroupForViewport(viewportId, renderingEngineId);
if (!toolGroup) {
return;
@@ -193,24 +177,16 @@ export default class ToolGroupService {
return toolGroup;
}
- public addToolsToToolGroup(
- toolGroupId: string,
- tools: Array,
- configs: any = {}
- ): void {
+ public addToolsToToolGroup(toolGroupId: string, tools: Array, configs: any = {}): void {
const toolGroup = ToolGroupManager.getToolGroup(toolGroupId);
// this.changeConfigurationIfNecessary(toolGroup, volumeId);
this._addTools(toolGroup, tools, configs);
this._setToolsMode(toolGroup, tools);
}
- public createToolGroupAndAddTools(
- toolGroupId: string,
- tools: Array,
- configs: any = {}
- ): Types.IToolGroup {
+ public createToolGroupAndAddTools(toolGroupId: string, tools: Array): Types.IToolGroup {
const toolGroup = this.createToolGroup(toolGroupId);
- this.addToolsToToolGroup(toolGroupId, tools, configs);
+ this.addToolsToToolGroup(toolGroupId, tools);
return toolGroup;
}
@@ -259,34 +235,6 @@ export default class ToolGroupService {
toolInstance.configuration = config;
}
- private _getToolNames(toolGroupTools: Tools): string[] {
- const toolNames = [];
- if (toolGroupTools.active) {
- toolGroupTools.active.forEach(tool => {
- toolNames.push(tool.toolName);
- });
- }
- if (toolGroupTools.passive) {
- toolGroupTools.passive.forEach(tool => {
- toolNames.push(tool.toolName);
- });
- }
-
- if (toolGroupTools.enabled) {
- toolGroupTools.enabled.forEach(tool => {
- toolNames.push(tool.toolName);
- });
- }
-
- if (toolGroupTools.disabled) {
- toolGroupTools.disabled.forEach(tool => {
- toolNames.push(tool.toolName);
- });
- }
-
- return toolNames;
- }
-
private _setToolsMode(toolGroup, tools) {
const { active, passive, enabled, disabled } = tools;
@@ -315,17 +263,33 @@ export default class ToolGroupService {
}
}
- private _addTools(toolGroup, tools, configs) {
- const toolNames = this._getToolNames(tools);
- toolNames.forEach(toolName => {
- // Initialize the toolConfig if no configuration is provided
- const toolConfig = configs[toolName] ?? {};
+ private _addTools(toolGroup, tools) {
+ const addTools = tools => {
+ tools.forEach(({ toolName, parentTool, configuration }) => {
+ if (parentTool) {
+ toolGroup.addToolInstance(toolName, parentTool, {
+ ...configuration,
+ });
+ } else {
+ toolGroup.addTool(toolName, { ...configuration });
+ }
+ });
+ };
- // if (volumeUID) {
- // toolConfig.volumeUID = volumeUID;
- // }
+ if (tools.active) {
+ addTools(tools.active);
+ }
- toolGroup.addTool(toolName, { ...toolConfig });
- });
+ if (tools.passive) {
+ addTools(tools.passive);
+ }
+
+ if (tools.enabled) {
+ addTools(tools.enabled);
+ }
+
+ if (tools.disabled) {
+ addTools(tools.disabled);
+ }
}
}
diff --git a/extensions/cornerstone/src/services/ViewportService/CornerstoneViewportService.ts b/extensions/cornerstone/src/services/ViewportService/CornerstoneViewportService.ts
index d20ef2f76b..f6d0978972 100644
--- a/extensions/cornerstone/src/services/ViewportService/CornerstoneViewportService.ts
+++ b/extensions/cornerstone/src/services/ViewportService/CornerstoneViewportService.ts
@@ -9,41 +9,27 @@ import {
VolumeViewport,
VolumeViewport3D,
cache,
- utilities,
- CONSTANTS,
Enums as csEnums,
} from '@cornerstonejs/core';
-import {
- utilities as csToolsUtils,
- Enums as csToolsEnums,
-} from '@cornerstonejs/tools';
+import { utilities as csToolsUtils, Enums as csToolsEnums } from '@cornerstonejs/tools';
import { IViewportService } from './IViewportService';
import { RENDERING_ENGINE_ID } from './constants';
-import ViewportInfo, {
- ViewportOptions,
- DisplaySetOptions,
- PublicViewportOptions,
-} from './Viewport';
-import {
- StackViewportData,
- VolumeViewportData,
-} from '../../types/CornerstoneCacheService';
+import ViewportInfo, { DisplaySetOptions, PublicViewportOptions } from './Viewport';
+import { StackViewportData, VolumeViewportData } from '../../types/CornerstoneCacheService';
import { Presentation, Presentations } from '../../types/Presentation';
import JumpPresets from '../../utils/JumpPresets';
const EVENTS = {
- VIEWPORT_DATA_CHANGED:
- 'event::cornerstoneViewportService:viewportDataChanged',
+ VIEWPORT_DATA_CHANGED: 'event::cornerstoneViewportService:viewportDataChanged',
};
/**
* Handles cornerstone viewport logic including enabling, disabling, and
* updating the viewport.
*/
-class CornerstoneViewportService extends PubSubService
- implements IViewportService {
+class CornerstoneViewportService extends PubSubService implements IViewportService {
static REGISTRATION = {
name: 'cornerstoneViewportService',
altName: 'CornerstoneViewportService',
@@ -55,7 +41,6 @@ class CornerstoneViewportService extends PubSubService
};
renderingEngine: Types.IRenderingEngine | null;
- viewportsInfo: Map = new Map();
viewportsById: Map = new Map();
viewportGridResizeObserver: ResizeObserver | null;
viewportsDisplaySets: Map = new Map();
@@ -75,45 +60,17 @@ class CornerstoneViewportService extends PubSubService
/**
* Adds the HTML element to the viewportService
- * @param {*} viewportIndex
+ * @param {*} viewportId
* @param {*} elementRef
*/
- public enableViewport(
- viewportIndex: number,
- viewportOptions: PublicViewportOptions,
- elementRef: HTMLDivElement
- ): void {
- // Use the provided viewportId
- // Not providing a viewportId is frowned upon because it does weird things
- // on moving them around, but it does mostly work.
- if (!viewportOptions.viewportId) {
- console.warn('Should provide viewport id externally', viewportOptions);
- viewportOptions.viewportId =
- this.getViewportId(viewportIndex) || `viewport-${viewportIndex}`;
- }
- const { viewportId } = viewportOptions;
- const viewportInfo = new ViewportInfo(viewportIndex, viewportId);
- if (!viewportInfo.viewportId) {
- throw new Error('Should have viewport ID afterwards');
- }
-
+ public enableViewport(viewportId: string, elementRef: HTMLDivElement): void {
+ const viewportInfo = new ViewportInfo(viewportId);
viewportInfo.setElement(elementRef);
- this.viewportsInfo.set(viewportIndex, viewportInfo);
this.viewportsById.set(viewportId, viewportInfo);
}
public getViewportIds(): string[] {
- const viewportIds = [];
-
- this.viewportsInfo.forEach(viewportInfo => {
- viewportIds.push(viewportInfo.getViewportId());
- });
-
- return viewportIds;
- }
-
- public getViewportId(viewportIndex: number): string {
- return this.viewportsInfo[viewportIndex]?.viewportId;
+ return Array.from(this.viewportsById.keys());
}
/**
@@ -171,37 +128,38 @@ class CornerstoneViewportService extends PubSubService
* created for every new viewport, this will be called whenever the set of
* viewports is changed, but NOT when the viewport position changes only.
*
- * @param viewportIndex
+ * @param viewportId - The viewportId to disable
*/
- public disableElement(viewportIndex: number): void {
- const viewportInfo = this.viewportsInfo.get(viewportIndex);
- if (!viewportInfo) {
- return;
- }
-
- const viewportId = viewportInfo.getViewportId();
-
- this.renderingEngine && this.renderingEngine.disableElement(viewportId);
+ public disableElement(viewportId: string): void {
+ this.renderingEngine?.disableElement(viewportId);
- this.viewportsInfo.get(viewportIndex).destroy();
- this.viewportsInfo.delete(viewportIndex);
+ // clean up
this.viewportsById.delete(viewportId);
+ this.viewportsDisplaySets.delete(viewportId);
}
public setPresentations(viewport, presentations?: Presentations): void {
const properties = presentations?.lutPresentation?.properties;
- if (properties) viewport.setProperties(properties);
+ if (properties) {
+ viewport.setProperties(properties);
+ }
const camera = presentations?.positionPresentation?.camera;
- if (camera) viewport.setCamera(camera);
+ if (camera) {
+ viewport.setCamera(camera);
+ }
}
- public getPresentation(viewportIndex: number): Presentation {
- const viewportInfo = this.viewportsInfo.get(viewportIndex);
- if (!viewportInfo) return;
+ public getPresentation(viewportId: string): Presentation {
+ const viewportInfo = this.viewportsById.get(viewportId);
+ if (!viewportInfo) {
+ return;
+ }
const { viewportType, presentationIds } = viewportInfo.getViewportOptions();
- const csViewport = this.getCornerstoneViewportByIndex(viewportIndex);
- if (!csViewport) return;
+ const csViewport = this.getCornerstoneViewport(viewportId);
+ if (!csViewport) {
+ return;
+ }
const properties = csViewport.getProperties();
if (properties.isComputedVOI) {
@@ -212,63 +170,80 @@ class CornerstoneViewportService extends PubSubService
const camera = csViewport.getCamera();
return {
presentationIds,
- viewportType:
- !viewportType || viewportType === 'stack' ? 'stack' : 'volume',
+ viewportType: !viewportType || viewportType === 'stack' ? 'stack' : 'volume',
properties,
initialImageIndex,
camera,
};
}
+ public storePresentation({ viewportId }) {
+ const stateSyncService = this.servicesManager.services.stateSyncService;
+ let presentation;
+ try {
+ presentation = this.getPresentation(viewportId);
+ } catch (error) {
+ console.warn(error);
+ }
+
+ if (!presentation || !presentation.presentationIds) {
+ return;
+ }
+ const { lutPresentationStore, positionPresentationStore } = stateSyncService.getState();
+ const { presentationIds } = presentation;
+ const { lutPresentationId, positionPresentationId } = presentationIds || {};
+ const storeState = {};
+ if (lutPresentationId) {
+ storeState.lutPresentationStore = {
+ ...lutPresentationStore,
+ [lutPresentationId]: presentation,
+ };
+ }
+ if (positionPresentationId) {
+ storeState.positionPresentationStore = {
+ ...positionPresentationStore,
+ [positionPresentationId]: presentation,
+ };
+ }
+ stateSyncService.store(storeState);
+ }
+
/**
- * Uses the renderingEngine to enable the element for the given viewport index
- * and sets the displaySet data to the viewport
- * @param {*} viewportIndex
- * @param {*} displaySet
- * @param {*} dataSource
- * @returns
+ * Sets the viewport data for a viewport.
+ * @param viewportId - The ID of the viewport to set the data for.
+ * @param viewportData - The viewport data to set.
+ * @param publicViewportOptions - The public viewport options.
+ * @param publicDisplaySetOptions - The public display set options.
+ * @param presentations - The presentations to set.
*/
public setViewportData(
- viewportIndex: number,
+ viewportId: string,
viewportData: StackViewportData | VolumeViewportData,
publicViewportOptions: PublicViewportOptions,
publicDisplaySetOptions: DisplaySetOptions[],
presentations?: Presentations
): void {
const renderingEngine = this.getRenderingEngine();
- const viewportId =
- publicViewportOptions.viewportId || this.getViewportId(viewportIndex);
- if (!viewportId) {
- throw new Error('Must define viewportId externally');
- }
+ // This is the old viewportInfo, which may have old options but we might be
+ // using its viewport (same viewportId as the new viewportInfo)
const viewportInfo = this.viewportsById.get(viewportId);
- if (!viewportInfo) {
- throw new Error('Viewport info not defined');
- }
+ // We should store the presentation for the current viewport since we can't only
+ // rely to store it WHEN the viewport is disabled since we might keep around the
+ // same viewport/element and just change the viewportData for it (drag and drop etc.)
+ // the disableElement storePresentation handle would not be called in this case
+ // and we would lose the presentation.
+ this.storePresentation({ viewportId: viewportInfo.getViewportId() });
- // If the viewport has moved index, then record the new index
- if (viewportInfo.viewportIndex !== viewportIndex) {
- this.viewportsInfo.delete(viewportInfo.viewportIndex);
- this.viewportsInfo.set(viewportIndex, viewportInfo);
- viewportInfo.viewportIndex = viewportIndex;
+ if (!viewportInfo) {
+ throw new Error('element is not enabled for the given viewportId');
}
- viewportInfo.setRenderingEngineId(renderingEngine.id);
-
- const {
- viewportOptions,
- displaySetOptions,
- } = this._getViewportAndDisplaySetOptions(
- publicViewportOptions,
- publicDisplaySetOptions,
- viewportInfo
- );
-
- viewportInfo.setViewportOptions(viewportOptions);
- viewportInfo.setDisplaySetOptions(displaySetOptions);
- viewportInfo.setViewportData(viewportData);
+ // override the viewportOptions and displaySetOptions with the public ones
+ // since those are the newly set ones, we set them here so that it handles defaults
+ const displaySetOptions = viewportInfo.setPublicDisplaySetOptions(publicDisplaySetOptions);
+ const viewportOptions = viewportInfo.setPublicViewportOptions(publicViewportOptions);
const element = viewportInfo.getElement();
const type = viewportInfo.getViewportType();
@@ -285,12 +260,26 @@ class CornerstoneViewportService extends PubSubService
},
};
+ // Rendering Engine Id set should happen before enabling the element
+ // since there are callbacks that depend on the renderingEngine id
+ // Todo: however, this is a limitation which means that we can't change
+ // the rendering engine id for a given viewport which might be a super edge
+ // case
+ viewportInfo.setRenderingEngineId(renderingEngine.id);
+
// Todo: this is not optimal at all, we are re-enabling the already enabled
// element which is not what we want. But enabledElement as part of the
// renderingEngine is designed to be used like this. This will trigger
// ENABLED_ELEMENT again and again, which will run onEnableElement callbacks
renderingEngine.enableElement(viewportInput);
+ viewportInfo.setViewportOptions(viewportOptions);
+ viewportInfo.setDisplaySetOptions(displaySetOptions);
+ viewportInfo.setViewportData(viewportData);
+ viewportInfo.setViewportId(viewportId);
+
+ this.viewportsById.set(viewportId, viewportInfo);
+
const viewport = renderingEngine.getViewport(viewportId);
this._setDisplaySets(viewport, viewportData, viewportInfo, presentations);
@@ -299,7 +288,6 @@ class CornerstoneViewportService extends PubSubService
// invalid data.
this._broadcastEvent(this.EVENTS.VIEWPORT_DATA_CHANGED, {
viewportData,
- viewportIndex,
viewportId,
});
}
@@ -309,11 +297,7 @@ class CornerstoneViewportService extends PubSubService
): Types.IStackViewport | Types.IVolumeViewport | null {
const viewportInfo = this.getViewportInfo(viewportId);
- if (
- !viewportInfo ||
- !this.renderingEngine ||
- this.renderingEngine.hasBeenDestroyed
- ) {
+ if (!viewportInfo || !this.renderingEngine || this.renderingEngine.hasBeenDestroyed) {
return null;
}
@@ -322,43 +306,8 @@ class CornerstoneViewportService extends PubSubService
return viewport;
}
- public getCornerstoneViewportByIndex(
- viewportIndex: number
- ): Types.IStackViewport | Types.IVolumeViewport | null {
- const viewportInfo = this.getViewportInfoByIndex(viewportIndex);
-
- if (
- !viewportInfo ||
- !this.renderingEngine ||
- this.renderingEngine.hasBeenDestroyed
- ) {
- return null;
- }
-
- const viewport = this.renderingEngine.getViewport(
- viewportInfo.getViewportId()
- );
-
- return viewport;
- }
-
- /**
- * Returns the viewportIndex for the provided viewportId
- * @param {string} viewportId - the viewportId
- * @returns {number} - the viewportIndex
- */
- public getViewportInfoByIndex(viewportIndex: number): ViewportInfo {
- return this.viewportsInfo.get(viewportIndex);
- }
-
public getViewportInfo(viewportId: string): ViewportInfo {
- // @ts-ignore
- for (const [index, viewport] of this.viewportsInfo.entries()) {
- if (viewport.getViewportId() === viewportId) {
- return viewport;
- }
- }
- return null;
+ return this.viewportsById.get(viewportId);
}
_setStackViewport(
@@ -369,24 +318,15 @@ class CornerstoneViewportService extends PubSubService
): void {
const displaySetOptions = viewportInfo.getDisplaySetOptions();
- const {
- imageIds,
- initialImageIndex,
- displaySetInstanceUID,
- } = viewportData.data;
+ const { imageIds, initialImageIndex, displaySetInstanceUID } = viewportData.data;
this.viewportsDisplaySets.set(viewport.id, [displaySetInstanceUID]);
let initialImageIndexToUse =
- presentations?.positionPresentation?.initialImageIndex ??
- initialImageIndex;
+ presentations?.positionPresentation?.initialImageIndex ?? initialImageIndex;
- if (
- initialImageIndexToUse === undefined ||
- initialImageIndexToUse === null
- ) {
- initialImageIndexToUse =
- this._getInitialImageIndexForViewport(viewportInfo, imageIds) || 0;
+ if (initialImageIndexToUse === undefined || initialImageIndexToUse === null) {
+ initialImageIndexToUse = this._getInitialImageIndexForViewport(viewportInfo, imageIds) || 0;
}
const properties = { ...presentations.lutPresentation?.properties };
@@ -406,9 +346,11 @@ class CornerstoneViewportService extends PubSubService
}
viewport.setStack(imageIds, initialImageIndexToUse).then(() => {
- viewport.setProperties(properties);
+ viewport.setProperties({ ...properties });
const camera = presentations.positionPresentation?.camera;
- if (camera) viewport.setCamera(camera);
+ if (camera) {
+ viewport.setCamera(camera);
+ }
});
}
@@ -429,12 +371,8 @@ class CornerstoneViewportService extends PubSubService
if (viewportType === csEnums.ViewportType.STACK) {
numberOfSlices = imageIds.length;
} else if (viewportType === csEnums.ViewportType.ORTHOGRAPHIC) {
- const viewport = this.getCornerstoneViewport(
- viewportInfo.getViewportId()
- );
- const imageSliceData = csUtils.getImageSliceDataForVolumeViewport(
- viewport
- );
+ const viewport = this.getCornerstoneViewport(viewportInfo.getViewportId());
+ const imageSliceData = csUtils.getImageSliceDataForVolumeViewport(viewport);
if (!imageSliceData) {
return;
@@ -448,11 +386,7 @@ class CornerstoneViewportService extends PubSubService
return this._getInitialImageIndex(numberOfSlices, index, preset);
}
- _getInitialImageIndex(
- numberOfSlices: number,
- imageIndex?: number,
- preset?: JumpPresets
- ): number {
+ _getInitialImageIndex(numberOfSlices: number, imageIndex?: number, preset?: JumpPresets): number {
const lastSliceIndex = numberOfSlices - 1;
if (imageIndex !== undefined) {
@@ -474,9 +408,7 @@ class CornerstoneViewportService extends PubSubService
// it will jump to a different slice than the middle one which
// was the initial slice, and we have some tools such as Crosshairs
// which rely on a relative camera modifications and those will break.
- return lastSliceIndex % 2 === 0
- ? lastSliceIndex / 2
- : (lastSliceIndex + 1) / 2;
+ return lastSliceIndex % 2 === 0 ? lastSliceIndex / 2 : (lastSliceIndex + 1) / 2;
}
return 0;
@@ -531,10 +463,7 @@ class CornerstoneViewportService extends PubSubService
this.viewportsDisplaySets.set(viewport.id, displaySetInstanceUIDs);
- if (
- hangingProtocolService.hasCustomImageLoadStrategy() &&
- !hangingProtocolService.customImageLoadPerformed
- ) {
+ if (hangingProtocolService.getShouldPerformCustomImageLoad()) {
// delegate the volume loading to the hanging protocol service if it has a custom image load strategy
return hangingProtocolService.runImageLoadStrategy({
viewportId: viewport.id,
@@ -549,22 +478,11 @@ class CornerstoneViewportService extends PubSubService
});
// This returns the async continuation only
- return this.setVolumesForViewport(
- viewport,
- volumeInputArray,
- presentations
- );
+ return this.setVolumesForViewport(viewport, volumeInputArray, presentations);
}
- public async setVolumesForViewport(
- viewport,
- volumeInputArray,
- presentations
- ) {
- const {
- displaySetService,
- toolGroupService,
- } = this.servicesManager.services;
+ public async setVolumesForViewport(viewport, volumeInputArray, presentations) {
+ const { displaySetService, toolGroupService } = this.servicesManager.services;
const viewportInfo = this.getViewportInfo(viewport.id);
const displaySetOptions = viewportInfo.getDisplaySetOptions();
@@ -622,10 +540,7 @@ class CornerstoneViewportService extends PubSubService
// associated with the primary displaySet
// get segmentations only returns the hydrated segmentations
- this._addSegmentationRepresentationToToolGroupIfNecessary(
- displaySetInstanceUIDs,
- viewport
- );
+ this._addSegmentationRepresentationToToolGroupIfNecessary(displaySetInstanceUIDs, viewport);
}
const toolGroup = toolGroupService.getToolGroupForViewport(viewport.id);
@@ -646,10 +561,7 @@ class CornerstoneViewportService extends PubSubService
displaySetInstanceUIDs: string[],
viewport: any
) {
- const {
- segmentationService,
- toolGroupService,
- } = this.servicesManager.services;
+ const { segmentationService, toolGroupService } = this.servicesManager.services;
const toolGroup = toolGroupService.getToolGroupForViewport(viewport.id);
@@ -658,9 +570,7 @@ class CornerstoneViewportService extends PubSubService
for (const segmentation of segmentations) {
const toolGroupSegmentationRepresentations =
- segmentationService.getSegmentationRepresentationsForToolGroup(
- toolGroup.id
- ) || [];
+ segmentationService.getSegmentationRepresentationsForToolGroup(toolGroup.id) || [];
// if there is already a segmentation representation for this segmentation
// for this toolGroup, don't bother at all
@@ -672,19 +582,28 @@ class CornerstoneViewportService extends PubSubService
continue;
}
- // otherwise, check if the hydrated segmentations are in the same FOR
+ // otherwise, check if the hydrated segmentations are in the same FrameOfReferenceUID
// as the primary displaySet, if so add the representation (since it was not there)
- const { id: segDisplaySetInstanceUID, type } = segmentation;
- const segFrameOfReferenceUID = this._getFrameOfReferenceUID(
- segDisplaySetInstanceUID
- );
+ const { id: segDisplaySetInstanceUID } = segmentation;
+ let segFrameOfReferenceUID = this._getFrameOfReferenceUID(segDisplaySetInstanceUID);
+
+ if (!segFrameOfReferenceUID) {
+ // if the segmentation displaySet does not have a FrameOfReferenceUID, we might check the
+ // segmentation itself maybe it has a FrameOfReferenceUID
+ const { FrameOfReferenceUID } = segmentation;
+ if (FrameOfReferenceUID) {
+ segFrameOfReferenceUID = FrameOfReferenceUID;
+ }
+ }
+
+ if (!segFrameOfReferenceUID) {
+ return;
+ }
let shouldDisplaySeg = false;
for (const displaySetInstanceUID of displaySetInstanceUIDs) {
- const primaryFrameOfReferenceUID = this._getFrameOfReferenceUID(
- displaySetInstanceUID
- );
+ const primaryFrameOfReferenceUID = this._getFrameOfReferenceUID(displaySetInstanceUID);
if (segFrameOfReferenceUID === primaryFrameOfReferenceUID) {
shouldDisplaySeg = true;
@@ -705,14 +624,8 @@ class CornerstoneViewportService extends PubSubService
}
}
- private addOverlayRepresentationForDisplaySet(
- displaySet: any,
- viewport: any
- ) {
- const {
- segmentationService,
- toolGroupService,
- } = this.servicesManager.services;
+ private addOverlayRepresentationForDisplaySet(displaySet: any, viewport: any) {
+ const { segmentationService, toolGroupService } = this.servicesManager.services;
const { referencedVolumeId } = displaySet;
const segmentationId = displaySet.displaySetInstanceUID;
@@ -734,18 +647,12 @@ class CornerstoneViewportService extends PubSubService
// Todo: keepCamera is an interim solution until we have a better solution for
// keeping the camera position when the viewport data is changed
- public updateViewport(
- viewportIndex: number,
- viewportData,
- keepCamera = false
- ) {
- const viewportInfo = this.getViewportInfoByIndex(viewportIndex);
-
- const viewportId = viewportInfo.getViewportId();
+ public updateViewport(viewportId: string, viewportData, keepCamera = false) {
+ const viewportInfo = this.getViewportInfo(viewportId);
const viewport = this.getCornerstoneViewport(viewportId);
const viewportCamera = viewport.getCamera();
- if (viewport instanceof VolumeViewport) {
+ if (viewport instanceof VolumeViewport || viewport instanceof VolumeViewport3D) {
this._setVolumeViewport(viewport, viewportData, viewportInfo).then(() => {
if (keepCamera) {
viewport.setCamera(viewportCamera);
@@ -775,10 +682,7 @@ class CornerstoneViewportService extends PubSubService
viewportInfo,
presentations
);
- } else if (
- viewport instanceof VolumeViewport ||
- viewport instanceof VolumeViewport3D
- ) {
+ } else if (viewport instanceof VolumeViewport || viewport instanceof VolumeViewport3D) {
this._setVolumeViewport(
viewport,
viewportData as VolumeViewportData,
@@ -801,10 +705,7 @@ class CornerstoneViewportService extends PubSubService
_getSlabThickness(displaySetOptions, volumeId) {
const { blendMode } = displaySetOptions;
- if (
- blendMode === undefined ||
- displaySetOptions.slabThickness === undefined
- ) {
+ if (blendMode === undefined || displaySetOptions.slabThickness === undefined) {
return;
}
@@ -828,41 +729,9 @@ class CornerstoneViewportService extends PubSubService
}
}
- _getViewportAndDisplaySetOptions(
- publicViewportOptions: PublicViewportOptions,
- publicDisplaySetOptions: DisplaySetOptions[],
- viewportInfo: ViewportInfo
- ): {
- viewportOptions: ViewportOptions;
- displaySetOptions: DisplaySetOptions[];
- } {
- const viewportIndex = viewportInfo.getViewportIndex();
-
- // Creating a temporary viewportInfo to handle defaults
- const newViewportInfo = new ViewportInfo(
- viewportIndex,
- viewportInfo.getViewportId()
- );
-
- // To handle setting the default values if missing for the viewportOptions and
- // displaySetOptions
- newViewportInfo.setPublicViewportOptions(publicViewportOptions);
- newViewportInfo.setPublicDisplaySetOptions(publicDisplaySetOptions);
-
- const newViewportOptions = newViewportInfo.getViewportOptions();
- const newDisplaySetOptions = newViewportInfo.getDisplaySetOptions();
-
- return {
- viewportOptions: newViewportOptions,
- displaySetOptions: newDisplaySetOptions,
- };
- }
-
_getFrameOfReferenceUID(displaySetInstanceUID) {
const { displaySetService } = this.servicesManager.services;
- const displaySet = displaySetService.getDisplaySetByUID(
- displaySetInstanceUID
- );
+ const displaySet = displaySetService.getDisplaySetByUID(displaySetInstanceUID);
if (!displaySet) {
return;
@@ -894,25 +763,25 @@ class CornerstoneViewportService extends PubSubService
*
* @param measurement
* The measurement that is desired to view.
- * @param activeViewportIndex - the index that was active at the time the jump
+ * @param activeViewportId - the index that was active at the time the jump
* was initiated.
- * @return the viewportIndex to display the given measurement
+ * @return the viewportId that the measurement should be displayed in.
*/
- public getViewportIndexToJump(
- activeViewportIndex: number,
+ public getViewportIdToJump(
+ activeViewportId: string,
displaySetInstanceUID: string,
cameraProps: unknown
- ): number {
- const viewportInfo = this.viewportsInfo.get(activeViewportIndex);
+ ): string {
+ const viewportInfo = this.getViewportInfo(activeViewportId);
const { referencedImageId } = cameraProps;
if (viewportInfo?.contains(displaySetInstanceUID, referencedImageId)) {
- return activeViewportIndex;
+ return activeViewportId;
}
return (
[...this.viewportsById.values()].find(viewportInfo =>
viewportInfo.contains(displaySetInstanceUID, referencedImageId)
- )?.viewportIndex ?? -1
+ )?.viewportId ?? null
);
}
}
diff --git a/extensions/cornerstone/src/services/ViewportService/IViewportService.ts b/extensions/cornerstone/src/services/ViewportService/IViewportService.ts
index 87168cb7f6..e96a7d7029 100644
--- a/extensions/cornerstone/src/services/ViewportService/IViewportService.ts
+++ b/extensions/cornerstone/src/services/ViewportService/IViewportService.ts
@@ -1,10 +1,6 @@
import { Types } from '@cornerstonejs/core';
import { StackData, VolumeData } from '../../types/CornerstoneCacheService';
-import {
- DisplaySetOptions,
- PublicViewportOptions,
- ViewportOptions,
-} from './Viewport';
+import { DisplaySetOptions, PublicViewportOptions, ViewportOptions } from './Viewport';
/**
* Handles cornerstone viewport logic including enabling, disabling, and
@@ -17,7 +13,6 @@ export interface IViewportService {
viewportGridResizeObserver: unknown;
viewportsInfo: unknown;
sceneVolumeInputs: unknown;
- viewportIndexUIDMap: unknown;
viewportDivElements: unknown;
ViewportPropertiesMap: unknown;
volumeUIDs: unknown;
@@ -28,14 +23,9 @@ export interface IViewportService {
_broadcastEvent: unknown;
/**
* Adds the HTML element to the viewportService
- * @param {*} viewportIndex
* @param {*} elementRef
*/
- enableViewport(
- viewportIndex: number,
- viewportOptions: ViewportOptions,
- elementRef: HTMLDivElement
- ): void;
+ enableViewport(viewportId: string, elementRef: HTMLDivElement): void;
/**
* It retrieves the renderingEngine if it does exist, or creates one otherwise
* @returns {RenderingEngine} rendering engine
@@ -54,19 +44,17 @@ export interface IViewportService {
/**
* Disables the viewport inside the renderingEngine, if no viewport is left
* it destroys the renderingEngine.
- * @param viewportIndex
+ * @param viewportId
*/
- disableElement(viewportIndex: number): void;
+ disableElement(viewportId: string): void;
/**
* Uses the renderingEngine to enable the element for the given viewport index
* and sets the displaySet data to the viewport
- * @param {*} viewportIndex
* @param {*} displaySet
* @param {*} dataSource
* @returns
*/
setViewportData(
- viewportIndex: number,
viewportData: StackData | VolumeData,
publicViewportOptions: PublicViewportOptions,
publicDisplaySetOptions: DisplaySetOptions[]
diff --git a/extensions/cornerstone/src/services/ViewportService/Viewport.ts b/extensions/cornerstone/src/services/ViewportService/Viewport.ts
index 1f5247bb1f..42fa56046e 100644
--- a/extensions/cornerstone/src/services/ViewportService/Viewport.ts
+++ b/extensions/cornerstone/src/services/ViewportService/Viewport.ts
@@ -1,9 +1,6 @@
import { Types, Enums } from '@cornerstonejs/core';
import { Types as UITypes } from '@ohif/ui';
-import {
- StackViewportData,
- VolumeViewportData,
-} from '../../types/CornerstoneCacheService';
+import { StackViewportData, VolumeViewportData } from '../../types/CornerstoneCacheService';
import getCornerstoneBlendMode from '../../utils/getCornerstoneBlendMode';
import getCornerstoneOrientation from '../../utils/getCornerstoneOrientation';
import getCornerstoneViewportType from '../../utils/getCornerstoneViewportType';
@@ -90,12 +87,10 @@ const DEFAULT_TOOLGROUP_ID = 'default';
// Return true if the data contains the given display set UID OR the imageId
// if it is a composite object.
-const dataContains = (
- data,
- displaySetUID: string,
- imageId?: string
-): boolean => {
- if (data.displaySetInstanceUID === displaySetUID) return true;
+const dataContains = (data, displaySetUID: string, imageId?: string): boolean => {
+ if (data.displaySetInstanceUID === displaySetUID) {
+ return true;
+ }
if (imageId && data.isCompositeStack && data.imageIds) {
return !!data.imageIds.find(dataId => dataId === imageId);
}
@@ -104,15 +99,13 @@ const dataContains = (
class ViewportInfo {
private viewportId = '';
- private viewportIndex: number;
private element: HTMLDivElement;
private viewportOptions: ViewportOptions;
private displaySetOptions: Array;
private viewportData: StackViewportData | VolumeViewportData;
private renderingEngineId: string;
- constructor(viewportIndex: number, viewportId: string) {
- this.viewportIndex = viewportIndex;
+ constructor(viewportId: string) {
this.viewportId = viewportId;
this.setPublicViewportOptions({});
this.setPublicDisplaySetOptions([{}]);
@@ -123,12 +116,12 @@ class ViewportInfo {
* OR if it is a composite stack and contains the given imageId
*/
public contains(displaySetUID: string, imageId: string): boolean {
- if (!this.viewportData?.data) return false;
+ if (!this.viewportData?.data) {
+ return false;
+ }
if (this.viewportData.data.length) {
- return !!this.viewportData.data.find(data =>
- dataContains(data, displaySetUID, imageId)
- );
+ return !!this.viewportData.data.find(data => dataContains(data, displaySetUID, imageId));
}
return dataContains(this.viewportData.data, displaySetUID, imageId);
}
@@ -151,17 +144,12 @@ class ViewportInfo {
public setViewportId(viewportId: string): void {
this.viewportId = viewportId;
}
- public setViewportIndex(viewportIndex: number): void {
- this.viewportIndex = viewportIndex;
- }
public setElement(element: HTMLDivElement): void {
this.element = element;
}
- public setViewportData(
- viewportData: StackViewportData | VolumeViewportData
- ): void {
+ public setViewportData(viewportData: StackViewportData | VolumeViewportData): void {
this.viewportData = viewportData;
}
@@ -169,10 +157,6 @@ class ViewportInfo {
return this.viewportData;
}
- public getViewportIndex(): number {
- return this.viewportIndex;
- }
-
public getElement(): HTMLDivElement {
return this.element;
}
@@ -183,13 +167,13 @@ class ViewportInfo {
public setPublicDisplaySetOptions(
publicDisplaySetOptions: PublicDisplaySetOptions[] | DisplaySetSelector[]
- ): void {
+ ): Array {
// map the displaySetOptions and check if they are undefined then set them to default values
- const displaySetOptions = this.mapDisplaySetOptions(
- publicDisplaySetOptions
- );
+ const displaySetOptions = this.mapDisplaySetOptions(publicDisplaySetOptions);
this.setDisplaySetOptions(displaySetOptions);
+
+ return this.displaySetOptions;
}
public hasDisplaySet(displaySetInstanceUID: string): boolean {
@@ -198,7 +182,10 @@ class ViewportInfo {
// via cornerstoneViewportService
let viewportData = this.getViewportData();
- if (viewportData.viewportType === Enums.ViewportType.ORTHOGRAPHIC) {
+ if (
+ viewportData.viewportType === Enums.ViewportType.ORTHOGRAPHIC ||
+ viewportData.viewportType === Enums.ViewportType.VOLUME_3D
+ ) {
viewportData = viewportData as VolumeViewportData;
return viewportData.data.some(
({ displaySetInstanceUID: dsUID }) => dsUID === displaySetInstanceUID
@@ -209,22 +196,15 @@ class ViewportInfo {
return viewportData.data.displaySetInstanceUID === displaySetInstanceUID;
}
- public setPublicViewportOptions(
- viewportOptionsEntry: PublicViewportOptions
- ): void {
+ public setPublicViewportOptions(viewportOptionsEntry: PublicViewportOptions): ViewportOptions {
let viewportType = viewportOptionsEntry.viewportType;
- const {
- toolGroupId = DEFAULT_TOOLGROUP_ID,
- presentationIds,
- } = viewportOptionsEntry;
+ const { toolGroupId = DEFAULT_TOOLGROUP_ID, presentationIds } = viewportOptionsEntry;
let orientation;
if (!viewportType) {
viewportType = getCornerstoneViewportType(STACK);
} else {
- viewportType = getCornerstoneViewportType(
- viewportOptionsEntry.viewportType
- );
+ viewportType = getCornerstoneViewportType(viewportOptionsEntry.viewportType);
}
// map SAGITTAL, AXIAL, CORONAL orientation to be used by cornerstone
@@ -244,6 +224,8 @@ class ViewportInfo {
toolGroupId,
presentationIds,
});
+
+ return this.viewportOptions;
}
public setViewportOptions(viewportOptions: ViewportOptions): void {
@@ -254,9 +236,7 @@ class ViewportInfo {
return this.viewportOptions;
}
- public setDisplaySetOptions(
- displaySetOptions: Array
- ): void {
+ public setDisplaySetOptions(displaySetOptions: Array): void {
this.displaySetOptions = displaySetOptions;
}
diff --git a/extensions/cornerstone/src/state.ts b/extensions/cornerstone/src/state.ts
index e1d67a5615..76afcdbb8d 100644
--- a/extensions/cornerstone/src/state.ts
+++ b/extensions/cornerstone/src/state.ts
@@ -9,26 +9,22 @@ const state = {
* @param {HTMLElement} dom Active viewport element.
* @return void
*/
-const setEnabledElement = (
- viewportIndex: number,
- element: HTMLElement,
- context?: string
-): void => {
+const setEnabledElement = (viewportId: string, element: HTMLElement, context?: string): void => {
const targetContext = context || state.DEFAULT_CONTEXT;
- state.enabledElements[viewportIndex] = {
+ state.enabledElements[viewportId] = {
element,
context: targetContext,
};
};
/**
- * Grabs the enabled element `dom` reference of an ative viewport.
+ * Grabs the enabled element `dom` reference of an active viewport.
*
* @return {HTMLElement} Active viewport element.
*/
-const getEnabledElement = viewportIndex => {
- return state.enabledElements[viewportIndex];
+const getEnabledElement = viewportId => {
+ return state.enabledElements[viewportId];
};
const reset = () => {
diff --git a/extensions/cornerstone/src/tools/CalibrationLineTool.ts b/extensions/cornerstone/src/tools/CalibrationLineTool.ts
index 1db404034c..3b4a9bede0 100644
--- a/extensions/cornerstone/src/tools/CalibrationLineTool.ts
+++ b/extensions/cornerstone/src/tools/CalibrationLineTool.ts
@@ -25,8 +25,7 @@ class CalibrationLineTool extends LengthTool {
this._renderingViewport.worldToCanvas(p)
);
// for display, round to 2 decimal points
- const lengthPx =
- Math.round(calculateLength2(canvasPoint1, canvasPoint2) * 100) / 100;
+ const lengthPx = Math.round(calculateLength2(canvasPoint1, canvasPoint2) * 100) / 100;
const textLines = [`${lengthPx}px`];
@@ -64,17 +63,11 @@ export function onCompletedCalibrationLine(servicesManager, csToolsEvent) {
const length =
Math.round(
- calculateLength3(
- annotationData.handles.points[0],
- annotationData.handles.points[1]
- ) * 100
+ calculateLength3(annotationData.handles.points[0], annotationData.handles.points[1]) * 100
) / 100;
// calculate the currently applied pixel spacing on the viewport
- const calibratedPixelSpacing = metaData.get(
- 'calibratedPixelSpacing',
- imageId
- );
+ const calibratedPixelSpacing = metaData.get('calibratedPixelSpacing', imageId);
const imagePlaneModule = metaData.get('imagePlaneModule', imageId);
const currentRowPixelSpacing =
calibratedPixelSpacing?.[0] || imagePlaneModule?.rowPixelSpacing || 1;
@@ -83,16 +76,12 @@ export function onCompletedCalibrationLine(servicesManager, csToolsEvent) {
const adjustCalibration = newLength => {
const spacingScale = newLength / length;
- const rowSpacing = spacingScale * currentRowPixelSpacing;
- const colSpacing = spacingScale * currentColumnPixelSpacing;
// trigger resize of the viewport to adjust the world/pixel mapping
- calibrateImageSpacing(
- imageId,
- viewport.getRenderingEngine(),
- rowSpacing,
- colSpacing
- );
+ calibrateImageSpacing(imageId, viewport.getRenderingEngine(), {
+ type: 'User',
+ scale: 1 / spacingScale,
+ });
};
return new Promise((resolve, reject) => {
diff --git a/extensions/cornerstone/src/tools/ImageOverlayViewerTool.tsx b/extensions/cornerstone/src/tools/ImageOverlayViewerTool.tsx
new file mode 100644
index 0000000000..e3dead9851
--- /dev/null
+++ b/extensions/cornerstone/src/tools/ImageOverlayViewerTool.tsx
@@ -0,0 +1,257 @@
+import { VolumeViewport, metaData } from '@cornerstonejs/core';
+import { utilities } from '@cornerstonejs/core';
+import { IStackViewport, IVolumeViewport, Point3 } from '@cornerstonejs/core/dist/esm/types';
+import { AnnotationDisplayTool, drawing } from '@cornerstonejs/tools';
+import { guid } from '@ohif/core/src/utils';
+
+interface CachedStat {
+ color: number[]; // [r, g, b, a]
+ overlays: {
+ // ...overlayPlaneModule
+ _id: string;
+ type: 'G' | 'R'; // G for Graphics, R for ROI
+ color?: number[]; // Rendered color [r, g, b, a]
+ dataUrl?: string; // Rendered image in Data URL expression
+ }[];
+}
+
+/**
+ * Image Overlay Viewer tool is not a traditional tool that requires user interactin.
+ * But it is used to display Pixel Overlays. And it will provide toggling capability.
+ *
+ * The documentation for Overlay Plane Module of DICOM can be found in [C.9.2 of
+ * Part-3 of DICOM standard](https://dicom.nema.org/medical/dicom/2018b/output/chtml/part03/sect_C.9.2.html)
+ *
+ * Image Overlay rendered by this tool can be toggled on and off using
+ * toolGroup.setToolEnabled() and toolGroup.setToolDisabled()
+ */
+class ImageOverlayViewerTool extends AnnotationDisplayTool {
+ static toolName = 'ImageOverlayViewer';
+ private _cachedOverlayMetadata: Map = new Map();
+ private _cachedStats: { [key: string]: CachedStat } = {};
+
+ constructor(
+ toolProps = {},
+ defaultToolProps = {
+ supportedInteractionTypes: [],
+ configuration: {
+ fillColor: [255, 127, 127, 255],
+ },
+ }
+ ) {
+ super(toolProps, defaultToolProps);
+ }
+
+ onSetToolDisabled = (): void => {
+ this._cachedStats = {};
+ this._cachedOverlayMetadata = new Map();
+ };
+
+ protected getReferencedImageId(viewport: IStackViewport | IVolumeViewport): string {
+ if (viewport instanceof VolumeViewport) {
+ return;
+ }
+
+ const targetId = this.getTargetId(viewport);
+ return targetId.split('imageId:')[1];
+ }
+
+ renderAnnotation = (enabledElement, svgDrawingHelper) => {
+ const { viewport } = enabledElement;
+
+ const imageId = this.getReferencedImageId(viewport);
+ if (!imageId) {
+ return;
+ }
+
+ const overlays =
+ this._cachedOverlayMetadata.get(imageId) ??
+ metaData.get('overlayPlaneModule', imageId)?.overlays;
+
+ // no overlays
+ if (!overlays?.length) {
+ return;
+ }
+
+ this._cachedOverlayMetadata.set(imageId, overlays);
+
+ this._getCachedStat(imageId, overlays, this.configuration.fillColor).then(cachedStat => {
+ cachedStat.overlays.forEach(overlay => {
+ this._renderOverlay(enabledElement, svgDrawingHelper, overlay);
+ });
+ });
+
+ return true;
+ };
+
+ /**
+ * Render to DOM
+ *
+ * @param enabledElement
+ * @param svgDrawingHelper
+ * @param overlayData
+ * @returns
+ */
+ private _renderOverlay(enabledElement, svgDrawingHelper, overlayData) {
+ const { viewport } = enabledElement;
+ const imageId = this.getReferencedImageId(viewport);
+ if (!imageId) {
+ return;
+ }
+
+ // Decide the rendering position of the overlay image on the current canvas
+ const { _id, columns: width, rows: height, x, y } = overlayData;
+ const overlayTopLeftWorldPos = utilities.imageToWorldCoords(imageId, [
+ x - 1, // Remind that top-left corner's (x, y) is be (1, 1)
+ y - 1,
+ ]);
+ const overlayTopLeftOnCanvas = viewport.worldToCanvas(overlayTopLeftWorldPos);
+ const overlayBottomRightWorldPos = utilities.imageToWorldCoords(imageId, [width, height]);
+ const overlayBottomRightOnCanvas = viewport.worldToCanvas(overlayBottomRightWorldPos);
+
+ // add image to the annotations svg layer
+ const svgns = 'http://www.w3.org/2000/svg';
+ const svgNodeHash = `image-overlay-${_id}`;
+ const existingImageElement = svgDrawingHelper.getSvgNode(svgNodeHash);
+
+ const attributes = {
+ 'data-id': svgNodeHash,
+ width: overlayBottomRightOnCanvas[0] - overlayTopLeftOnCanvas[0],
+ height: overlayBottomRightOnCanvas[1] - overlayTopLeftOnCanvas[1],
+ x: overlayTopLeftOnCanvas[0],
+ y: overlayTopLeftOnCanvas[1],
+ href: overlayData.dataUrl,
+ };
+
+ if (
+ isNaN(attributes.x) ||
+ isNaN(attributes.y) ||
+ isNaN(attributes.width) ||
+ isNaN(attributes.height)
+ ) {
+ console.warn('Invalid rendering attribute for image overlay', attributes['data-id']);
+ return false;
+ }
+
+ if (existingImageElement) {
+ drawing.setAttributesIfNecessary(attributes, existingImageElement);
+ svgDrawingHelper.setNodeTouched(svgNodeHash);
+ } else {
+ const newImageElement = document.createElementNS(svgns, 'image');
+ drawing.setNewAttributesIfValid(attributes, newImageElement);
+ svgDrawingHelper.appendNode(newImageElement, svgNodeHash);
+ }
+ return true;
+ }
+
+ private async _getCachedStat(
+ imageId: string,
+ overlayMetadata: any[],
+ color: number[]
+ ): Promise {
+ if (this._cachedStats[imageId] && this._isSameColor(this._cachedStats[imageId].color, color)) {
+ return this._cachedStats[imageId];
+ }
+
+ const overlays = await Promise.all(
+ overlayMetadata
+ .filter(overlay => overlay.pixelData)
+ .map(async (overlay, idx) => {
+ let pixelData = null;
+ if (overlay.pixelData.Value) {
+ pixelData = overlay.pixelData.Value;
+ } else if (overlay.pixelData.retrieveBulkData) {
+ pixelData = await overlay.pixelData.retrieveBulkData();
+ }
+
+ if (!pixelData) {
+ return;
+ }
+
+ const dataUrl = this._renderOverlayToDataUrl(
+ { width: overlay.columns, height: overlay.rows },
+ color,
+ pixelData
+ );
+
+ return {
+ ...overlay,
+ _id: guid(),
+ dataUrl, // this will be a data url expression of the rendered image
+ color,
+ };
+ })
+ );
+
+ this._cachedStats[imageId] = {
+ color: color,
+ overlays: overlays.filter(overlay => overlay),
+ };
+
+ return this._cachedStats[imageId];
+ }
+
+ /**
+ * compare two RGBA expression of colors.
+ *
+ * @param color1
+ * @param color2
+ * @returns
+ */
+ private _isSameColor(color1: number[], color2: number[]) {
+ return (
+ color1 &&
+ color2 &&
+ color1[0] === color2[0] &&
+ color1[1] === color2[1] &&
+ color1[2] === color2[2] &&
+ color1[3] === color2[3]
+ );
+ }
+
+ /**
+ * pixelData of overlayPlane module is an array of bits corresponding
+ * to each of the underlying pixels of the image.
+ * Let's create pixel data from bit array of overlay data
+ *
+ * @param pixelDataRaw
+ * @param color
+ * @returns
+ */
+ private _renderOverlayToDataUrl({ width, height }, color, pixelDataRaw) {
+ const pixelDataView = new DataView(pixelDataRaw);
+ const totalBits = width * height;
+
+ const canvas = document.createElement('canvas');
+ canvas.width = width;
+ canvas.height = height;
+
+ const ctx = canvas.getContext('2d');
+ ctx.clearRect(0, 0, width, height); // make it transparent
+ ctx.globalCompositeOperation = 'copy';
+
+ const imageData = ctx.getImageData(0, 0, width, height);
+ const data = imageData.data;
+ for (let i = 0, bitIdx = 0, byteIdx = 0; i < totalBits; i++) {
+ if (pixelDataView.getUint8(byteIdx) & (1 << bitIdx)) {
+ data[i * 4] = color[0];
+ data[i * 4 + 1] = color[1];
+ data[i * 4 + 2] = color[2];
+ data[i * 4 + 3] = color[3];
+ }
+
+ // next bit, byte
+ if (bitIdx >= 7) {
+ bitIdx = 0;
+ byteIdx++;
+ } else {
+ bitIdx++;
+ }
+ }
+ ctx.putImageData(imageData, 0, 0);
+
+ return canvas.toDataURL();
+ }
+}
+
+export default ImageOverlayViewerTool;
diff --git a/extensions/cornerstone/src/types/CornerstoneServices.ts b/extensions/cornerstone/src/types/CornerstoneServices.ts
index 2f52dc9ff9..b7b791ae6a 100644
--- a/extensions/cornerstone/src/types/CornerstoneServices.ts
+++ b/extensions/cornerstone/src/types/CornerstoneServices.ts
@@ -1,9 +1,9 @@
import { Types } from '@ohif/core';
-import ToolGroupService from './services/ToolGroupService';
-import SyncGroupService from './services/SyncGroupService';
-import SegmentationService from './services/SegmentationService';
-import CornerstoneCacheService from './services/CornerstoneCacheService';
-import CornerstoneViewportService from './services/ViewportService/CornerstoneViewportService';
+import ToolGroupService from '../services/ToolGroupService';
+import SyncGroupService from '../services/SyncGroupService';
+import SegmentationService from '../services/SegmentationService';
+import CornerstoneCacheService from '../services/CornerstoneCacheService';
+import CornerstoneViewportService from '../services/ViewportService/CornerstoneViewportService';
interface CornerstoneServices extends Types.Services {
cornerstoneViewportService: CornerstoneViewportService;
diff --git a/extensions/cornerstone/src/types/index.ts b/extensions/cornerstone/src/types/index.ts
index 6c729817d6..c8db85fb76 100644
--- a/extensions/cornerstone/src/types/index.ts
+++ b/extensions/cornerstone/src/types/index.ts
@@ -1,7 +1,4 @@
-import * as CornerstoneCacheService from './CornerstoneCacheService'
+import * as CornerstoneCacheService from './CornerstoneCacheService';
import CornerstoneServices from './CornerstoneServices';
-export type {
- CornerstoneCacheService,
- CornerstoneServices,
-}
+export type { CornerstoneCacheService, CornerstoneServices };
diff --git a/extensions/cornerstone/src/utils/CornerstoneViewportDownloadForm.tsx b/extensions/cornerstone/src/utils/CornerstoneViewportDownloadForm.tsx
index cfab216e78..048c6d008b 100644
--- a/extensions/cornerstone/src/utils/CornerstoneViewportDownloadForm.tsx
+++ b/extensions/cornerstone/src/utils/CornerstoneViewportDownloadForm.tsx
@@ -20,38 +20,29 @@ const VIEWPORT_ID = 'cornerstone-viewport-download-form';
const CornerstoneViewportDownloadForm = ({
onClose,
- activeViewportIndex,
+ activeViewportId: activeViewportIdProp,
cornerstoneViewportService,
}) => {
- const enabledElement = OHIFgetEnabledElement(activeViewportIndex);
+ const enabledElement = OHIFgetEnabledElement(activeViewportIdProp);
const activeViewportElement = enabledElement?.element;
const activeViewportEnabledElement = getEnabledElement(activeViewportElement);
- const {
- viewportId: activeViewportId,
- renderingEngineId,
- } = activeViewportEnabledElement;
+ const { viewportId: activeViewportId, renderingEngineId } = activeViewportEnabledElement;
- const toolGroup = ToolGroupManager.getToolGroupForViewport(
- activeViewportId,
- renderingEngineId
- );
+ const toolGroup = ToolGroupManager.getToolGroupForViewport(activeViewportId, renderingEngineId);
- const toolModeAndBindings = Object.keys(toolGroup.toolOptions).reduce(
- (acc, toolName) => {
- const tool = toolGroup.toolOptions[toolName];
- const { mode, bindings } = tool;
+ const toolModeAndBindings = Object.keys(toolGroup.toolOptions).reduce((acc, toolName) => {
+ const tool = toolGroup.toolOptions[toolName];
+ const { mode, bindings } = tool;
- return {
- ...acc,
- [toolName]: {
- mode,
- bindings,
- },
- };
- },
- {}
- );
+ return {
+ ...acc,
+ [toolName]: {
+ mode,
+ bindings,
+ },
+ };
+ }, {});
useEffect(() => {
return () => {
@@ -64,9 +55,7 @@ const CornerstoneViewportDownloadForm = ({
const enableViewport = viewportElement => {
if (viewportElement) {
- const { renderingEngine, viewport } = getEnabledElement(
- activeViewportElement
- );
+ const { renderingEngine, viewport } = getEnabledElement(activeViewportElement);
const viewportInput = {
viewportId: VIEWPORT_ID,
@@ -91,11 +80,7 @@ const CornerstoneViewportDownloadForm = ({
}
};
- const updateViewportPreview = (
- downloadViewportElement,
- internalCanvas,
- fileType
- ) =>
+ const updateViewportPreview = (downloadViewportElement, internalCanvas, fileType) =>
new Promise(resolve => {
const enabledElement = getEnabledElement(downloadViewportElement);
@@ -133,10 +118,7 @@ const CornerstoneViewportDownloadForm = ({
resolve({ dataUrl, width: newWidth, height: newHeight });
- downloadViewportElement.removeEventListener(
- Enums.Events.IMAGE_RENDERED,
- updateViewport
- );
+ downloadViewportElement.removeEventListener(Enums.Events.IMAGE_RENDERED, updateViewport);
}
);
});
@@ -144,9 +126,7 @@ const CornerstoneViewportDownloadForm = ({
const loadImage = (activeViewportElement, viewportElement, width, height) =>
new Promise(resolve => {
if (activeViewportElement && viewportElement) {
- const activeViewportEnabledElement = getEnabledElement(
- activeViewportElement
- );
+ const activeViewportEnabledElement = getEnabledElement(activeViewportElement);
if (!activeViewportEnabledElement) {
return;
@@ -165,10 +145,7 @@ const CornerstoneViewportDownloadForm = ({
downloadViewport.setProperties(properties);
const newWidth = Math.min(width || image.width, MAX_TEXTURE_SIZE);
- const newHeight = Math.min(
- height || image.height,
- MAX_TEXTURE_SIZE
- );
+ const newHeight = Math.min(height || image.height, MAX_TEXTURE_SIZE);
resolve({ width: newWidth, height: newHeight });
});
@@ -190,31 +167,19 @@ const CornerstoneViewportDownloadForm = ({
}
});
- const toggleAnnotations = (
- toggle,
- viewportElement,
- activeViewportElement
- ) => {
- const activeViewportEnabledElement = getEnabledElement(
- activeViewportElement
- );
+ const toggleAnnotations = (toggle, viewportElement, activeViewportElement) => {
+ const activeViewportEnabledElement = getEnabledElement(activeViewportElement);
const downloadViewportElement = getEnabledElement(viewportElement);
- const {
- viewportId: activeViewportId,
- renderingEngineId,
- } = activeViewportEnabledElement;
+ const { viewportId: activeViewportId, renderingEngineId } = activeViewportEnabledElement;
const { viewportId: downloadViewportId } = downloadViewportElement;
if (!activeViewportEnabledElement || !downloadViewportElement) {
return;
}
- const toolGroup = ToolGroupManager.getToolGroupForViewport(
- activeViewportId,
- renderingEngineId
- );
+ const toolGroup = ToolGroupManager.getToolGroupForViewport(activeViewportId, renderingEngineId);
// add the viewport to the toolGroup
toolGroup.addViewport(downloadViewportId, renderingEngineId);
@@ -268,7 +233,7 @@ const CornerstoneViewportDownloadForm = ({
CornerstoneViewportDownloadForm.propTypes = {
onClose: PropTypes.func,
- activeViewportIndex: PropTypes.number.isRequired,
+ activeViewportId: PropTypes.string.isRequired,
};
export default CornerstoneViewportDownloadForm;
diff --git a/extensions/cornerstone/src/utils/DicomFileUploader.ts b/extensions/cornerstone/src/utils/DicomFileUploader.ts
index 64465e597e..cfbad0745b 100644
--- a/extensions/cornerstone/src/utils/DicomFileUploader.ts
+++ b/extensions/cornerstone/src/utils/DicomFileUploader.ts
@@ -98,22 +98,13 @@ export default class DicomFileUploader extends PubSubService {
});
},
timeout: () => {
- this._reject(
- reject,
- new UploadRejection(UploadStatus.Failed, 'The request timed out.')
- );
+ this._reject(reject, new UploadRejection(UploadStatus.Failed, 'The request timed out.'));
},
abort: () => {
- this._reject(
- reject,
- new UploadRejection(UploadStatus.Cancelled, 'Cancelled')
- );
+ this._reject(reject, new UploadRejection(UploadStatus.Cancelled, 'Cancelled'));
},
error: () => {
- this._reject(
- reject,
- new UploadRejection(UploadStatus.Failed, 'The request failed.')
- );
+ this._reject(reject, new UploadRejection(UploadStatus.Failed, 'The request failed.'));
},
};
@@ -122,10 +113,7 @@ export default class DicomFileUploader extends PubSubService {
.loadFileRequest(this._fileId)
.then(dicomFile => {
if (this._abortController.signal.aborted) {
- this._reject(
- reject,
- new UploadRejection(UploadStatus.Cancelled, 'Cancelled')
- );
+ this._reject(reject, new UploadRejection(UploadStatus.Cancelled, 'Cancelled'));
return;
}
@@ -133,10 +121,7 @@ export default class DicomFileUploader extends PubSubService {
// The file is not DICOM
this._reject(
reject,
- new UploadRejection(
- UploadStatus.Failed,
- 'Not a valid DICOM file.'
- )
+ new UploadRejection(UploadStatus.Failed, 'Not a valid DICOM file.')
);
return;
}
@@ -164,10 +149,7 @@ export default class DicomFileUploader extends PubSubService {
}
private _isRejected(): boolean {
- return (
- this._status === UploadStatus.Failed ||
- this._status === UploadStatus.Cancelled
- );
+ return this._status === UploadStatus.Failed || this._status === UploadStatus.Cancelled;
}
private _reject(reject: (reason?: any) => void, reason: any) {
@@ -212,7 +194,9 @@ export default class DicomFileUploader extends PubSubService {
}
private _checkDicomFile(arrayBuffer: ArrayBuffer) {
- if (arrayBuffer.length <= 132) return false;
+ if (arrayBuffer.length <= 132) {
+ return false;
+ }
const arr = new Uint8Array(arrayBuffer.slice(128, 132));
// bytes from 128 to 132 must be "DICM"
return Array.from('DICM').every((char, i) => char.charCodeAt(0) === arr[i]);
diff --git a/extensions/cornerstone/src/utils/callInputDialog.tsx b/extensions/cornerstone/src/utils/callInputDialog.tsx
index b141ece63b..37d5021c50 100644
--- a/extensions/cornerstone/src/utils/callInputDialog.tsx
+++ b/extensions/cornerstone/src/utils/callInputDialog.tsx
@@ -1,5 +1,5 @@
import React from 'react';
-import { Input, Dialog } from '@ohif/ui';
+import { Input, Dialog, ButtonEnums } from '@ohif/ui';
/**
*
@@ -21,11 +21,7 @@ function callInputDialog(
dialogConfig: any = {}
) {
const dialogId = 'dialog-enter-annotation';
- const label = data
- ? isArrowAnnotateInputDialog
- ? data.text
- : data.label
- : '';
+ const label = data ? (isArrowAnnotateInputDialog ? data.text : data.label) : '';
const {
dialogTitle = 'Annotation',
inputLabel = 'Enter your annotation',
@@ -35,8 +31,9 @@ function callInputDialog(
const onSubmitHandler = ({ action, value }) => {
switch (action.id) {
case 'save':
- if (typeof validateFunc === 'function' && !validateFunc(value.label))
+ if (typeof validateFunc === 'function' && !validateFunc(value.label)) {
return;
+ }
callback(value.label, action.id);
break;
@@ -60,15 +57,15 @@ function callInputDialog(
noCloseButton: true,
onClose: () => uiDialogService.dismiss({ id: dialogId }),
actions: [
- { id: 'cancel', text: 'Cancel', type: 'primary' },
- { id: 'save', text: 'Save', type: 'secondary' },
+ { id: 'cancel', text: 'Cancel', type: ButtonEnums.type.secondary },
+ { id: 'save', text: 'Save', type: ButtonEnums.type.primary },
],
onSubmit: onSubmitHandler,
body: ({ value, setValue }) => {
return (
{
return;
}
- return typeof imageObj.getImageId === 'function'
- ? imageObj.getImageId()
- : imageObj.url;
+ return typeof imageObj.getImageId === 'function' ? imageObj.getImageId() : imageObj.url;
};
const findImageIdOnStudies = (studies, displaySetInstanceUID) => {
@@ -99,7 +97,7 @@ class DicomLoaderService {
if (
(!imageInstance && !nonImageInstance) ||
- !nonImageInstance.imageId.startsWith('dicomfile')
+ !nonImageInstance.imageId?.startsWith('dicomfile')
) {
return;
}
@@ -163,9 +161,7 @@ class DicomLoaderService {
getDicomDataMethod = fetchIt.bind(this, imageId);
break;
default:
- throw new Error(
- `Unsupported image type: ${loaderType} for imageId: ${imageId}`
- );
+ throw new Error(`Unsupported image type: ${loaderType} for imageId: ${imageId}`);
}
return getDicomDataMethod();
diff --git a/extensions/cornerstone/src/utils/getActiveViewportEnabledElement.ts b/extensions/cornerstone/src/utils/getActiveViewportEnabledElement.ts
index d188ece9af..e63e85f791 100644
--- a/extensions/cornerstone/src/utils/getActiveViewportEnabledElement.ts
+++ b/extensions/cornerstone/src/utils/getActiveViewportEnabledElement.ts
@@ -3,11 +3,9 @@ import { IEnabledElement } from '@cornerstonejs/core/dist/esm/types';
import { getEnabledElement as OHIFgetEnabledElement } from '../state';
-export default function getActiveViewportEnabledElement(
- viewportGridService
-): IEnabledElement {
- const { activeViewportIndex } = viewportGridService.getState();
- const { element } = OHIFgetEnabledElement(activeViewportIndex) || {};
+export default function getActiveViewportEnabledElement(viewportGridService): IEnabledElement {
+ const { activeViewportId } = viewportGridService.getState();
+ const { element } = OHIFgetEnabledElement(activeViewportId) || {};
const enabledElement = getEnabledElement(element);
return enabledElement;
}
diff --git a/extensions/cornerstone/src/utils/getCornerstoneBlendMode.ts b/extensions/cornerstone/src/utils/getCornerstoneBlendMode.ts
index 4bc7cb449f..37dca4c10b 100644
--- a/extensions/cornerstone/src/utils/getCornerstoneBlendMode.ts
+++ b/extensions/cornerstone/src/utils/getCornerstoneBlendMode.ts
@@ -2,9 +2,7 @@ import { Enums } from '@cornerstonejs/core';
const MIP = 'mip';
-export default function getCornerstoneBlendMode(
- blendMode: string
-): Enums.BlendModes {
+export default function getCornerstoneBlendMode(blendMode: string): Enums.BlendModes {
if (!blendMode) {
return Enums.BlendModes.COMPOSITE;
}
diff --git a/extensions/cornerstone/src/utils/getCornerstoneOrientation.ts b/extensions/cornerstone/src/utils/getCornerstoneOrientation.ts
index 8ac7b2cb51..6e47fe8076 100644
--- a/extensions/cornerstone/src/utils/getCornerstoneOrientation.ts
+++ b/extensions/cornerstone/src/utils/getCornerstoneOrientation.ts
@@ -4,9 +4,7 @@ const AXIAL = 'axial';
const SAGITTAL = 'sagittal';
const CORONAL = 'coronal';
-export default function getCornerstoneOrientation(
- orientation: string
-): Enums.OrientationAxis {
+export default function getCornerstoneOrientation(orientation: string): Enums.OrientationAxis {
if (orientation) {
switch (orientation.toLowerCase()) {
case AXIAL:
diff --git a/extensions/cornerstone/src/utils/getCornerstoneViewportType.ts b/extensions/cornerstone/src/utils/getCornerstoneViewportType.ts
index 47a5ede85b..9a5dd71de1 100644
--- a/extensions/cornerstone/src/utils/getCornerstoneViewportType.ts
+++ b/extensions/cornerstone/src/utils/getCornerstoneViewportType.ts
@@ -5,9 +5,7 @@ const VOLUME = 'volume';
const ORTHOGRAPHIC = 'orthographic';
const VOLUME_3D = 'volume3d';
-export default function getCornerstoneViewportType(
- viewportType: string
-): Enums.ViewportType {
+export default function getCornerstoneViewportType(viewportType: string): Enums.ViewportType {
const lowerViewportType = viewportType.toLowerCase();
if (lowerViewportType === STACK) {
return Enums.ViewportType.STACK;
@@ -21,7 +19,5 @@ export default function getCornerstoneViewportType(
return Enums.ViewportType.VOLUME_3D;
}
- throw new Error(
- `Invalid viewport type: ${viewportType}. Valid types are: stack, volume`
- );
+ throw new Error(`Invalid viewport type: ${viewportType}. Valid types are: stack, volume`);
}
diff --git a/extensions/cornerstone/src/utils/getInterleavedFrames.js b/extensions/cornerstone/src/utils/getInterleavedFrames.js
index d8eae131a2..b380a9350b 100644
--- a/extensions/cornerstone/src/utils/getInterleavedFrames.js
+++ b/extensions/cornerstone/src/utils/getInterleavedFrames.js
@@ -30,7 +30,7 @@ export default function getInterleavedFrames(imageIds) {
!prefetchQueuedFilled.currentPositionUpToMaximum
) {
if (!prefetchQueuedFilled.currentPositionDownToMinimum) {
- // Add imageId bellow
+ // Add imageId below
lowerImageIdIndex--;
imageIdsToPrefetch.push({
imageId: imageIds[lowerImageIdIndex],
diff --git a/extensions/cornerstone/src/utils/getNthFrames.js b/extensions/cornerstone/src/utils/getNthFrames.js
index 09bfc0b1ec..38df66d958 100644
--- a/extensions/cornerstone/src/utils/getNthFrames.js
+++ b/extensions/cornerstone/src/utils/getNthFrames.js
@@ -19,11 +19,7 @@ export default function getNthFrames(imageIds) {
const centerEnd = centerStart + 6;
for (let i = 0; i < imageIds.length; i++) {
- if (
- i < 2 ||
- i > imageIds.length - 4 ||
- (i > centerStart && i < centerEnd)
- ) {
+ if (i < 2 || i > imageIds.length - 4 || (i > centerStart && i < centerEnd)) {
frames[0].push(imageIds[i]);
} else if (i % 7 === 2) {
frames[1].push(imageIds[i]);
@@ -33,12 +29,6 @@ export default function getNthFrames(imageIds) {
frames[(i % 2) + 3].push(imageIds[i]);
}
}
- const ret = [
- ...frames[0],
- ...frames[1],
- ...frames[2],
- ...frames[3],
- ...frames[4],
- ];
+ const ret = [...frames[0], ...frames[1], ...frames[2], ...frames[3], ...frames[4]];
return ret;
}
diff --git a/extensions/cornerstone/src/utils/interleave.js b/extensions/cornerstone/src/utils/interleave.js
index 05fe2cab19..a21d3fb7e0 100644
--- a/extensions/cornerstone/src/utils/interleave.js
+++ b/extensions/cornerstone/src/utils/interleave.js
@@ -7,8 +7,12 @@
* @returns [] reordered to be breadth first traversal of lists
*/
export default function interleave(lists) {
- if (!lists || !lists.length) return [];
- if (lists.length === 1) return lists[0];
+ if (!lists || !lists.length) {
+ return [];
+ }
+ if (lists.length === 1) {
+ return lists[0];
+ }
console.time('interleave');
const useLists = [...lists];
const ret = [];
diff --git a/extensions/cornerstone/src/utils/interleaveCenterLoader.ts b/extensions/cornerstone/src/utils/interleaveCenterLoader.ts
index 0047f0ac0a..d8f64b5d83 100644
--- a/extensions/cornerstone/src/utils/interleaveCenterLoader.ts
+++ b/extensions/cornerstone/src/utils/interleaveCenterLoader.ts
@@ -105,9 +105,7 @@ export default function interleaveCenterLoader({
const { imageId } = request;
AllRequests.forEach(volumeRequests => {
- const volumeImageIdRequest = volumeRequests.find(
- req => req.imageId === imageId
- );
+ const volumeImageIdRequest = volumeRequests.find(req => req.imageId === imageId);
if (volumeImageIdRequest) {
finalRequests.push(volumeImageIdRequest);
}
@@ -117,31 +115,17 @@ export default function interleaveCenterLoader({
const requestType = Enums.RequestType.Prefetch;
const priority = 0;
- finalRequests.forEach(
- ({ callLoadImage, additionalDetails, imageId, imageIdIndex, options }) => {
- const callLoadImageBound = callLoadImage.bind(
- null,
- imageId,
- imageIdIndex,
- options
- );
-
- imageLoadPoolManager.addRequest(
- callLoadImageBound,
- requestType,
- additionalDetails,
- priority
- );
- }
- );
+ finalRequests.forEach(({ callLoadImage, additionalDetails, imageId, imageIdIndex, options }) => {
+ const callLoadImageBound = callLoadImage.bind(null, imageId, imageIdIndex, options);
+
+ imageLoadPoolManager.addRequest(callLoadImageBound, requestType, additionalDetails, priority);
+ });
// clear the volumeIdMapsToLoad
volumeIdMapsToLoad.clear();
// copy the viewportIdVolumeInputArrayMap
- const viewportIdVolumeInputArrayMapCopy = new Map(
- viewportIdVolumeInputArrayMap
- );
+ const viewportIdVolumeInputArrayMapCopy = new Map(viewportIdVolumeInputArrayMap);
// reset the viewportIdVolumeInputArrayMap
viewportIdVolumeInputArrayMap.clear();
diff --git a/extensions/cornerstone/src/utils/interleaveTopToBottom.ts b/extensions/cornerstone/src/utils/interleaveTopToBottom.ts
index 162bb5588c..0caf403729 100644
--- a/extensions/cornerstone/src/utils/interleaveTopToBottom.ts
+++ b/extensions/cornerstone/src/utils/interleaveTopToBottom.ts
@@ -94,9 +94,7 @@ export default function interleaveTopToBottom({
const { imageId } = request;
AllRequests.forEach(volumeRequests => {
- const volumeImageIdRequest = volumeRequests.find(
- req => req.imageId === imageId
- );
+ const volumeImageIdRequest = volumeRequests.find(req => req.imageId === imageId);
if (volumeImageIdRequest) {
finalRequests.push(volumeImageIdRequest);
}
@@ -106,31 +104,17 @@ export default function interleaveTopToBottom({
const requestType = Enums.RequestType.Prefetch;
const priority = 0;
- finalRequests.forEach(
- ({ callLoadImage, additionalDetails, imageId, imageIdIndex, options }) => {
- const callLoadImageBound = callLoadImage.bind(
- null,
- imageId,
- imageIdIndex,
- options
- );
-
- imageLoadPoolManager.addRequest(
- callLoadImageBound,
- requestType,
- additionalDetails,
- priority
- );
- }
- );
+ finalRequests.forEach(({ callLoadImage, additionalDetails, imageId, imageIdIndex, options }) => {
+ const callLoadImageBound = callLoadImage.bind(null, imageId, imageIdIndex, options);
+
+ imageLoadPoolManager.addRequest(callLoadImageBound, requestType, additionalDetails, priority);
+ });
// clear the volumeIdMapsToLoad
volumeIdMapsToLoad.clear();
// copy the viewportIdVolumeInputArrayMap
- const viewportIdVolumeInputArrayMapCopy = new Map(
- viewportIdVolumeInputArrayMap
- );
+ const viewportIdVolumeInputArrayMapCopy = new Map(viewportIdVolumeInputArrayMap);
// reset the viewportIdVolumeInputArrayMap
viewportIdVolumeInputArrayMap.clear();
diff --git a/extensions/cornerstone/src/utils/measurementServiceMappings/Angle.ts b/extensions/cornerstone/src/utils/measurementServiceMappings/Angle.ts
index dfbe9aa62a..40f9c9ef6c 100644
--- a/extensions/cornerstone/src/utils/measurementServiceMappings/Angle.ts
+++ b/extensions/cornerstone/src/utils/measurementServiceMappings/Angle.ts
@@ -3,7 +3,7 @@ import getSOPInstanceAttributes from './utils/getSOPInstanceAttributes';
import { utils } from '@ohif/core';
const Angle = {
- toAnnotation: measurement => { },
+ toAnnotation: measurement => {},
/**
* Maps cornerstone annotation event data to measurement service format.
@@ -32,11 +32,7 @@ const Angle = {
throw new Error('Tool not supported');
}
- const {
- SOPInstanceUID,
- SeriesInstanceUID,
- StudyInstanceUID,
- } = getSOPInstanceAttributes(
+ const { SOPInstanceUID, SeriesInstanceUID, StudyInstanceUID } = getSOPInstanceAttributes(
referencedImageId,
CornerstoneViewportService,
viewportId
@@ -55,14 +51,10 @@ const Angle = {
const { points } = data.handles;
- const mappedAnnotations = getMappedAnnotations(
- annotation,
- displaySetService
- );
+ const mappedAnnotations = getMappedAnnotations(annotation, displaySetService);
const displayText = getDisplayText(mappedAnnotations, displaySet);
- const getReport = () =>
- _getReport(mappedAnnotations, points, FrameOfReferenceUID);
+ const getReport = () => _getReport(mappedAnnotations, points, FrameOfReferenceUID);
return {
uid: annotationUID,
@@ -99,16 +91,11 @@ function getMappedAnnotations(annotation, DisplaySetService) {
const targetStats = cachedStats[targetId];
if (!referencedImageId) {
- throw new Error(
- 'Non-acquisition plane measurement mapping not supported'
- );
+ throw new Error('Non-acquisition plane measurement mapping not supported');
}
- const {
- SOPInstanceUID,
- SeriesInstanceUID,
- frameNumber,
- } = getSOPInstanceAttributes(referencedImageId);
+ const { SOPInstanceUID, SeriesInstanceUID, frameNumber } =
+ getSOPInstanceAttributes(referencedImageId);
const displaySet = DisplaySetService.getDisplaySetForSOPInstanceUID(
SOPInstanceUID,
@@ -179,17 +166,9 @@ function getDisplayText(mappedAnnotations, displaySet) {
const displayText = [];
// Area is the same for all series
- const {
- angle,
- unit,
- SeriesNumber,
- SOPInstanceUID,
- frameNumber,
- } = mappedAnnotations[0];
-
- const instance = displaySet.images.find(
- image => image.SOPInstanceUID === SOPInstanceUID
- );
+ const { angle, unit, SeriesNumber, SOPInstanceUID, frameNumber } = mappedAnnotations[0];
+
+ const instance = displaySet.images.find(image => image.SOPInstanceUID === SOPInstanceUID);
let InstanceNumber;
if (instance) {
@@ -198,11 +177,11 @@ function getDisplayText(mappedAnnotations, displaySet) {
const instanceText = InstanceNumber ? ` I: ${InstanceNumber}` : '';
const frameText = displaySet.isMultiFrame ? ` F: ${frameNumber}` : '';
- if (angle === undefined) return displayText;
+ if (angle === undefined) {
+ return displayText;
+ }
const roundedAngle = utils.roundNumber(angle, 2);
- displayText.push(
- `${roundedAngle} ${unit} (S: ${SeriesNumber}${instanceText}${frameText})`
- );
+ displayText.push(`${roundedAngle} ${unit} (S: ${SeriesNumber}${instanceText}${frameText})`);
return displayText;
}
diff --git a/extensions/cornerstone/src/utils/measurementServiceMappings/ArrowAnnotate.ts b/extensions/cornerstone/src/utils/measurementServiceMappings/ArrowAnnotate.ts
index 9a6f6e49b3..d5a7129da2 100644
--- a/extensions/cornerstone/src/utils/measurementServiceMappings/ArrowAnnotate.ts
+++ b/extensions/cornerstone/src/utils/measurementServiceMappings/ArrowAnnotate.ts
@@ -31,11 +31,7 @@ const Length = {
throw new Error('Tool not supported');
}
- const {
- SOPInstanceUID,
- SeriesInstanceUID,
- StudyInstanceUID,
- } = getSOPInstanceAttributes(
+ const { SOPInstanceUID, SeriesInstanceUID, StudyInstanceUID } = getSOPInstanceAttributes(
referencedImageId,
cornerstoneViewportService,
viewportId
@@ -54,10 +50,7 @@ const Length = {
const { points } = data.handles;
- const mappedAnnotations = getMappedAnnotations(
- annotation,
- displaySetService
- );
+ const mappedAnnotations = getMappedAnnotations(annotation, displaySetService);
const displayText = getDisplayText(mappedAnnotations, displaySet);
@@ -91,11 +84,8 @@ function getMappedAnnotations(annotation, displaySetService) {
const annotations = [];
- const {
- SOPInstanceUID,
- SeriesInstanceUID,
- frameNumber,
- } = getSOPInstanceAttributes(referencedImageId);
+ const { SOPInstanceUID, SeriesInstanceUID, frameNumber } =
+ getSOPInstanceAttributes(referencedImageId);
const displaySet = displaySetService.getDisplaySetForSOPInstanceUID(
SOPInstanceUID,
@@ -126,9 +116,7 @@ function getDisplayText(mappedAnnotations, displaySet) {
// Area is the same for all series
const { SeriesNumber, SOPInstanceUID, frameNumber } = mappedAnnotations[0];
- const instance = displaySet.images.find(
- image => image.SOPInstanceUID === SOPInstanceUID
- );
+ const instance = displaySet.images.find(image => image.SOPInstanceUID === SOPInstanceUID);
let InstanceNumber;
if (instance) {
diff --git a/extensions/cornerstone/src/utils/measurementServiceMappings/Bidirectional.ts b/extensions/cornerstone/src/utils/measurementServiceMappings/Bidirectional.ts
index 781a0f909f..8652c7c8a2 100644
--- a/extensions/cornerstone/src/utils/measurementServiceMappings/Bidirectional.ts
+++ b/extensions/cornerstone/src/utils/measurementServiceMappings/Bidirectional.ts
@@ -27,11 +27,7 @@ const Bidirectional = {
throw new Error('Tool not supported');
}
- const {
- SOPInstanceUID,
- SeriesInstanceUID,
- StudyInstanceUID,
- } = getSOPInstanceAttributes(
+ const { SOPInstanceUID, SeriesInstanceUID, StudyInstanceUID } = getSOPInstanceAttributes(
referencedImageId,
cornerstoneViewportService,
viewportId
@@ -50,14 +46,10 @@ const Bidirectional = {
const { points } = data.handles;
- const mappedAnnotations = getMappedAnnotations(
- annotation,
- displaySetService
- );
+ const mappedAnnotations = getMappedAnnotations(annotation, displaySetService);
const displayText = getDisplayText(mappedAnnotations, displaySet);
- const getReport = () =>
- _getReport(mappedAnnotations, points, FrameOfReferenceUID);
+ const getReport = () => _getReport(mappedAnnotations, points, FrameOfReferenceUID);
return {
uid: annotationUID,
@@ -94,16 +86,11 @@ function getMappedAnnotations(annotation, displaySetService) {
const targetStats = cachedStats[targetId];
if (!referencedImageId) {
- throw new Error(
- 'Non-acquisition plane measurement mapping not supported'
- );
+ throw new Error('Non-acquisition plane measurement mapping not supported');
}
- const {
- SOPInstanceUID,
- SeriesInstanceUID,
- frameNumber,
- } = getSOPInstanceAttributes(referencedImageId);
+ const { SOPInstanceUID, SeriesInstanceUID, frameNumber } =
+ getSOPInstanceAttributes(referencedImageId);
const displaySet = displaySetService.getDisplaySetForSOPInstanceUID(
SOPInstanceUID,
@@ -112,8 +99,7 @@ function getMappedAnnotations(annotation, displaySetService) {
);
const { SeriesNumber } = displaySet;
- const { length, width } = targetStats;
- const unit = 'mm';
+ const { length, width, unit } = targetStats;
annotations.push({
SeriesInstanceUID,
@@ -143,9 +129,9 @@ function _getReport(mappedAnnotations, points, FrameOfReferenceUID) {
values.push('Cornerstone:Bidirectional');
mappedAnnotations.forEach(annotation => {
- const { length, width } = annotation;
- columns.push(`Length (mm)`, `Width (mm)`);
- values.push(length, width);
+ const { length, width, unit } = annotation;
+ columns.push(`Length`, `Width`, 'Unit');
+ values.push(length, width, unit);
});
if (FrameOfReferenceUID) {
@@ -178,6 +164,7 @@ function getDisplayText(mappedAnnotations, displaySet) {
const {
length,
width,
+ unit,
SeriesNumber,
SOPInstanceUID,
frameNumber,
@@ -185,9 +172,7 @@ function getDisplayText(mappedAnnotations, displaySet) {
const roundedLength = utils.roundNumber(length, 2);
const roundedWidth = utils.roundNumber(width, 2);
- const instance = displaySet.images.find(
- image => image.SOPInstanceUID === SOPInstanceUID
- );
+ const instance = displaySet.images.find(image => image.SOPInstanceUID === SOPInstanceUID);
let InstanceNumber;
if (instance) {
@@ -198,9 +183,9 @@ function getDisplayText(mappedAnnotations, displaySet) {
const frameText = displaySet.isMultiFrame ? ` F: ${frameNumber}` : '';
displayText.push(
- `L: ${roundedLength} mm (S: ${SeriesNumber}${instanceText}${frameText})`
+ `L: ${roundedLength} ${unit} (S: ${SeriesNumber}${instanceText}${frameText})`
);
- displayText.push(`W: ${roundedWidth} mm`);
+ displayText.push(`W: ${roundedWidth} ${unit}`);
return displayText;
}
diff --git a/extensions/cornerstone/src/utils/measurementServiceMappings/CircleROI.ts b/extensions/cornerstone/src/utils/measurementServiceMappings/CircleROI.ts
index c55d7da4bd..7c8f8f7cb0 100644
--- a/extensions/cornerstone/src/utils/measurementServiceMappings/CircleROI.ts
+++ b/extensions/cornerstone/src/utils/measurementServiceMappings/CircleROI.ts
@@ -1,6 +1,5 @@
import SUPPORTED_TOOLS from './constants/supportedTools';
import getSOPInstanceAttributes from './utils/getSOPInstanceAttributes';
-import getModalityUnit from './utils/getModalityUnit';
import { utils } from '@ohif/core';
const CircleROI = {
@@ -26,11 +25,7 @@ const CircleROI = {
throw new Error('Tool not supported');
}
- const {
- SOPInstanceUID,
- SeriesInstanceUID,
- StudyInstanceUID,
- } = getSOPInstanceAttributes(
+ const { SOPInstanceUID, SeriesInstanceUID, StudyInstanceUID } = getSOPInstanceAttributes(
referencedImageId,
CornerstoneViewportService,
viewportId
@@ -49,14 +44,10 @@ const CircleROI = {
const { points } = data.handles;
- const mappedAnnotations = getMappedAnnotations(
- annotation,
- DisplaySetService
- );
+ const mappedAnnotations = getMappedAnnotations(annotation, DisplaySetService);
const displayText = getDisplayText(mappedAnnotations, displaySet);
- const getReport = () =>
- _getReport(mappedAnnotations, points, FrameOfReferenceUID);
+ const getReport = () => _getReport(mappedAnnotations, points, FrameOfReferenceUID);
return {
uid: annotationUID,
@@ -94,16 +85,11 @@ function getMappedAnnotations(annotation, DisplaySetService) {
if (!referencedImageId) {
// Todo: Non-acquisition plane measurement mapping not supported yet
- throw new Error(
- 'Non-acquisition plane measurement mapping not supported'
- );
+ throw new Error('Non-acquisition plane measurement mapping not supported');
}
- const {
- SOPInstanceUID,
- SeriesInstanceUID,
- frameNumber,
- } = getSOPInstanceAttributes(referencedImageId);
+ const { SOPInstanceUID, SeriesInstanceUID, frameNumber } =
+ getSOPInstanceAttributes(referencedImageId);
const displaySet = DisplaySetService.getDisplaySetForSOPInstanceUID(
SOPInstanceUID,
@@ -112,8 +98,7 @@ function getMappedAnnotations(annotation, DisplaySetService) {
);
const { SeriesNumber } = displaySet;
- const { mean, stdDev, max, area, Modality } = targetStats;
- const unit = getModalityUnit(Modality);
+ const { mean, stdDev, max, area, Modality, areaUnit, modalityUnit } = targetStats;
annotations.push({
SeriesInstanceUID,
@@ -121,11 +106,12 @@ function getMappedAnnotations(annotation, DisplaySetService) {
SeriesNumber,
frameNumber,
Modality,
- unit,
+ unit: modalityUnit,
mean,
stdDev,
max,
area,
+ areaUnit,
});
});
@@ -146,7 +132,7 @@ function _getReport(mappedAnnotations, points, FrameOfReferenceUID) {
values.push('Cornerstone:CircleROI');
mappedAnnotations.forEach(annotation => {
- const { mean, stdDev, max, area, unit } = annotation;
+ const { mean, stdDev, max, area, unit, areaUnit } = annotation;
if (!mean || !unit || !max || !area) {
return;
@@ -156,9 +142,10 @@ function _getReport(mappedAnnotations, points, FrameOfReferenceUID) {
`max (${unit})`,
`mean (${unit})`,
`std (${unit})`,
- `area (mm2)`
+ 'Area',
+ 'Unit'
);
- values.push(max, mean, stdDev, area);
+ values.push(max, mean, stdDev, area, areaUnit);
});
if (FrameOfReferenceUID) {
@@ -188,11 +175,9 @@ function getDisplayText(mappedAnnotations, displaySet) {
const displayText = [];
// Area is the same for all series
- const { area, SOPInstanceUID, frameNumber } = mappedAnnotations[0];
+ const { area, SOPInstanceUID, frameNumber, areaUnit } = mappedAnnotations[0];
- const instance = displaySet.images.find(
- image => image.SOPInstanceUID === SOPInstanceUID
- );
+ const instance = displaySet.images.find(image => image.SOPInstanceUID === SOPInstanceUID);
let InstanceNumber;
if (instance) {
@@ -204,7 +189,7 @@ function getDisplayText(mappedAnnotations, displaySet) {
// Area sometimes becomes undefined if `preventHandleOutsideImage` is off.
const roundedArea = utils.roundNumber(area || 0, 2);
- displayText.push(`${roundedArea} mm2`);
+ displayText.push(`${roundedArea} ${areaUnit}`);
// Todo: we need a better UI for displaying all these information
mappedAnnotations.forEach(mappedAnnotation => {
diff --git a/extensions/cornerstone/src/utils/measurementServiceMappings/CobbAngle.ts b/extensions/cornerstone/src/utils/measurementServiceMappings/CobbAngle.ts
index 53dace2b40..8c78a377dc 100644
--- a/extensions/cornerstone/src/utils/measurementServiceMappings/CobbAngle.ts
+++ b/extensions/cornerstone/src/utils/measurementServiceMappings/CobbAngle.ts
@@ -3,7 +3,7 @@ import getSOPInstanceAttributes from './utils/getSOPInstanceAttributes';
import { utils } from '@ohif/core';
const CobbAngle = {
- toAnnotation: measurement => { },
+ toAnnotation: measurement => {},
/**
* Maps cornerstone annotation event data to measurement service format.
@@ -32,11 +32,7 @@ const CobbAngle = {
throw new Error('Tool not supported');
}
- const {
- SOPInstanceUID,
- SeriesInstanceUID,
- StudyInstanceUID,
- } = getSOPInstanceAttributes(
+ const { SOPInstanceUID, SeriesInstanceUID, StudyInstanceUID } = getSOPInstanceAttributes(
referencedImageId,
CornerstoneViewportService,
viewportId
@@ -55,14 +51,10 @@ const CobbAngle = {
const { points } = data.handles;
- const mappedAnnotations = getMappedAnnotations(
- annotation,
- displaySetService
- );
+ const mappedAnnotations = getMappedAnnotations(annotation, displaySetService);
const displayText = getDisplayText(mappedAnnotations, displaySet);
- const getReport = () =>
- _getReport(mappedAnnotations, points, FrameOfReferenceUID);
+ const getReport = () => _getReport(mappedAnnotations, points, FrameOfReferenceUID);
return {
uid: annotationUID,
@@ -99,16 +91,11 @@ function getMappedAnnotations(annotation, DisplaySetService) {
const targetStats = cachedStats[targetId];
if (!referencedImageId) {
- throw new Error(
- 'Non-acquisition plane measurement mapping not supported'
- );
+ throw new Error('Non-acquisition plane measurement mapping not supported');
}
- const {
- SOPInstanceUID,
- SeriesInstanceUID,
- frameNumber,
- } = getSOPInstanceAttributes(referencedImageId);
+ const { SOPInstanceUID, SeriesInstanceUID, frameNumber } =
+ getSOPInstanceAttributes(referencedImageId);
const displaySet = DisplaySetService.getDisplaySetForSOPInstanceUID(
SOPInstanceUID,
@@ -179,17 +166,9 @@ function getDisplayText(mappedAnnotations, displaySet) {
const displayText = [];
// Area is the same for all series
- const {
- angle,
- unit,
- SeriesNumber,
- SOPInstanceUID,
- frameNumber,
- } = mappedAnnotations[0];
-
- const instance = displaySet.images.find(
- image => image.SOPInstanceUID === SOPInstanceUID
- );
+ const { angle, unit, SeriesNumber, SOPInstanceUID, frameNumber } = mappedAnnotations[0];
+
+ const instance = displaySet.images.find(image => image.SOPInstanceUID === SOPInstanceUID);
let InstanceNumber;
if (instance) {
@@ -198,11 +177,11 @@ function getDisplayText(mappedAnnotations, displaySet) {
const instanceText = InstanceNumber ? ` I: ${InstanceNumber}` : '';
const frameText = displaySet.isMultiFrame ? ` F: ${frameNumber}` : '';
- if (angle === undefined) return displayText;
+ if (angle === undefined) {
+ return displayText;
+ }
const roundedAngle = utils.roundNumber(angle, 2);
- displayText.push(
- `${roundedAngle} ${unit} (S: ${SeriesNumber}${instanceText}${frameText})`
- );
+ displayText.push(`${roundedAngle} ${unit} (S: ${SeriesNumber}${instanceText}${frameText})`);
return displayText;
}
diff --git a/extensions/cornerstone/src/utils/measurementServiceMappings/EllipticalROI.ts b/extensions/cornerstone/src/utils/measurementServiceMappings/EllipticalROI.ts
index 0068426022..9bcf67d5dd 100644
--- a/extensions/cornerstone/src/utils/measurementServiceMappings/EllipticalROI.ts
+++ b/extensions/cornerstone/src/utils/measurementServiceMappings/EllipticalROI.ts
@@ -1,6 +1,5 @@
import SUPPORTED_TOOLS from './constants/supportedTools';
import getSOPInstanceAttributes from './utils/getSOPInstanceAttributes';
-import getModalityUnit from './utils/getModalityUnit';
import { utils } from '@ohif/core';
const EllipticalROI = {
@@ -26,11 +25,7 @@ const EllipticalROI = {
throw new Error('Tool not supported');
}
- const {
- SOPInstanceUID,
- SeriesInstanceUID,
- StudyInstanceUID,
- } = getSOPInstanceAttributes(
+ const { SOPInstanceUID, SeriesInstanceUID, StudyInstanceUID } = getSOPInstanceAttributes(
referencedImageId,
cornerstoneViewportService,
viewportId
@@ -49,14 +44,10 @@ const EllipticalROI = {
const { points } = data.handles;
- const mappedAnnotations = getMappedAnnotations(
- annotation,
- displaySetService
- );
+ const mappedAnnotations = getMappedAnnotations(annotation, displaySetService);
const displayText = getDisplayText(mappedAnnotations, displaySet);
- const getReport = () =>
- _getReport(mappedAnnotations, points, FrameOfReferenceUID);
+ const getReport = () => _getReport(mappedAnnotations, points, FrameOfReferenceUID);
return {
uid: annotationUID,
@@ -94,16 +85,11 @@ function getMappedAnnotations(annotation, displaySetService) {
if (!referencedImageId) {
// Todo: Non-acquisition plane measurement mapping not supported yet
- throw new Error(
- 'Non-acquisition plane measurement mapping not supported'
- );
+ throw new Error('Non-acquisition plane measurement mapping not supported');
}
- const {
- SOPInstanceUID,
- SeriesInstanceUID,
- frameNumber,
- } = getSOPInstanceAttributes(referencedImageId);
+ const { SOPInstanceUID, SeriesInstanceUID, frameNumber } =
+ getSOPInstanceAttributes(referencedImageId);
const displaySet = displaySetService.getDisplaySetForSOPInstanceUID(
SOPInstanceUID,
@@ -112,8 +98,7 @@ function getMappedAnnotations(annotation, displaySetService) {
);
const { SeriesNumber } = displaySet;
- const { mean, stdDev, max, area, Modality } = targetStats;
- const unit = getModalityUnit(Modality);
+ const { mean, stdDev, max, area, Modality, areaUnit, modalityUnit } = targetStats;
annotations.push({
SeriesInstanceUID,
@@ -121,7 +106,8 @@ function getMappedAnnotations(annotation, displaySetService) {
SeriesNumber,
frameNumber,
Modality,
- unit,
+ unit: modalityUnit,
+ areaUnit,
mean,
stdDev,
max,
@@ -146,7 +132,7 @@ function _getReport(mappedAnnotations, points, FrameOfReferenceUID) {
values.push('Cornerstone:EllipticalROI');
mappedAnnotations.forEach(annotation => {
- const { mean, stdDev, max, area, unit } = annotation;
+ const { mean, stdDev, max, area, unit, areaUnit } = annotation;
if (!mean || !unit || !max || !area) {
return;
@@ -156,9 +142,10 @@ function _getReport(mappedAnnotations, points, FrameOfReferenceUID) {
`max (${unit})`,
`mean (${unit})`,
`std (${unit})`,
- `area (mm2)`
+ 'Area',
+ 'Unit'
);
- values.push(max, mean, stdDev, area);
+ values.push(max, mean, stdDev, area, areaUnit);
});
if (FrameOfReferenceUID) {
@@ -188,11 +175,9 @@ function getDisplayText(mappedAnnotations, displaySet) {
const displayText = [];
// Area is the same for all series
- const { area, SOPInstanceUID, frameNumber } = mappedAnnotations[0];
+ const { area, SOPInstanceUID, frameNumber, areaUnit } = mappedAnnotations[0];
- const instance = displaySet.images.find(
- image => image.SOPInstanceUID === SOPInstanceUID
- );
+ const instance = displaySet.images.find(image => image.SOPInstanceUID === SOPInstanceUID);
let InstanceNumber;
if (instance) {
@@ -202,9 +187,8 @@ function getDisplayText(mappedAnnotations, displaySet) {
const instanceText = InstanceNumber ? ` I: ${InstanceNumber}` : '';
const frameText = displaySet.isMultiFrame ? ` F: ${frameNumber}` : '';
- // Area sometimes becomes undefined if `preventHandleOutsideImage` is off.
- const roundedArea = utils.roundNumber(area || 0, 2);
- displayText.push(`${roundedArea} mm2`);
+ const roundedArea = utils.roundNumber(area, 2);
+ displayText.push(`${roundedArea} ${areaUnit}`);
// Todo: we need a better UI for displaying all these information
mappedAnnotations.forEach(mappedAnnotation => {
diff --git a/extensions/cornerstone/src/utils/measurementServiceMappings/Length.ts b/extensions/cornerstone/src/utils/measurementServiceMappings/Length.ts
index 44cf64ac06..5c5072d2c1 100644
--- a/extensions/cornerstone/src/utils/measurementServiceMappings/Length.ts
+++ b/extensions/cornerstone/src/utils/measurementServiceMappings/Length.ts
@@ -32,12 +32,15 @@ const Length = {
throw new Error('Tool not supported');
}
- const { SOPInstanceUID, SeriesInstanceUID, StudyInstanceUID } =
- getSOPInstanceAttributes(
- referencedImageId,
- cornerstoneViewportService,
- viewportId
- );
+ const {
+ SOPInstanceUID,
+ SeriesInstanceUID,
+ StudyInstanceUID,
+ } = getSOPInstanceAttributes(
+ referencedImageId,
+ cornerstoneViewportService,
+ viewportId
+ );
let displaySet;
@@ -52,14 +55,10 @@ const Length = {
const { points } = data.handles;
- const mappedAnnotations = getMappedAnnotations(
- annotation,
- displaySetService
- );
+ const mappedAnnotations = getMappedAnnotations(annotation, displaySetService);
const displayText = getDisplayText(mappedAnnotations, displaySet);
- const getReport = () =>
- _getReport(mappedAnnotations, points, FrameOfReferenceUID);
+ const getReport = () => _getReport(mappedAnnotations, points, FrameOfReferenceUID);
return {
uid: annotationUID,
@@ -96,13 +95,14 @@ function getMappedAnnotations(annotation, displaySetService) {
const targetStats = cachedStats[targetId];
if (!referencedImageId) {
- throw new Error(
- 'Non-acquisition plane measurement mapping not supported'
- );
+ throw new Error('Non-acquisition plane measurement mapping not supported');
}
- const { SOPInstanceUID, SeriesInstanceUID, frameNumber } =
- getSOPInstanceAttributes(referencedImageId);
+ const {
+ SOPInstanceUID,
+ SeriesInstanceUID,
+ frameNumber,
+ } = getSOPInstanceAttributes(referencedImageId);
const displaySet = displaySetService.getDisplaySetForSOPInstanceUID(
SOPInstanceUID,
@@ -111,8 +111,7 @@ function getMappedAnnotations(annotation, displaySetService) {
);
const { SeriesNumber } = displaySet;
- const { length } = targetStats;
- const unit = 'mm';
+ const { length, unit = 'mm' } = targetStats;
annotations.push({
SeriesInstanceUID,
@@ -141,9 +140,11 @@ function _getReport(mappedAnnotations, points, FrameOfReferenceUID) {
values.push('Cornerstone:Length');
mappedAnnotations.forEach(annotation => {
- const { length } = annotation;
- columns.push(`Length (mm)`);
+ const { length, unit } = annotation;
+ columns.push(`Length`);
values.push(length);
+ columns.push('Unit');
+ values.push(unit);
});
if (FrameOfReferenceUID) {
@@ -173,12 +174,15 @@ function getDisplayText(mappedAnnotations, displaySet) {
const displayText = [];
// Area is the same for all series
- const { length, SeriesNumber, SOPInstanceUID, frameNumber } =
- mappedAnnotations[0];
+ const {
+ length,
+ SeriesNumber,
+ SOPInstanceUID,
+ frameNumber,
+ unit,
+ } = mappedAnnotations[0];
- const instance = displaySet.images.find(
- image => image.SOPInstanceUID === SOPInstanceUID
- );
+ const instance = displaySet.images.find(image => image.SOPInstanceUID === SOPInstanceUID);
let InstanceNumber;
if (instance) {
@@ -188,10 +192,12 @@ function getDisplayText(mappedAnnotations, displaySet) {
const instanceText = InstanceNumber ? ` I: ${InstanceNumber}` : '';
const frameText = displaySet.isMultiFrame ? ` F: ${frameNumber}` : '';
- if (length === null || length === undefined) return displayText;
+ if (length === null || length === undefined) {
+ return displayText;
+ }
const roundedLength = utils.roundNumber(length, 2);
displayText.push(
- `${roundedLength} mm (S: ${SeriesNumber}${instanceText}${frameText})`
+ `${roundedLength} ${unit} (S: ${SeriesNumber}${instanceText}${frameText})`
);
return displayText;
diff --git a/extensions/cornerstone/src/utils/measurementServiceMappings/PlanarFreehandROI.ts b/extensions/cornerstone/src/utils/measurementServiceMappings/PlanarFreehandROI.ts
index 71ded00c1f..b6db513b66 100644
--- a/extensions/cornerstone/src/utils/measurementServiceMappings/PlanarFreehandROI.ts
+++ b/extensions/cornerstone/src/utils/measurementServiceMappings/PlanarFreehandROI.ts
@@ -2,7 +2,7 @@ import SUPPORTED_TOOLS from './constants/supportedTools';
import getSOPInstanceAttributes from './utils/getSOPInstanceAttributes';
const PlanarFreehandROI = {
- toAnnotation: measurement => { },
+ toAnnotation: measurement => {},
/**
* Maps cornerstone annotation event data to measurement service format.
@@ -31,11 +31,7 @@ const PlanarFreehandROI = {
throw new Error('Tool not supported');
}
- const {
- SOPInstanceUID,
- SeriesInstanceUID,
- StudyInstanceUID,
- } = getSOPInstanceAttributes(
+ const { SOPInstanceUID, SeriesInstanceUID, StudyInstanceUID } = getSOPInstanceAttributes(
referencedImageId,
CornerstoneViewportService,
viewportId
@@ -54,14 +50,10 @@ const PlanarFreehandROI = {
const { points } = data.handles;
- const mappedAnnotations = getMappedAnnotations(
- annotation,
- DisplaySetService
- );
+ const mappedAnnotations = getMappedAnnotations(annotation, DisplaySetService);
const displayText = getDisplayText(mappedAnnotations);
- const getReport = () =>
- _getReport(mappedAnnotations, points, FrameOfReferenceUID);
+ const getReport = () => _getReport(mappedAnnotations, points, FrameOfReferenceUID);
return {
uid: annotationUID,
@@ -96,10 +88,8 @@ function getMappedAnnotations(annotationData, DisplaySetService) {
const annotations = [];
- const {
- SOPInstanceUID: _SOPInstanceUID,
- SeriesInstanceUID: _SeriesInstanceUID,
- } = getSOPInstanceAttributes(referencedImageId) || {};
+ const { SOPInstanceUID: _SOPInstanceUID, SeriesInstanceUID: _SeriesInstanceUID } =
+ getSOPInstanceAttributes(referencedImageId) || {};
if (!_SOPInstanceUID || !_SeriesInstanceUID) {
return annotations;
diff --git a/extensions/cornerstone/src/utils/measurementServiceMappings/RectangleROI.ts b/extensions/cornerstone/src/utils/measurementServiceMappings/RectangleROI.ts
index 01f1178b9c..567badd1d2 100644
--- a/extensions/cornerstone/src/utils/measurementServiceMappings/RectangleROI.ts
+++ b/extensions/cornerstone/src/utils/measurementServiceMappings/RectangleROI.ts
@@ -1,6 +1,5 @@
import SUPPORTED_TOOLS from './constants/supportedTools';
import getSOPInstanceAttributes from './utils/getSOPInstanceAttributes';
-import getModalityUnit from './utils/getModalityUnit';
import { utils } from '@ohif/core';
const RectangleROI = {
@@ -26,12 +25,15 @@ const RectangleROI = {
throw new Error('Tool not supported');
}
- const { SOPInstanceUID, SeriesInstanceUID, StudyInstanceUID } =
- getSOPInstanceAttributes(
- referencedImageId,
- CornerstoneViewportService,
- viewportId
- );
+ const {
+ SOPInstanceUID,
+ SeriesInstanceUID,
+ StudyInstanceUID,
+ } = getSOPInstanceAttributes(
+ referencedImageId,
+ CornerstoneViewportService,
+ viewportId
+ );
let displaySet;
@@ -46,14 +48,10 @@ const RectangleROI = {
const { points } = data.handles;
- const mappedAnnotations = getMappedAnnotations(
- annotation,
- DisplaySetService
- );
+ const mappedAnnotations = getMappedAnnotations(annotation, DisplaySetService);
const displayText = getDisplayText(mappedAnnotations, displaySet);
- const getReport = () =>
- _getReport(mappedAnnotations, points, FrameOfReferenceUID);
+ const getReport = () => _getReport(mappedAnnotations, points, FrameOfReferenceUID);
return {
uid: annotationUID,
@@ -91,13 +89,14 @@ function getMappedAnnotations(annotation, DisplaySetService) {
if (!referencedImageId) {
// Todo: Non-acquisition plane measurement mapping not supported yet
- throw new Error(
- 'Non-acquisition plane measurement mapping not supported'
- );
+ throw new Error('Non-acquisition plane measurement mapping not supported');
}
- const { SOPInstanceUID, SeriesInstanceUID, frameNumber } =
- getSOPInstanceAttributes(referencedImageId);
+ const {
+ SOPInstanceUID,
+ SeriesInstanceUID,
+ frameNumber,
+ } = getSOPInstanceAttributes(referencedImageId);
const displaySet = DisplaySetService.getDisplaySetForSOPInstanceUID(
SOPInstanceUID,
@@ -106,8 +105,7 @@ function getMappedAnnotations(annotation, DisplaySetService) {
);
const { SeriesNumber } = displaySet;
- const { mean, stdDev, max, area, Modality } = targetStats;
- const unit = getModalityUnit(Modality);
+ const { mean, stdDev, max, area, Modality, modalityUnit, areaUnit } = targetStats;
annotations.push({
SeriesInstanceUID,
@@ -115,11 +113,12 @@ function getMappedAnnotations(annotation, DisplaySetService) {
SeriesNumber,
frameNumber,
Modality,
- unit,
+ unit: modalityUnit,
mean,
stdDev,
max,
area,
+ areaUnit,
});
});
@@ -140,19 +139,14 @@ function _getReport(mappedAnnotations, points, FrameOfReferenceUID) {
values.push('Cornerstone:RectangleROI');
mappedAnnotations.forEach(annotation => {
- const { mean, stdDev, max, area, unit } = annotation;
+ const { mean, stdDev, max, area, unit, areaUnit } = annotation;
if (!mean || !unit || !max || !area) {
return;
}
- columns.push(
- `max (${unit})`,
- `mean (${unit})`,
- `std (${unit})`,
- `area (mm2)`
- );
- values.push(max, mean, stdDev, area);
+ columns.push(`Maximum`, `Mean`, `Std Dev`, 'Pixel Unit', `Area`, 'Unit');
+ values.push(max, mean, stdDev, unit, area, areaUnit);
});
if (FrameOfReferenceUID) {
@@ -182,11 +176,9 @@ function getDisplayText(mappedAnnotations, displaySet) {
const displayText = [];
// Area is the same for all series
- const { area, SOPInstanceUID, frameNumber } = mappedAnnotations[0];
+ const { area, SOPInstanceUID, frameNumber, areaUnit } = mappedAnnotations[0];
- const instance = displaySet.images.find(
- image => image.SOPInstanceUID === SOPInstanceUID
- );
+ const instance = displaySet.images.find(image => image.SOPInstanceUID === SOPInstanceUID);
let InstanceNumber;
if (instance) {
@@ -198,7 +190,7 @@ function getDisplayText(mappedAnnotations, displaySet) {
// Area sometimes becomes undefined if `preventHandleOutsideImage` is off.
const roundedArea = utils.roundNumber(area || 0, 2);
- displayText.push(`${roundedArea} mm2`);
+ displayText.push(`${roundedArea} ${areaUnit}`);
// Todo: we need a better UI for displaying all these information
mappedAnnotations.forEach(mappedAnnotation => {
diff --git a/extensions/cornerstone/src/utils/measurementServiceMappings/measurementServiceMappingsFactory.ts b/extensions/cornerstone/src/utils/measurementServiceMappings/measurementServiceMappingsFactory.ts
index 2a4562e7db..e3ccf4e51e 100644
--- a/extensions/cornerstone/src/utils/measurementServiceMappings/measurementServiceMappingsFactory.ts
+++ b/extensions/cornerstone/src/utils/measurementServiceMappings/measurementServiceMappingsFactory.ts
@@ -23,15 +23,8 @@ const measurementServiceMappingsFactory = (
*/
const _getValueTypeFromToolType = toolType => {
- const {
- POLYLINE,
- ELLIPSE,
- CIRCLE,
- RECTANGLE,
- BIDIRECTIONAL,
- POINT,
- ANGLE,
- } = MeasurementService.VALUE_TYPES;
+ const { POLYLINE, ELLIPSE, CIRCLE, RECTANGLE, BIDIRECTIONAL, POINT, ANGLE } =
+ MeasurementService.VALUE_TYPES;
// TODO -> I get why this was attempted, but its not nearly flexible enough.
// A single measurement may have an ellipse + a bidirectional measurement, for instances.
diff --git a/extensions/cornerstone/src/utils/measurementServiceMappings/utils/getModalityUnit.js b/extensions/cornerstone/src/utils/measurementServiceMappings/utils/getModalityUnit.js
deleted file mode 100644
index 7cc005e419..0000000000
--- a/extensions/cornerstone/src/utils/measurementServiceMappings/utils/getModalityUnit.js
+++ /dev/null
@@ -1,11 +0,0 @@
-function getModalityUnit(modality) {
- if (modality === 'CT') {
- return 'HU';
- } else if (modality === 'PT') {
- return 'SUV';
- } else {
- return '';
- }
-}
-
-export default getModalityUnit;
diff --git a/extensions/cornerstone/src/utils/measurementServiceMappings/utils/index.ts b/extensions/cornerstone/src/utils/measurementServiceMappings/utils/index.ts
index c313921964..e7cd75f714 100644
--- a/extensions/cornerstone/src/utils/measurementServiceMappings/utils/index.ts
+++ b/extensions/cornerstone/src/utils/measurementServiceMappings/utils/index.ts
@@ -4,11 +4,9 @@ import {
setAnnotationSelected,
getFirstAnnotationSelected,
} from './selection';
-import getModalityUnit from './getModalityUnit';
import getSOPInstanceAttributes from './getSOPInstanceAttributes';
export {
- getModalityUnit,
getHandlesFromPoints,
getSOPInstanceAttributes,
isAnnotationSelected,
diff --git a/extensions/cornerstone/src/utils/measurementServiceMappings/utils/selection.ts b/extensions/cornerstone/src/utils/measurementServiceMappings/utils/selection.ts
index 156133306d..1de09d9426 100644
--- a/extensions/cornerstone/src/utils/measurementServiceMappings/utils/selection.ts
+++ b/extensions/cornerstone/src/utils/measurementServiceMappings/utils/selection.ts
@@ -18,24 +18,16 @@ function setAnnotationSelected(annotationUID: string, selected: boolean): void {
const isCurrentSelected = isAnnotationSelected(annotationUID);
// branch cut, avoid invoking imaging library unnecessarily.
if (isCurrentSelected !== selected) {
- cs3dToolAnnotationUtils.selection.setAnnotationSelected(
- annotationUID,
- selected
- );
+ cs3dToolAnnotationUtils.selection.setAnnotationSelected(annotationUID, selected);
}
}
function getFirstAnnotationSelected(element) {
- const [selectedAnnotationUID] =
- cs3dToolAnnotationUtils.selection.getAnnotationsSelected() || [];
+ const [selectedAnnotationUID] = cs3dToolAnnotationUtils.selection.getAnnotationsSelected() || [];
if (selectedAnnotationUID) {
return cs3dToolAnnotationUtils.state.getAnnotation(selectedAnnotationUID);
}
}
-export {
- isAnnotationSelected,
- setAnnotationSelected,
- getFirstAnnotationSelected,
-};
+export { isAnnotationSelected, setAnnotationSelected, getFirstAnnotationSelected };
diff --git a/extensions/cornerstone/src/utils/nthLoader.ts b/extensions/cornerstone/src/utils/nthLoader.ts
index bce0d22f5f..90aab65a8b 100644
--- a/extensions/cornerstone/src/utils/nthLoader.ts
+++ b/extensions/cornerstone/src/utils/nthLoader.ts
@@ -51,9 +51,7 @@ export default function interleaveNthLoader({
.map(volume => volume.getImageLoadRequests())
.filter(requests => requests?.[0]?.imageId);
- const orderedRequests = originalRequests.map(request =>
- getNthFrames(request)
- );
+ const orderedRequests = originalRequests.map(request => getNthFrames(request));
// set the finalRequests to the imageLoadPoolManager
const finalRequests = interleave(orderedRequests);
@@ -61,31 +59,17 @@ export default function interleaveNthLoader({
const requestType = Enums.RequestType.Prefetch;
const priority = 0;
- finalRequests.forEach(
- ({ callLoadImage, additionalDetails, imageId, imageIdIndex, options }) => {
- const callLoadImageBound = callLoadImage.bind(
- null,
- imageId,
- imageIdIndex,
- options
- );
-
- imageLoadPoolManager.addRequest(
- callLoadImageBound,
- requestType,
- additionalDetails,
- priority
- );
- }
- );
+ finalRequests.forEach(({ callLoadImage, additionalDetails, imageId, imageIdIndex, options }) => {
+ const callLoadImageBound = callLoadImage.bind(null, imageId, imageIdIndex, options);
+
+ imageLoadPoolManager.addRequest(callLoadImageBound, requestType, additionalDetails, priority);
+ });
// clear the volumeIdMapsToLoad
volumeIdMapsToLoad.clear();
// copy the viewportIdVolumeInputArrayMap
- const viewportIdVolumeInputArrayMapCopy = new Map(
- viewportIdVolumeInputArrayMap
- );
+ const viewportIdVolumeInputArrayMapCopy = new Map(viewportIdVolumeInputArrayMap);
// reset the viewportIdVolumeInputArrayMap
viewportIdVolumeInputArrayMap.clear();
diff --git a/extensions/cornerstone/src/utils/removeToolGroupSegmentationRepresentations.ts b/extensions/cornerstone/src/utils/removeToolGroupSegmentationRepresentations.ts
index 513321b32f..b0f3e57968 100644
--- a/extensions/cornerstone/src/utils/removeToolGroupSegmentationRepresentations.ts
+++ b/extensions/cornerstone/src/utils/removeToolGroupSegmentationRepresentations.ts
@@ -1,9 +1,7 @@
import { segmentation } from '@cornerstonejs/tools';
function removeToolGroupSegmentationRepresentations(toolGroupId) {
- const representations = segmentation.state.getSegmentationRepresentations(
- toolGroupId
- );
+ const representations = segmentation.state.getSegmentationRepresentations(toolGroupId);
if (!representations || !representations.length) {
return;
diff --git a/extensions/cornerstone/src/utils/stackSync/calculateViewportRegistrations.ts b/extensions/cornerstone/src/utils/stackSync/calculateViewportRegistrations.ts
index cbb976534b..aae2882b05 100644
--- a/extensions/cornerstone/src/utils/stackSync/calculateViewportRegistrations.ts
+++ b/extensions/cornerstone/src/utils/stackSync/calculateViewportRegistrations.ts
@@ -1,8 +1,6 @@
import { Types, getRenderingEngine, utilities } from '@cornerstonejs/core';
-export default function calculateViewportRegistrations(
- viewports: Types.IViewportId[]
-) {
+export default function calculateViewportRegistrations(viewports: Types.IViewportId[]) {
const viewportPairs = _getViewportPairs(viewports);
for (const [viewport, nextViewport] of viewportPairs) {
diff --git a/extensions/cornerstone/src/utils/stackSync/toggleStackImageSync.ts b/extensions/cornerstone/src/utils/stackSync/toggleStackImageSync.ts
index 5a0de4677f..5e18b6ba4f 100644
--- a/extensions/cornerstone/src/utils/stackSync/toggleStackImageSync.ts
+++ b/extensions/cornerstone/src/utils/stackSync/toggleStackImageSync.ts
@@ -2,32 +2,20 @@ import calculateViewportRegistrations from './calculateViewportRegistrations';
// [ {
// synchronizerId: string,
-// viewports: [ { viewportId: number, renderingEngineId: string, index: number } , ...]
+// viewports: [ { viewportId: string, renderingEngineId: string, index: number } , ...]
// ]}
let STACK_IMAGE_SYNC_GROUPS_INFO = [];
-export default function toggleStackImageSync({
- toggledState,
- servicesManager,
- getEnabledElement,
-}) {
- const {
- syncGroupService,
- viewportGridService,
- displaySetService,
- cornerstoneViewportService,
- } = servicesManager.services;
+export default function toggleStackImageSync({ toggledState, servicesManager, getEnabledElement }) {
+ const { syncGroupService, viewportGridService, displaySetService, cornerstoneViewportService } =
+ servicesManager.services;
if (!toggledState) {
STACK_IMAGE_SYNC_GROUPS_INFO.forEach(syncGroupInfo => {
const { viewports, synchronizerId } = syncGroupInfo;
viewports.forEach(({ viewportId, renderingEngineId }) => {
- syncGroupService.removeViewportFromSyncGroup(
- viewportId,
- renderingEngineId,
- synchronizerId
- );
+ syncGroupService.removeViewportFromSyncGroup(viewportId, renderingEngineId, synchronizerId);
});
});
@@ -37,32 +25,23 @@ export default function toggleStackImageSync({
STACK_IMAGE_SYNC_GROUPS_INFO = [];
// create synchronization groups and add viewports
- let { viewports } = viewportGridService.getState();
+ const { viewports } = viewportGridService.getState();
// filter empty viewports
- viewports = viewports.filter(
- viewport =>
- viewport.displaySetInstanceUIDs && viewport.displaySetInstanceUIDs.length
- );
-
- // filter reconstructable viewports
- viewports = viewports.filter(viewport => {
- const { displaySetInstanceUIDs } = viewport;
-
- for (const displaySetInstanceUID of displaySetInstanceUIDs) {
- const displaySet = displaySetService.getDisplaySetByUID(
- displaySetInstanceUID
- );
-
- if (displaySet && displaySet.isReconstructable) {
- return true;
- }
+ const viewportsArray = Array.from(viewports.values())
+ .filter(viewport => viewport.displaySetInstanceUIDs?.length)
+ // filter reconstructable viewports
+ .filter(viewport => {
+ const { displaySetInstanceUIDs } = viewport;
- return false;
- }
- });
+ for (const displaySetInstanceUID of displaySetInstanceUIDs) {
+ const displaySet = displaySetService.getDisplaySetByUID(displaySetInstanceUID);
+
+ return !!displaySet?.isReconstructable;
+ }
+ });
- const viewportsByOrientation = viewports.reduce((acc, viewport) => {
+ const viewportsByOrientation = viewportsArray.reduce((acc, viewport) => {
const { viewportId, viewportType } = viewport.viewportOptions;
if (viewportType !== 'stack') {
@@ -71,9 +50,7 @@ export default function toggleStackImageSync({
}
const { element } = cornerstoneViewportService.getViewportInfo(viewportId);
- const { viewport: csViewport, renderingEngineId } = getEnabledElement(
- element
- );
+ const { viewport: csViewport, renderingEngineId } = getEnabledElement(element);
const { viewPlaneNormal } = csViewport.getCamera();
// Should we round here? I guess so, but not sure how much precision we need
@@ -90,9 +67,7 @@ export default function toggleStackImageSync({
// create synchronizer for each group
Object.values(viewportsByOrientation).map(viewports => {
- let synchronizerId = viewports
- .map(({ viewportId }) => viewportId)
- .join(',');
+ let synchronizerId = viewports.map(({ viewportId }) => viewportId).join(',');
synchronizerId = `imageSync_${synchronizerId}`;
diff --git a/extensions/default/.webpack/webpack.dev.js b/extensions/default/.webpack/webpack.dev.js
index 96d68096d9..6aea859ca7 100644
--- a/extensions/default/.webpack/webpack.dev.js
+++ b/extensions/default/.webpack/webpack.dev.js
@@ -7,7 +7,6 @@ const ENTRY = {
app: `${SRC_DIR}/index.tsx`,
};
-
module.exports = (env, argv) => {
return webpackCommon(env, argv, { SRC_DIR, DIST_DIR, ENTRY });
};
diff --git a/extensions/default/.webpack/webpack.prod.js b/extensions/default/.webpack/webpack.prod.js
index ea7b2e5bb0..1151efc8b2 100644
--- a/extensions/default/.webpack/webpack.prod.js
+++ b/extensions/default/.webpack/webpack.prod.js
@@ -40,13 +40,7 @@ module.exports = (env, argv) => {
libraryTarget: 'umd',
filename: pkg.main,
},
- externals: [
- /\b(vtk.js)/,
- /\b(dcmjs)/,
- /\b(gl-matrix)/,
- /^@ohif/,
- /^@cornerstonejs/,
- ],
+ externals: [/\b(vtk.js)/, /\b(dcmjs)/, /\b(gl-matrix)/, /^@ohif/, /^@cornerstonejs/],
plugins: [
new webpack.optimize.LimitChunkCountPlugin({
maxChunks: 1,
diff --git a/extensions/default/CHANGELOG.md b/extensions/default/CHANGELOG.md
new file mode 100644
index 0000000000..c7a7a48541
--- /dev/null
+++ b/extensions/default/CHANGELOG.md
@@ -0,0 +1,263 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+# [3.7.0-beta.85](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.84...v3.7.0-beta.85) (2023-09-26)
+
+
+### Bug Fixes
+
+* **toggleOneUp:** fixed one up for main tmtv layout ([#3677](https://github.com/OHIF/Viewers/issues/3677)) ([86f54d0](https://github.com/OHIF/Viewers/commit/86f54d0d07042750a863ae876aa8dd5fb16029a5))
+
+
+
+
+
+# [3.7.0-beta.84](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.83...v3.7.0-beta.84) (2023-09-26)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.83](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.82...v3.7.0-beta.83) (2023-09-26)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.82](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.81...v3.7.0-beta.82) (2023-09-26)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.81](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.80...v3.7.0-beta.81) (2023-09-26)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.80](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.79...v3.7.0-beta.80) (2023-09-22)
+
+
+### Features
+
+* **segmentation mode:** Add create, and export SEG with Brushes ([#3632](https://github.com/OHIF/Viewers/issues/3632)) ([48bbd62](https://github.com/OHIF/Viewers/commit/48bbd6281a497ea68670239f5426a10ee6c56dc1))
+* **SidePanel:** new side panel tab look-and-feel ([#3657](https://github.com/OHIF/Viewers/issues/3657)) ([85c899b](https://github.com/OHIF/Viewers/commit/85c899b399e2521480724be145538993721b9378))
+
+
+
+
+
+# [3.7.0-beta.79](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.78...v3.7.0-beta.79) (2023-09-22)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.78](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.77...v3.7.0-beta.78) (2023-09-21)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.77](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.76...v3.7.0-beta.77) (2023-09-21)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.76](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.75...v3.7.0-beta.76) (2023-09-19)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.75](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.74...v3.7.0-beta.75) (2023-09-18)
+
+
+### Bug Fixes
+
+* **DicomJson:** retrieve.series.metadata method should be async ([#3659](https://github.com/OHIF/Viewers/issues/3659)) ([2737903](https://github.com/OHIF/Viewers/commit/2737903386cf97399473e0fa64fe53ad14da155a))
+
+
+
+
+
+# [3.7.0-beta.74](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.73...v3.7.0-beta.74) (2023-09-15)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.73](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.72...v3.7.0-beta.73) (2023-09-12)
+
+
+### Bug Fixes
+
+* **health imaging:** studies not loading from healthimaging if imagepositionpatient is missing ([#3646](https://github.com/OHIF/Viewers/issues/3646)) ([74e62a1](https://github.com/OHIF/Viewers/commit/74e62a176374f720080d4e777972f70e7f2d8b2b))
+
+
+
+
+
+# [3.7.0-beta.72](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.71...v3.7.0-beta.72) (2023-09-12)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.71](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.70...v3.7.0-beta.71) (2023-09-12)
+
+
+### Bug Fixes
+
+* **suv:** import calculate-suv library version that prevents SUV calculation for a zero PatientWeight ([#3638](https://github.com/OHIF/Viewers/issues/3638)) ([0d10f46](https://github.com/OHIF/Viewers/commit/0d10f46b885fe54ec3dae1848134da658eb6280a))
+
+
+
+
+
+# [3.7.0-beta.70](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.69...v3.7.0-beta.70) (2023-09-12)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.69](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.68...v3.7.0-beta.69) (2023-09-11)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.68](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.67...v3.7.0-beta.68) (2023-09-11)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.67](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.66...v3.7.0-beta.67) (2023-09-06)
+
+
+### Bug Fixes
+
+* **hotkeys:** preserve hotkeys if changed, and reduce re-rendering ([#3635](https://github.com/OHIF/Viewers/issues/3635)) ([94f7cfb](https://github.com/OHIF/Viewers/commit/94f7cfb08e3490488394efc42ef089ebe55e86be))
+
+
+
+
+
+# [3.7.0-beta.66](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.65...v3.7.0-beta.66) (2023-09-06)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.65](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.64...v3.7.0-beta.65) (2023-09-06)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.64](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.63...v3.7.0-beta.64) (2023-09-05)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.63](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.62...v3.7.0-beta.63) (2023-09-01)
+
+
+### Features
+
+* **grid:** remove viewportIndex and only rely on viewportId ([#3591](https://github.com/OHIF/Viewers/issues/3591)) ([4c6ff87](https://github.com/OHIF/Viewers/commit/4c6ff873e887cc30ffc09223f5cb99e5f94c9cdd))
+
+
+
+
+
+# [3.7.0-beta.62](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.61...v3.7.0-beta.62) (2023-08-30)
+
+
+### Features
+
+* **data source UI config:** Popup the configuration dialogue whenever a data source is not fully configured ([#3620](https://github.com/OHIF/Viewers/issues/3620)) ([adedc8c](https://github.com/OHIF/Viewers/commit/adedc8c382e18a2e86a569e3d023cc55a157363f))
+
+
+
+
+
+# [3.7.0-beta.61](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.60...v3.7.0-beta.61) (2023-08-29)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.60](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.59...v3.7.0-beta.60) (2023-08-29)
+
+
+### Bug Fixes
+
+* **PT Metadata:** Allow for PatientWeight to be missing from the metadata ([#3621](https://github.com/OHIF/Viewers/issues/3621)) ([44f101d](https://github.com/OHIF/Viewers/commit/44f101d3f2b3204b67e31f4e4939062e65a246ee))
+
+
+
+
+
+# [3.7.0-beta.59](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.58...v3.7.0-beta.59) (2023-08-29)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.58](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.57...v3.7.0-beta.58) (2023-08-25)
+
+
+### Features
+
+* **cloud data source config:** GUI and API for configuring a cloud data source with Google cloud healthcare implementation ([#3589](https://github.com/OHIF/Viewers/issues/3589)) ([a336992](https://github.com/OHIF/Viewers/commit/a336992971c07552c9dbb6e1de43169d37762ef1))
+
+
+
+
+
+# [3.7.0-beta.57](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.56...v3.7.0-beta.57) (2023-08-23)
+
+**Note:** Version bump only for package @ohif/extension-default
diff --git a/extensions/default/package.json b/extensions/default/package.json
index 0dbddf6c75..5d9aa6f011 100644
--- a/extensions/default/package.json
+++ b/extensions/default/package.json
@@ -1,6 +1,6 @@
{
"name": "@ohif/extension-default",
- "version": "3.6.0",
+ "version": "3.7.0-beta.85",
"description": "Common/default features and functionality for basic image viewing",
"author": "OHIF Core Team",
"license": "MIT",
@@ -30,8 +30,8 @@
"start": "yarn run dev"
},
"peerDependencies": {
- "@ohif/core": "3.6.0",
- "@ohif/i18n": "3.6.0",
+ "@ohif/core": "3.7.0-beta.85",
+ "@ohif/i18n": "3.7.0-beta.85",
"dcmjs": "^0.29.5",
"dicomweb-client": "^0.10.2",
"prop-types": "^15.6.2",
@@ -44,6 +44,6 @@
},
"dependencies": {
"@babel/runtime": "^7.20.13",
- "@cornerstonejs/calculate-suv": "^1.0.3"
+ "@cornerstonejs/calculate-suv": "^1.1.0"
}
}
diff --git a/extensions/default/src/Actions/createReportAsync.tsx b/extensions/default/src/Actions/createReportAsync.tsx
index 98080288b0..d0f34a48a2 100644
--- a/extensions/default/src/Actions/createReportAsync.tsx
+++ b/extensions/default/src/Actions/createReportAsync.tsx
@@ -4,53 +4,31 @@ import { DicomMetadataStore } from '@ohif/core';
/**
*
* @param {*} servicesManager
- * @param {*} dataSource
- * @param {*} measurements
- * @param {*} options
- * @returns {string[]} displaySetInstanceUIDs
*/
-async function createReportAsync(
- servicesManager,
- commandsManager,
- dataSource,
- measurements,
- options
-) {
- const {
- displaySetService,
- uiNotificationService,
- uiDialogService,
- } = servicesManager.services;
+async function createReportAsync({ servicesManager, getReport, reportType = 'measurement' }) {
+ const { displaySetService, uiNotificationService, uiDialogService } = servicesManager.services;
const loadingDialogId = uiDialogService.create({
showOverlay: true,
isDraggable: false,
centralize: true,
- // TODO: Create a loading indicator component + zeplin design?
content: Loading,
});
try {
- const naturalizedReport = await commandsManager.runCommand(
- 'storeMeasurements',
- {
- measurementData: measurements,
- dataSource,
- additionalFindingTypes: ['ArrowAnnotate'],
- options,
- },
- 'CORNERSTONE_STRUCTURED_REPORT'
- );
+ const naturalizedReport = await getReport();
// The "Mode" route listens for DicomMetadataStore changes
// When a new instance is added, it listens and
// automatically calls makeDisplaySets
DicomMetadataStore.addInstances([naturalizedReport], true);
- const displaySetInstanceUID = displaySetService.getMostRecentDisplaySet();
+ const displaySet = displaySetService.getMostRecentDisplaySet();
+
+ const displaySetInstanceUID = displaySet.displaySetInstanceUID;
uiNotificationService.show({
title: 'Create Report',
- message: 'Measurements saved successfully',
+ message: `${reportType} saved successfully`,
type: 'success',
});
@@ -58,7 +36,7 @@ async function createReportAsync(
} catch (error) {
uiNotificationService.show({
title: 'Create Report',
- message: error.message || 'Failed to store measurements',
+ message: error.message || `Failed to store ${reportType}`,
type: 'error',
});
} finally {
diff --git a/extensions/default/src/Components/DataSourceConfigurationComponent.tsx b/extensions/default/src/Components/DataSourceConfigurationComponent.tsx
new file mode 100644
index 0000000000..97896a92c7
--- /dev/null
+++ b/extensions/default/src/Components/DataSourceConfigurationComponent.tsx
@@ -0,0 +1,121 @@
+import React, { ReactElement, useCallback, useEffect, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Icon, useModal } from '@ohif/ui';
+import { ExtensionManager, ServicesManager, Types } from '@ohif/core';
+import DataSourceConfigurationModalComponent from './DataSourceConfigurationModalComponent';
+
+type DataSourceConfigurationComponentProps = {
+ servicesManager: ServicesManager;
+ extensionManager: ExtensionManager;
+};
+
+function DataSourceConfigurationComponent({
+ servicesManager,
+ extensionManager,
+}: DataSourceConfigurationComponentProps): ReactElement {
+ const { t } = useTranslation('DataSourceConfiguration');
+ const { show, hide } = useModal();
+
+ const { customizationService } = servicesManager.services;
+
+ const [configurationAPI, setConfigurationAPI] = useState();
+
+ const [configuredItems, setConfiguredItems] =
+ useState>();
+
+ useEffect(() => {
+ let shouldUpdate = true;
+
+ const dataSourceChangedCallback = async () => {
+ const activeDataSourceDef = extensionManager.getActiveDataSourceDefinition();
+
+ if (!activeDataSourceDef.configuration.configurationAPI) {
+ return;
+ }
+
+ const { factory: configurationAPIFactory } =
+ customizationService.get(activeDataSourceDef.configuration.configurationAPI) ?? {};
+
+ if (!configurationAPIFactory) {
+ return;
+ }
+
+ const configAPI = configurationAPIFactory(activeDataSourceDef.sourceName);
+ setConfigurationAPI(configAPI);
+
+ // New configuration API means that the existing configured items must be cleared.
+ setConfiguredItems(null);
+
+ configAPI.getConfiguredItems().then(list => {
+ if (shouldUpdate) {
+ setConfiguredItems(list);
+ }
+ });
+ };
+
+ const sub = extensionManager.subscribe(
+ extensionManager.EVENTS.ACTIVE_DATA_SOURCE_CHANGED,
+ dataSourceChangedCallback
+ );
+
+ dataSourceChangedCallback();
+
+ return () => {
+ shouldUpdate = false;
+ sub.unsubscribe();
+ };
+ }, []);
+
+ const showConfigurationModal = useCallback(() => {
+ show({
+ content: DataSourceConfigurationModalComponent,
+ title: t('Configure Data Source'),
+ contentProps: {
+ configurationAPI,
+ configuredItems,
+ onHide: hide,
+ },
+ });
+ }, [configurationAPI, configuredItems]);
+
+ useEffect(() => {
+ if (!configurationAPI || !configuredItems) {
+ return;
+ }
+
+ if (configuredItems.length !== configurationAPI.getItemLabels().length) {
+ // Not the correct number of configured items, so show the modal to configure the data source.
+ showConfigurationModal();
+ }
+ }, [configurationAPI, configuredItems, showConfigurationModal]);
+
+ return configuredItems ? (
+ ;
+ onHide: () => void;
+};
+
+function DataSourceConfigurationModalComponent({
+ configurationAPI,
+ configuredItems,
+ onHide,
+}: DataSourceConfigurationModalComponentProps) {
+ const { t } = useTranslation('DataSourceConfiguration');
+
+ const [itemList, setItemList] = useState>();
+
+ const [selectedItems, setSelectedItems] = useState(configuredItems);
+
+ const [errorMessage, setErrorMessage] = useState();
+
+ const [itemLabels] = useState(configurationAPI.getItemLabels());
+
+ // Determines whether to show the full/existing configuration for the data source.
+ // A full or complete configuration is one where the data source (path) has the
+ // maximum/required number of path items. Anything less is considered not complete and
+ // the configuration starts from scratch (i.e. as if no items are configured at all).
+ // TODO: consider configuration starting from a partial (i.e. non-empty) configuration
+ const [showFullConfig, setShowFullConfig] = useState(
+ itemLabels.length === configuredItems.length
+ );
+
+ /**
+ * The index of the selected item that is considered current and for which
+ * its sub-items should be displayed in the items list component. When the
+ * full/existing configuration for a data source is to be shown, the current
+ * selected item is the second to last in the `selectedItems` list.
+ */
+ const currentSelectedItemIndex = showFullConfig
+ ? selectedItems.length - 2
+ : selectedItems.length - 1;
+
+ useEffect(() => {
+ let shouldUpdate = true;
+
+ setErrorMessage(null);
+
+ // Clear out the former/old list while we fetch the next sub item list.
+ setItemList(null);
+
+ if (selectedItems.length === 0) {
+ configurationAPI
+ .initialize()
+ .then(items => {
+ if (shouldUpdate) {
+ setItemList(items);
+ }
+ })
+ .catch(error => setErrorMessage(error.message));
+ } else if (!showFullConfig && selectedItems.length === itemLabels.length) {
+ // The last item to configure the data source (path) has been selected.
+ configurationAPI.setCurrentItem(selectedItems[selectedItems.length - 1]);
+ // We can hide the modal dialog now.
+ onHide();
+ } else {
+ configurationAPI
+ .setCurrentItem(selectedItems[currentSelectedItemIndex])
+ .then(items => {
+ if (shouldUpdate) {
+ setItemList(items);
+ }
+ })
+ .catch(error => setErrorMessage(error.message));
+ }
+
+ return () => {
+ shouldUpdate = false;
+ };
+ }, [
+ selectedItems,
+ configurationAPI,
+ onHide,
+ itemLabels,
+ showFullConfig,
+ currentSelectedItemIndex,
+ ]);
+
+ const getSelectedItemCursorClasses = itemIndex =>
+ itemIndex !== itemLabels.length - 1 && itemIndex < selectedItems.length
+ ? 'cursor-pointer'
+ : 'cursor-auto';
+
+ const getSelectedItemBackgroundClasses = itemIndex =>
+ itemIndex < selectedItems.length
+ ? classNames(
+ 'bg-black/[.4]',
+ itemIndex !== itemLabels.length - 1 ? 'hover:bg-transparent active:bg-secondary-dark' : ''
+ )
+ : 'bg-transparent';
+
+ const getSelectedItemBorderClasses = itemIndex =>
+ itemIndex === currentSelectedItemIndex + 1
+ ? classNames('border-2', 'border-solid', 'border-primary-light')
+ : itemIndex < selectedItems.length
+ ? 'border border-solid border-primary-active hover:border-primary-light active:border-white'
+ : 'border border-dashed border-secondary-light';
+
+ const getSelectedItemTextClasses = itemIndex =>
+ itemIndex <= selectedItems.length ? 'text-primary-light' : 'text-primary-active';
+
+ const getErrorComponent = (): ReactElement => {
+ return (
+ ;
+ onItemClicked: (item: Types.BaseDataSourceConfigurationAPIItem) => void;
+};
+
+function ItemListComponent({
+ itemLabel,
+ itemList,
+ onItemClicked,
+}: ItemListComponentProps): ReactElement {
+ const { t } = useTranslation('DataSourceConfiguration');
+ const [filterValue, setFilterValue] = useState('');
+
+ useEffect(() => {
+ setFilterValue('');
+ }, [itemList]);
+
+ return (
+ {
+ setHasBeenOpened(true);
+ }}
+ >
+ );
+};
+
+export default SidePanelWithServices;
diff --git a/extensions/default/src/CustomizableContextMenu/ContextMenuController.tsx b/extensions/default/src/CustomizableContextMenu/ContextMenuController.tsx
index 82879bf02a..9d65b971d8 100644
--- a/extensions/default/src/CustomizableContextMenu/ContextMenuController.tsx
+++ b/extensions/default/src/CustomizableContextMenu/ContextMenuController.tsx
@@ -19,10 +19,7 @@ export default class ContextMenuController {
services: Types.Services;
menuItems: Menu[] | MenuItem[];
- constructor(
- servicesManager: ServicesManager,
- commandsManager: CommandsManager
- ) {
+ constructor(servicesManager: ServicesManager, commandsManager: CommandsManager) {
this.services = servicesManager.services as Obj;
this.commandsManager = commandsManager;
}
@@ -72,10 +69,9 @@ export default class ContextMenuController {
event,
content: ContextMenu,
- // This naming is part of hte uiDialogService convention
- // Clicking outside simpy closes the dialog box.
- onClickOutside: () =>
- this.services.uiDialogService.dismiss({ id: 'context-menu' }),
+ // This naming is part of the uiDialogService convention
+ // Clicking outside simply closes the dialog box.
+ onClickOutside: () => this.services.uiDialogService.dismiss({ id: 'context-menu' }),
contentProps: {
items,
@@ -170,9 +166,7 @@ export default class ContextMenuController {
};
static _isValidPosition = (source): boolean => {
- return (
- source && typeof source.x === 'number' && typeof source.y === 'number'
- );
+ return source && typeof source.x === 'number' && typeof source.y === 'number';
};
/**
@@ -180,10 +174,7 @@ export default class ContextMenuController {
*/
static _getDefaultPosition = (canvasPoints, eventDetail, viewerElement) => {
function* getPositionIterator() {
- yield ContextMenuController._getCanvasPointsPosition(
- canvasPoints,
- viewerElement
- );
+ yield ContextMenuController._getCanvasPointsPosition(canvasPoints, viewerElement);
yield ContextMenuController._getEventDefaultPosition(eventDetail);
yield ContextMenuController._getElementDefaultPosition(viewerElement);
yield ContextMenuController.getDefaultPosition();
diff --git a/extensions/default/src/CustomizableContextMenu/ContextMenuItemsBuilder.test.js b/extensions/default/src/CustomizableContextMenu/ContextMenuItemsBuilder.test.js
index b5555f71f1..00ee469dd5 100644
--- a/extensions/default/src/CustomizableContextMenu/ContextMenuItemsBuilder.test.js
+++ b/extensions/default/src/CustomizableContextMenu/ContextMenuItemsBuilder.test.js
@@ -1,4 +1,4 @@
-import ContextMenuItemsBuilder from "./ContextMenuItemsBuilder";
+import ContextMenuItemsBuilder from './ContextMenuItemsBuilder';
const menus = [
{
diff --git a/extensions/default/src/CustomizableContextMenu/ContextMenuItemsBuilder.ts b/extensions/default/src/CustomizableContextMenu/ContextMenuItemsBuilder.ts
index 2fe20e8d96..8b8b985326 100644
--- a/extensions/default/src/CustomizableContextMenu/ContextMenuItemsBuilder.ts
+++ b/extensions/default/src/CustomizableContextMenu/ContextMenuItemsBuilder.ts
@@ -31,16 +31,11 @@ export function findMenuById(menus: Menu[], menuId?: string): Menu {
* @param {*} subProps
* @returns
*/
-export function findMenuDefault(
- menus: Menu[],
- subProps: Record
-): Menu {
+export function findMenuDefault(menus: Menu[], subProps: Record): Menu {
if (!menus) {
return null;
}
- return menus.find(
- menu => !menu.selector || menu.selector(subProps.selectorProps)
- );
+ return menus.find(menu => !menu.selector || menu.selector(subProps.selectorProps));
}
/**
@@ -53,11 +48,7 @@ export function findMenuDefault(
* @param menuIdFilter - menu id identifier (to be considered on selection)
* This is intended to support other types of filtering in the future.
*/
-export function findMenu(
- menus: Menu[],
- props?: Types.IProps,
- menuIdFilter?: string
-) {
+export function findMenu(menus: Menu[], props?: Types.IProps, menuIdFilter?: string) {
const { subMenu } = props;
function* findMenuIterator() {
@@ -137,10 +128,7 @@ export function getMenuItems(
if (!selector || selector(selectorProps)) {
if (delegating) {
- menuItems = [
- ...menuItems,
- ...getMenuItems(selectorProps, event, menus, subMenu),
- ];
+ menuItems = [...menuItems, ...getMenuItems(selectorProps, event, menus, subMenu)];
} else {
const toAdd = adaptItem(item, subProps);
menuItems.push(toAdd);
@@ -161,10 +149,7 @@ export function getMenuItems(
* @returns a MenuItem that is compatible with the base ContextMenu
* This requires having a label and set of actions to be called.
*/
-export function adaptItem(
- item: MenuItem,
- subProps: ContextMenuProps
-): ContextMenuItem {
+export function adaptItem(item: MenuItem, subProps: ContextMenuProps): ContextMenuItem {
const newItem: ContextMenuItem = {
...item,
value: subProps.selectorProps?.value,
diff --git a/extensions/default/src/CustomizableContextMenu/types.ts b/extensions/default/src/CustomizableContextMenu/types.ts
index 23075d0578..c251fd33d7 100644
--- a/extensions/default/src/CustomizableContextMenu/types.ts
+++ b/extensions/default/src/CustomizableContextMenu/types.ts
@@ -5,7 +5,7 @@ import { Types } from '@ohif/core';
* menu item for display.
* An instance of SelectorProps is provided to the selector functions, which
* return true to include the item or false to exclude it.
- * The point of this is to allow more specific conext menus which hide
+ * The point of this is to allow more specific context menus which hide
* non-relevant menu options, optimizing the speed of selection of menus
*/
export interface SelectorProps {
@@ -69,7 +69,7 @@ export interface MenuItem {
// or more importantly, if the delegating subMenu will be included.
selector?: (props: SelectorProps) => boolean;
- /** Adapts the item by filling in additional properties as requried */
+ /** Adapts the item by filling in additional properties as required */
adaptItem?: (item: MenuItem, props: ContextMenuProps) => UIMenuItem;
/** List of commands to run when this item's action is taken. */
diff --git a/extensions/default/src/DataSourceConfigurationAPI/GoogleCloudDataSourceConfigurationAPI.ts b/extensions/default/src/DataSourceConfigurationAPI/GoogleCloudDataSourceConfigurationAPI.ts
new file mode 100644
index 0000000000..4e02cafae9
--- /dev/null
+++ b/extensions/default/src/DataSourceConfigurationAPI/GoogleCloudDataSourceConfigurationAPI.ts
@@ -0,0 +1,236 @@
+import { ExtensionManager, Types } from '@ohif/core';
+
+/**
+ * This file contains the implementations of BaseDataSourceConfigurationAPIItem
+ * and BaseDataSourceConfigurationAPI for the Google cloud healthcare API. To
+ * better understand this implementation and/or to implement custom implementations,
+ * see the platform\core\src\types\DataSourceConfigurationAPI.ts and its JS doc
+ * comments as a guide.
+ */
+
+/**
+ * The various Google Cloud Healthcare path item types.
+ */
+enum ItemType {
+ projects = 0,
+ locations = 1,
+ datasets = 2,
+ dicomStores = 3,
+}
+
+interface NamedItem {
+ name: string;
+}
+interface Project extends NamedItem {
+ projectId: string;
+}
+
+const initialUrl = 'https://cloudresourcemanager.googleapis.com/v1';
+const baseHealthcareUrl = 'https://healthcare.googleapis.com/v1';
+
+class GoogleCloudDataSourceConfigurationAPIItem
+ implements Types.BaseDataSourceConfigurationAPIItem
+{
+ id: string;
+ name: string;
+ url: string;
+ itemType: ItemType;
+}
+
+class GoogleCloudDataSourceConfigurationAPI implements Types.BaseDataSourceConfigurationAPI {
+ private _extensionManager: ExtensionManager;
+ private _fetchOptions: { method: string; headers: unknown };
+ private _dataSourceName: string;
+
+ constructor(dataSourceName, servicesManager, extensionManager) {
+ this._dataSourceName = dataSourceName;
+ this._extensionManager = extensionManager;
+ const userAuthenticationService = servicesManager.services.userAuthenticationService;
+ this._fetchOptions = {
+ method: 'GET',
+ headers: userAuthenticationService.getAuthorizationHeader(),
+ };
+ }
+
+ getItemLabels = () => ['Project', 'Location', 'Data set', 'DICOM store'];
+
+ async initialize(): Promise {
+ const url = `${initialUrl}/projects`;
+
+ const projects = (await GoogleCloudDataSourceConfigurationAPI._doFetch(
+ url,
+ ItemType.projects,
+ this._fetchOptions
+ )) as Array;
+
+ if (!projects?.length) {
+ return [];
+ }
+
+ const projectItems = projects.map(project => {
+ return {
+ id: project.projectId,
+ name: project.name,
+ itemType: ItemType.projects,
+ url: `${baseHealthcareUrl}/projects/${project.projectId}`,
+ };
+ });
+
+ return projectItems;
+ }
+
+ async setCurrentItem(
+ anItem: Types.BaseDataSourceConfigurationAPIItem
+ ): Promise {
+ const googleCloudItem = anItem as GoogleCloudDataSourceConfigurationAPIItem;
+
+ if (googleCloudItem.itemType === ItemType.dicomStores) {
+ // Last configurable item, so update the data source configuration.
+ const url = `${googleCloudItem.url}/dicomWeb`;
+ const dataSourceDefCopy = JSON.parse(
+ JSON.stringify(this._extensionManager.getDataSourceDefinition(this._dataSourceName))
+ );
+ dataSourceDefCopy.configuration = {
+ ...dataSourceDefCopy.configuration,
+ wadoUriRoot: url,
+ qidoRoot: url,
+ wadoRoot: url,
+ };
+
+ this._extensionManager.updateDataSourceConfiguration(
+ dataSourceDefCopy.sourceName,
+ dataSourceDefCopy.configuration
+ );
+
+ return [];
+ }
+
+ const subItemType = googleCloudItem.itemType + 1;
+ const subItemField = `${ItemType[subItemType]}`;
+
+ const url = `${googleCloudItem.url}/${subItemField}`;
+
+ const fetchedSubItems = await GoogleCloudDataSourceConfigurationAPI._doFetch(
+ url,
+ subItemType,
+ this._fetchOptions
+ );
+
+ if (!fetchedSubItems?.length) {
+ return [];
+ }
+
+ const subItems = fetchedSubItems.map(subItem => {
+ const nameSplit = subItem.name.split('/');
+ return {
+ id: subItem.name,
+ name: nameSplit[nameSplit.length - 1],
+ itemType: subItemType,
+ url: `${baseHealthcareUrl}/${subItem.name}`,
+ };
+ });
+
+ return subItems;
+ }
+
+ async getConfiguredItems(): Promise> {
+ const dataSourceDefinition = this._extensionManager.getDataSourceDefinition(
+ this._dataSourceName
+ );
+
+ const url = dataSourceDefinition.configuration.wadoUriRoot;
+ const projectsIndex = url.indexOf('projects');
+ // Split the configured URL into (essentially) pairs (i.e. item type followed by item)
+ // Explicitly: ['projects','aProject','locations','aLocation','datasets','aDataSet','dicomStores','aDicomStore']
+ // Note that a partial configuration will have a subset of the above.
+ const urlSplit = url.substring(projectsIndex).split('/');
+
+ const configuredItems = [];
+
+ for (
+ let itemType = 0;
+ // the number of configured items is either the max (4) or the number extracted from the url split
+ itemType < 4 && (itemType + 1) * 2 < urlSplit.length;
+ itemType += 1
+ ) {
+ if (itemType === ItemType.projects) {
+ const projectId = urlSplit[1];
+ const projectUrl = `${initialUrl}/projects/${projectId}`;
+ const data = await GoogleCloudDataSourceConfigurationAPI._doFetch(
+ projectUrl,
+ ItemType.projects,
+ this._fetchOptions
+ );
+ const project = data[0] as Project;
+ configuredItems.push({
+ id: project.projectId,
+ name: project.name,
+ itemType: itemType,
+ url: `${baseHealthcareUrl}/projects/${project.projectId}`,
+ });
+ } else {
+ const relativePath = urlSplit.slice(0, itemType * 2 + 2).join('/');
+ configuredItems.push({
+ id: relativePath,
+ name: urlSplit[itemType * 2 + 1],
+ itemType: itemType,
+ url: `${baseHealthcareUrl}/${relativePath}`,
+ });
+ }
+ }
+
+ return configuredItems;
+ }
+
+ /**
+ * Fetches an array of items the specified item type.
+ * @param urlStr the fetch url
+ * @param fetchItemType the type to fetch
+ * @param fetchOptions the header options for the fetch (e.g. authorization header)
+ * @param fetchSearchParams any search query params; currently only used for paging results
+ * @returns an array of items of the specified type
+ */
+ private static async _doFetch(
+ urlStr: string,
+ fetchItemType: ItemType,
+ fetchOptions = {},
+ fetchSearchParams: Record = {}
+ ): Promise | Array> {
+ try {
+ const url = new URL(urlStr);
+ url.search = new URLSearchParams(fetchSearchParams).toString();
+
+ const response = await fetch(url, fetchOptions);
+ const data = await response.json();
+ if (response.status >= 200 && response.status < 300 && data != null) {
+ if (data.nextPageToken != null) {
+ fetchSearchParams.pageToken = data.nextPageToken;
+ const subPageData = await this._doFetch(
+ urlStr,
+ fetchItemType,
+ fetchOptions,
+ fetchSearchParams
+ );
+ data[ItemType[fetchItemType]] = data[ItemType[fetchItemType]].concat(subPageData);
+ }
+ if (data[ItemType[fetchItemType]]) {
+ return data[ItemType[fetchItemType]];
+ } else if (data.name) {
+ return [data];
+ } else {
+ return [];
+ }
+ } else {
+ const message =
+ data?.error?.message ||
+ `Error returned from Google Cloud Healthcare: ${response.status} - ${response.statusText}`;
+ throw new Error(message);
+ }
+ } catch (err) {
+ const message = err?.message || 'Error occurred during fetch request.';
+ throw new Error(message);
+ }
+ }
+}
+
+export { GoogleCloudDataSourceConfigurationAPI };
diff --git a/extensions/default/src/DicomJSONDataSource/index.js b/extensions/default/src/DicomJSONDataSource/index.js
index 241d430af9..c4bfb75ce6 100644
--- a/extensions/default/src/DicomJSONDataSource/index.js
+++ b/extensions/default/src/DicomJSONDataSource/index.js
@@ -13,6 +13,7 @@ const mappings = {
let _store = {
urls: [],
+ studyInstanceUIDMap: new Map(), // map of urls to array of study instance UIDs
// {
// url: url1
// studies: [Study1, Study2], // if multiple studies
@@ -41,11 +42,13 @@ const findStudies = (key, value) => {
};
function createDicomJSONApi(dicomJsonConfig) {
- const { name, wadoRoot } = dicomJsonConfig;
+ const { wadoRoot } = dicomJsonConfig;
const implementation = {
- initialize: async ({ params, query, url }) => {
- if (!url) url = query.get('url');
+ initialize: async ({ query, url }) => {
+ if (!url) {
+ url = query.get('url');
+ }
let metaData = getMetaDataByURL(url);
// if we have already cached the data from this specific url
@@ -58,11 +61,7 @@ function createDicomJSONApi(dicomJsonConfig) {
}
const response = await fetch(url);
- let data = await response.json();
-
- const studyInstanceUIDs = data.studies.map(
- study => study.StudyInstanceUID
- );
+ const data = await response.json();
let StudyInstanceUID;
let SeriesInstanceUID;
@@ -89,12 +88,14 @@ function createDicomJSONApi(dicomJsonConfig) {
url,
studies: [...data.studies],
});
-
- return studyInstanceUIDs;
+ _store.studyInstanceUIDMap.set(
+ url,
+ data.studies.map(study => study.StudyInstanceUID)
+ );
},
query: {
studies: {
- mapParams: () => { },
+ mapParams: () => {},
search: async param => {
const [key, value] = Object.entries(param)[0];
const mappedParam = mappings[key];
@@ -118,18 +119,18 @@ function createDicomJSONApi(dicomJsonConfig) {
});
},
processResults: () => {
- console.debug(' DICOMJson QUERY processResults');
+ console.warn(' DICOMJson QUERY processResults not implemented');
},
},
series: {
// mapParams: mapParams.bind(),
search: () => {
- console.debug(' DICOMJson QUERY SERIES SEARCH');
+ console.warn(' DICOMJson QUERY SERIES SEARCH not implemented');
},
},
instances: {
search: () => {
- console.debug(' DICOMJson QUERY instances SEARCH');
+ console.warn(' DICOMJson QUERY instances SEARCH not implemented');
},
},
},
@@ -151,15 +152,9 @@ function createDicomJSONApi(dicomJsonConfig) {
return getDirectURL(wadoRoot, params);
},
series: {
- metadata: ({
- StudyInstanceUID,
- madeInClient = false,
- customSort,
- } = {}) => {
+ metadata: async ({ StudyInstanceUID, madeInClient = false, customSort } = {}) => {
if (!StudyInstanceUID) {
- throw new Error(
- 'Unable to query for SeriesMetadata without StudyInstanceUID'
- );
+ throw new Error('Unable to query for SeriesMetadata without StudyInstanceUID');
}
const study = findStudies('StudyInstanceUID', StudyInstanceUID)[0];
@@ -185,16 +180,10 @@ function createDicomJSONApi(dicomJsonConfig) {
DicomMetadataStore.addInstances(naturalizedInstances, madeInClient);
}
- DicomMetadataStore.addSeriesMetadata(
- seriesSummaryMetadata,
- madeInClient
- );
+ DicomMetadataStore.addSeriesMetadata(seriesSummaryMetadata, madeInClient);
function setSuccessFlag() {
- const study = DicomMetadataStore.getStudy(
- StudyInstanceUID,
- madeInClient
- );
+ const study = DicomMetadataStore.getStudy(StudyInstanceUID, madeInClient);
study.isLoaded = true;
}
@@ -213,14 +202,16 @@ function createDicomJSONApi(dicomJsonConfig) {
return obj;
});
storeInstances(instances);
- if (index === numberOfSeries - 1) setSuccessFlag();
+ if (index === numberOfSeries - 1) {
+ setSuccessFlag();
+ }
});
},
},
},
store: {
dicom: () => {
- console.debug(' DICOMJson store dicom');
+ console.warn(' DICOMJson store dicom not implemented');
},
},
getImageIdsForDisplaySet(displaySet) {
@@ -252,12 +243,13 @@ function createDicomJSONApi(dicomJsonConfig) {
return imageIds;
},
getImageIdsForInstance({ instance, frame }) {
- const imageIds = getImageId({
- instance,
- frame,
- });
+ const imageIds = getImageId({ instance, frame });
return imageIds;
},
+ getStudyInstanceUIDs: ({ params, query }) => {
+ const url = query.get('url');
+ return _store.studyInstanceUIDMap.get(url);
+ },
};
return IWebApiDataSource.create(implementation);
}
diff --git a/extensions/default/src/DicomLocalDataSource/index.js b/extensions/default/src/DicomLocalDataSource/index.js
index fc8554b92a..a7628e80a9 100644
--- a/extensions/default/src/DicomLocalDataSource/index.js
+++ b/extensions/default/src/DicomLocalDataSource/index.js
@@ -12,8 +12,12 @@ const END_MODALITIES = {
};
const compareValue = (v1, v2, def = 0) => {
- if (v1 === v2) return def;
- if (v1 < v2) return -1;
+ if (v1 === v2) {
+ return def;
+ }
+ if (v1 < v2) {
+ return -1;
+ }
return 1;
};
@@ -41,25 +45,7 @@ function createDicomLocalApi(dicomLocalConfig) {
const { name } = dicomLocalConfig;
const implementation = {
- initialize: ({ params, query }) => {
- const { StudyInstanceUIDs: paramsStudyInstanceUIDs } = params;
- const queryStudyInstanceUIDs = query.getAll('StudyInstanceUIDs');
-
- const StudyInstanceUIDs =
- queryStudyInstanceUIDs || paramsStudyInstanceUIDs;
- const StudyInstanceUIDsAsArray =
- StudyInstanceUIDs && Array.isArray(StudyInstanceUIDs)
- ? StudyInstanceUIDs
- : [StudyInstanceUIDs];
-
- // Put SRs at the end of series list to make sure images are loaded first
- StudyInstanceUIDsAsArray.forEach(StudyInstanceUID => {
- const study = DicomMetadataStore.getStudy(StudyInstanceUID);
- study.series = study.series.sort(customSort);
- });
-
- return StudyInstanceUIDsAsArray;
- },
+ initialize: ({ params, query }) => {},
query: {
studies: {
mapParams: () => {},
@@ -99,7 +85,7 @@ function createDicomLocalApi(dicomLocalConfig) {
});
},
processResults: () => {
- console.debug(' DICOMLocal QUERY processResults');
+ console.warn(' DICOMLocal QUERY processResults not implemented');
},
},
series: {
@@ -121,7 +107,7 @@ function createDicomLocalApi(dicomLocalConfig) {
},
instances: {
search: () => {
- console.debug(' DICOMLocal QUERY instances SEARCH');
+ console.warn(' DICOMLocal QUERY instances SEARCH not implemented');
},
},
},
@@ -141,16 +127,11 @@ function createDicomLocalApi(dicomLocalConfig) {
series: {
metadata: async ({ StudyInstanceUID, madeInClient = false } = {}) => {
if (!StudyInstanceUID) {
- throw new Error(
- 'Unable to query for SeriesMetadata without StudyInstanceUID'
- );
+ throw new Error('Unable to query for SeriesMetadata without StudyInstanceUID');
}
// Instances metadata already added via local upload
- const study = DicomMetadataStore.getStudy(
- StudyInstanceUID,
- madeInClient
- );
+ const study = DicomMetadataStore.getStudy(StudyInstanceUID, madeInClient);
// Series metadata already added via local upload
DicomMetadataStore._broadcastEvent(EVENTS.SERIES_ADDED, {
@@ -246,6 +227,28 @@ function createDicomLocalApi(dicomLocalConfig) {
deleteStudyMetadataPromise() {
console.log('deleteStudyMetadataPromise not implemented');
},
+ getStudyInstanceUIDs: ({ params, query }) => {
+ const { StudyInstanceUIDs: paramsStudyInstanceUIDs } = params;
+ const queryStudyInstanceUIDs = query.getAll('StudyInstanceUIDs');
+
+ const StudyInstanceUIDs = queryStudyInstanceUIDs || paramsStudyInstanceUIDs;
+ const StudyInstanceUIDsAsArray =
+ StudyInstanceUIDs && Array.isArray(StudyInstanceUIDs)
+ ? StudyInstanceUIDs
+ : [StudyInstanceUIDs];
+
+ // Put SRs at the end of series list to make sure images are loaded first
+ let isStudyInCache = false;
+ StudyInstanceUIDsAsArray.forEach(StudyInstanceUID => {
+ const study = DicomMetadataStore.getStudy(StudyInstanceUID);
+ if (study) {
+ study.series = study.series.sort(customSort);
+ isStudyInCache = true;
+ }
+ });
+
+ return isStudyInCache ? StudyInstanceUIDsAsArray : [];
+ },
};
return IWebApiDataSource.create(implementation);
}
diff --git a/extensions/default/src/DicomTagBrowser/DicomTagBrowser.css b/extensions/default/src/DicomTagBrowser/DicomTagBrowser.css
index fe6a960963..2845f2f39c 100644
--- a/extensions/default/src/DicomTagBrowser/DicomTagBrowser.css
+++ b/extensions/default/src/DicomTagBrowser/DicomTagBrowser.css
@@ -4,7 +4,7 @@
}
.dicom-tag-browser-table-wrapper {
-/* height: 500px;*/
+ /* height: 500px;*/
/*overflow-y: scroll;*/
overflow-x: scroll;
}
@@ -45,7 +45,7 @@
padding-left: 10px;
padding-right: 10px;
text-align: center;
- color: "#20A5D6";
+ color: '#20A5D6';
}
.dicom-tag-browser-table th.dicom-tag-browser-table-left {
diff --git a/extensions/default/src/DicomTagBrowser/DicomTagBrowser.tsx b/extensions/default/src/DicomTagBrowser/DicomTagBrowser.tsx
index 57cf04fa83..22eea9bc85 100644
--- a/extensions/default/src/DicomTagBrowser/DicomTagBrowser.tsx
+++ b/extensions/default/src/DicomTagBrowser/DicomTagBrowser.tsx
@@ -1,10 +1,9 @@
import dcmjs from 'dcmjs';
import moment from 'moment';
-import React, { useState, useMemo, useEffect, useRef } from 'react';
+import React, { useState, useMemo, useEffect } from 'react';
import { classes } from '@ohif/core';
-import { Icon, InputRange, Select, Typography } from '@ohif/ui';
+import { InputRange, Select, Typography, InputFilterText } from '@ohif/ui';
import debounce from 'lodash.debounce';
-import classNames from 'classnames';
import DicomTagTable from './DicomTagTable';
import './DicomTagBrowser.css';
@@ -22,10 +21,8 @@ const DicomTagBrowser = ({ displaySets, displaySetInstanceUID }) => {
// 3: Value
const excludedColumnIndicesForFilter: Set = new Set([1]);
- const [
- selectedDisplaySetInstanceUID,
- setSelectedDisplaySetInstanceUID,
- ] = useState(displaySetInstanceUID);
+ const [selectedDisplaySetInstanceUID, setSelectedDisplaySetInstanceUID] =
+ useState(displaySetInstanceUID);
const [instanceNumber, setInstanceNumber] = useState(1);
const [filterValue, setFilterValue] = useState('');
@@ -34,8 +31,6 @@ const DicomTagBrowser = ({ displaySets, displaySetInstanceUID }) => {
setInstanceNumber(1);
};
- const searchInputRef = useRef(null);
-
const activeDisplaySet = displaySets.find(
ds => ds.displaySetInstanceUID === selectedDisplaySetInstanceUID
);
@@ -113,27 +108,31 @@ const DicomTagBrowser = ({ displaySets, displaySetInstanceUID }) => {
return (
- Your computer does not have enough GPU power to support the default GPU - rendering mode. OHIF has switched to CPU rendering mode. Please note - that CPU rendering does not support all features such as Volume - Rendering, Multiplanar Reconstruction, and Segmentation Overlays. + Your computer does not have enough GPU power to support the default GPU rendering mode. OHIF + has switched to CPU rendering mode. Please note that CPU rendering does not support all + features such as Volume Rendering, Multiplanar Reconstruction, and Segmentation Overlays.
+
+ ) : (
+ <>
+ );
+}
+
+export default DataSourceConfigurationComponent;
diff --git a/extensions/default/src/Components/DataSourceConfigurationModalComponent.tsx b/extensions/default/src/Components/DataSourceConfigurationModalComponent.tsx
new file mode 100644
index 0000000000..c709a45e19
--- /dev/null
+++ b/extensions/default/src/Components/DataSourceConfigurationModalComponent.tsx
@@ -0,0 +1,195 @@
+import classNames from 'classnames';
+import React, { ReactElement, useEffect, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Icon } from '@ohif/ui';
+import { Types } from '@ohif/core';
+import ItemListComponent from './ItemListComponent';
+
+const NO_WRAP_ELLIPSIS_CLASS_NAMES = 'text-ellipsis whitespace-nowrap overflow-hidden';
+
+type DataSourceConfigurationModalComponentProps = {
+ configurationAPI: Types.BaseDataSourceConfigurationAPI;
+ configuredItems: Array
+
+ );
+ })}
+
+ {item.name}
+
+ {itemIndex !== configuredItems.length - 1 && |
}
+
+
+ );
+ };
+
+ const getSelectedItemsComponent = (): ReactElement => {
+ return (
+
+ {t(`Error fetching ${itemLabels[selectedItems.length]} list`)}
+
+ {errorMessage}
+
+ {itemLabels.map((itemLabel, itemLabelIndex) => {
+ return (
+
+ );
+ };
+
+ return (
+ {
+ setShowFullConfig(false);
+ setSelectedItems(theList => theList.slice(0, itemLabelIndex));
+ }
+ : undefined
+ }
+ >
+
+ )} +
+ );
+ })}
+
+ {itemLabelIndex < selectedItems.length ? (
+
+ {itemLabelIndex < selectedItems.length ? (
+ {t(itemLabel)}
+
+ {selectedItems[itemLabelIndex].name}
+
+ ) : (
+ + )} +
+ {getSelectedItemsComponent()}
+
+ {errorMessage ? (
+ getErrorComponent()
+ ) : (
+ {
+ setShowFullConfig(false);
+ setSelectedItems(theList => [...theList.slice(0, currentSelectedItemIndex + 1), item]);
+ }}
+ >
+ )}
+
+ );
+}
+
+export default DataSourceConfigurationModalComponent;
diff --git a/extensions/default/src/Components/ItemListComponent.tsx b/extensions/default/src/Components/ItemListComponent.tsx
new file mode 100644
index 0000000000..d8c30714f0
--- /dev/null
+++ b/extensions/default/src/Components/ItemListComponent.tsx
@@ -0,0 +1,86 @@
+import classNames from 'classnames';
+import React, { ReactElement, useEffect, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Button, Icon, InputFilterText, LoadingIndicatorProgress } from '@ohif/ui';
+import { Types } from '@ohif/core';
+
+type ItemListComponentProps = {
+ itemLabel: string;
+ itemList: Array
+
+ );
+}
+
+export default ItemListComponent;
diff --git a/extensions/default/src/Components/SidePanelWithServices.tsx b/extensions/default/src/Components/SidePanelWithServices.tsx
new file mode 100644
index 0000000000..23e9841b06
--- /dev/null
+++ b/extensions/default/src/Components/SidePanelWithServices.tsx
@@ -0,0 +1,60 @@
+import React, { useEffect, useState } from 'react';
+import { SidePanel } from '@ohif/ui';
+import { PanelService, ServicesManager } from '@ohif/core';
+
+export type SidePanelWithServicesProps = {
+ servicesManager: ServicesManager;
+ side: 'left' | 'right';
+ className: string;
+ activeTabIndex: number;
+ tabs: any;
+};
+
+const SidePanelWithServices = ({
+ servicesManager,
+ side,
+ className,
+ activeTabIndex: activeTabIndexProp,
+ tabs,
+}) => {
+ const panelService: PanelService = servicesManager?.services?.panelService;
+
+ // Tracks whether this SidePanel has been opened at least once since this SidePanel was inserted into the DOM.
+ // Thus going to the Study List page and back to the viewer resets this flag for a SidePanel.
+ const [hasBeenOpened, setHasBeenOpened] = useState(false);
+ const [activeTabIndex, setActiveTabIndex] = useState(activeTabIndexProp);
+
+ useEffect(() => {
+ if (panelService) {
+ const activatePanelSubscription = panelService.subscribe(
+ panelService.EVENTS.ACTIVATE_PANEL,
+ (activatePanelEvent: Types.ActivatePanelEvent) => {
+ if (!hasBeenOpened || activatePanelEvent.forceActive) {
+ const tabIndex = tabs.findIndex(tab => tab.id === activatePanelEvent.panelId);
+ if (tabIndex !== -1) {
+ setActiveTabIndex(tabIndex);
+ }
+ }
+ }
+ );
+
+ return () => {
+ activatePanelSubscription.unsubscribe();
+ };
+ }
+ }, [tabs, hasBeenOpened, panelService]);
+
+ return (
+
+
+ {t(`Select ${itemLabel}`)}
+
+ {itemList == null ? (
+
+
+
+ ) : (
+ <>
+ {t(itemLabel)}
+
+ {itemList
+ .filter(
+ item =>
+ !filterValue || item.name.toLowerCase().includes(filterValue.toLowerCase())
+ )
+ .map(item => {
+ const border =
+ 'rounded border-transparent border-b-secondary-light border-[1px] hover:border-primary-light';
+ return (
+
+
+ )}
+
+
+ );
+ })}
+ {item.name}
+
+
-
-
-
+
+
+
Series
-
+
-
+
-
-
{showInstanceList && (
-
+
Instance Number
)}
@@ -156,35 +155,13 @@ const DicomTagBrowser = ({ displaySets, displaySetInstanceUID }) => {
)}
- {/* TODO - refactor the following into its own reusable component */}
-
+
+
@@ -196,24 +173,14 @@ function getFormattedRowsFromTags(tags, metadata) {
tags.forEach(tagInfo => {
if (tagInfo.vr === 'SQ') {
- rows.push([
- `${tagInfo.tagIndent}${tagInfo.tag}`,
- tagInfo.vr,
- tagInfo.keyword,
- '',
- ]);
+ rows.push([`${tagInfo.tagIndent}${tagInfo.tag}`, tagInfo.vr, tagInfo.keyword, '']);
const { values } = tagInfo;
values.forEach((item, index) => {
const formatedRowsFromTags = getFormattedRowsFromTags(item, metadata);
- rows.push([
- `${item[0].tagIndent}(FFFE,E000)`,
- '',
- `Item #${index}`,
- '',
- ]);
+ rows.push([`${item[0].tagIndent}(FFFE,E000)`, '', `Item #${index}`, '']);
rows.push(...formatedRowsFromTags);
});
@@ -224,17 +191,10 @@ function getFormattedRowsFromTags(tags, metadata) {
const originalTagInfo = metadata[tag];
tagInfo.vr = originalTagInfo.vr;
} catch (error) {
- console.error(
- `Failed to parse value representation for tag '${tagInfo.keyword}'`
- );
+ console.error(`Failed to parse value representation for tag '${tagInfo.keyword}'`);
}
}
- rows.push([
- `${tagInfo.tagIndent}${tagInfo.tag}`,
- tagInfo.vr,
- tagInfo.keyword,
- tagInfo.value,
- ]);
+ rows.push([`${tagInfo.tagIndent}${tagInfo.tag}`, tagInfo.vr, tagInfo.keyword, tagInfo.value]);
}
});
diff --git a/extensions/default/src/DicomTagBrowser/DicomTagTable.tsx b/extensions/default/src/DicomTagBrowser/DicomTagTable.tsx
index 982af013b4..a661da9f7b 100644
--- a/extensions/default/src/DicomTagBrowser/DicomTagTable.tsx
+++ b/extensions/default/src/DicomTagBrowser/DicomTagTable.tsx
@@ -17,48 +17,40 @@ function ColumnHeaders({ tagRef, vrRef, keywordRef, valueRef }) {
return (
+
-
+
-
+
-
+
-
+
@@ -114,10 +106,7 @@ function DicomTagTable({ rows }) {
* When the browser window resizes, update the row virtualization (i.e. row heights)
*/
useEffect(() => {
- const debouncedResize = debounce(
- () => listRef.current.resetAfterIndex(0),
- 100
- );
+ const debouncedResize = debounce(() => listRef.current.resetAfterIndex(0), 100);
window.addEventListener('resize', debouncedResize);
@@ -135,15 +124,15 @@ function DicomTagTable({ rows }) {
-
);
},
@@ -154,9 +143,7 @@ function DicomTagTable({ rows }) {
* Whenever any one of the column headers is set, then the header is rendered.
* Here we chose the tag header.
*/
- const isHeaderRendered = useCallback(() => tagHeaderElem !== null, [
- tagHeaderElem,
- ]);
+ const isHeaderRendered = useCallback(() => tagHeaderElem !== null, [tagHeaderElem]);
/**
* Get the item/row size. We use the header column widths to calculate the various row heights.
@@ -179,11 +166,7 @@ function DicomTagTable({ rows }) {
.map((colText, index) => {
const colOneLineWidth = context.measureText(colText).width;
const numLines = Math.ceil(colOneLineWidth / headerWidths[index]);
- return (
- numLines * lineHeightPx +
- 2 * rowVerticalPaddingPx +
- rowBottomBorderPx
- );
+ return numLines * lineHeightPx + 2 * rowVerticalPaddingPx + rowBottomBorderPx;
})
.reduce((maxHeight, colHeight) => Math.max(maxHeight, colHeight));
},
@@ -204,7 +187,7 @@ function DicomTagTable({ rows }) {
valueRef={valueRef}
/>
{row[0]}
- {row[1]}
- {row[2]}
- {row[3]}
+ {row[0]}
+ {row[1]}
+ {row[2]}
+ {row[3]}
{isHeaderRendered() && (
diff --git a/extensions/default/src/DicomWebDataSource/index.js b/extensions/default/src/DicomWebDataSource/index.js
index 00f82841ed..b265e4a07a 100644
--- a/extensions/default/src/DicomWebDataSource/index.js
+++ b/extensions/default/src/DicomWebDataSource/index.js
@@ -1,11 +1,5 @@
import { api } from 'dicomweb-client';
-import {
- DicomMetadataStore,
- IWebApiDataSource,
- utils,
- errorHandler,
- classes,
-} from '@ohif/core';
+import { DicomMetadataStore, IWebApiDataSource, utils, errorHandler, classes } from '@ohif/core';
import {
mapParams,
@@ -18,10 +12,7 @@ import dcm4cheeReject from './dcm4cheeReject';
import getImageId from './utils/getImageId';
import dcmjs from 'dcmjs';
-import {
- retrieveStudyMetadata,
- deleteStudyMetadataPromise,
-} from './retrieveStudyMetadata.js';
+import { retrieveStudyMetadata, deleteStudyMetadataPromise } from './retrieveStudyMetadata.js';
import StaticWadoClient from './utils/StaticWadoClient';
import getDirectURL from '../utils/getDirectURL';
import { fixBulkDataURI } from './utils/fixBulkDataURI';
@@ -30,8 +21,7 @@ const { DicomMetaDictionary, DicomDict } = dcmjs.data;
const { naturalizeDataset, denaturalizeDataset } = DicomMetaDictionary;
-const ImplementationClassUID =
- '2.25.270695996825855179949881587723571202391.2.0.0';
+const ImplementationClassUID = '2.25.270695996825855179949881587723571202391.2.0.0';
const ImplementationVersionName = 'OHIF-VIEWER-2.0.0';
const EXPLICIT_VR_LITTLE_ENDIAN = '1.2.840.10008.1.2.1';
@@ -51,82 +41,87 @@ const metadataProvider = classes.MetadataProvider;
* @param {string|bool} singlepart - indicates of the retrieves can fetch singlepart. Options are bulkdata, video, image or boolean true
*/
function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
- const {
- qidoRoot,
- wadoRoot,
- enableStudyLazyLoad,
- supportsFuzzyMatching,
- supportsWildcard,
- supportsReject,
- staticWado,
- singlepart,
- } = dicomWebConfig;
-
- const dicomWebConfigCopy = JSON.parse(JSON.stringify(dicomWebConfig));
-
- const qidoConfig = {
- url: qidoRoot,
- staticWado,
- singlepart,
- headers: userAuthenticationService.getAuthorizationHeader(),
- errorInterceptor: errorHandler.getHTTPErrorHandler(),
- };
+ let dicomWebConfigCopy,
+ qidoConfig,
+ wadoConfig,
+ qidoDicomWebClient,
+ wadoDicomWebClient,
+ getAuthrorizationHeader,
+ generateWadoHeader;
- const wadoConfig = {
- url: wadoRoot,
- staticWado,
- singlepart,
- headers: userAuthenticationService.getAuthorizationHeader(),
- errorInterceptor: errorHandler.getHTTPErrorHandler(),
- };
+ const implementation = {
+ initialize: ({ params, query }) => {
+ if (dicomWebConfig.onConfiguration && typeof dicomWebConfig.onConfiguration === 'function') {
+ dicomWebConfig = dicomWebConfig.onConfiguration(dicomWebConfig, {
+ params,
+ query,
+ });
+ }
- // TODO -> Two clients sucks, but its better than 1000.
- // TODO -> We'll need to merge auth later.
- const qidoDicomWebClient = staticWado
- ? new StaticWadoClient(qidoConfig)
- : new api.DICOMwebClient(qidoConfig);
+ dicomWebConfigCopy = JSON.parse(JSON.stringify(dicomWebConfig));
- const wadoDicomWebClient = staticWado
- ? new StaticWadoClient(wadoConfig)
- : new api.DICOMwebClient(wadoConfig);
+ getAuthrorizationHeader = () => {
+ const xhrRequestHeaders = {};
+ const authHeaders = userAuthenticationService.getAuthorizationHeader();
+ if (authHeaders && authHeaders.Authorization) {
+ xhrRequestHeaders.Authorization = authHeaders.Authorization;
+ }
+ return xhrRequestHeaders;
+ };
- const implementation = {
- initialize: ({ params, query }) => {
- const { StudyInstanceUIDs: paramsStudyInstanceUIDs } = params;
- const queryStudyInstanceUIDs = utils.splitComma(
- query.getAll('StudyInstanceUIDs')
- );
+ generateWadoHeader = () => {
+ let authorizationHeader = getAuthrorizationHeader();
+ //Generate accept header depending on config params
+ let formattedAcceptHeader = utils.generateAcceptHeader(
+ dicomWebConfig.acceptHeader,
+ dicomWebConfig.requestTransferSyntaxUID,
+ dicomWebConfig.omitQuotationForMultipartRequest
+ );
- const StudyInstanceUIDs =
- (queryStudyInstanceUIDs.length && queryStudyInstanceUIDs) ||
- paramsStudyInstanceUIDs;
- const StudyInstanceUIDsAsArray =
- StudyInstanceUIDs && Array.isArray(StudyInstanceUIDs)
- ? StudyInstanceUIDs
- : [StudyInstanceUIDs];
- return StudyInstanceUIDsAsArray;
+ return {
+ ...authorizationHeader,
+ Accept: formattedAcceptHeader,
+ };
+ };
+
+ qidoConfig = {
+ url: dicomWebConfig.qidoRoot,
+ staticWado: dicomWebConfig.staticWado,
+ singlepart: dicomWebConfig.singlepart,
+ headers: userAuthenticationService.getAuthorizationHeader(),
+ errorInterceptor: errorHandler.getHTTPErrorHandler(),
+ };
+
+ wadoConfig = {
+ url: dicomWebConfig.wadoRoot,
+ staticWado: dicomWebConfig.staticWado,
+ singlepart: dicomWebConfig.singlepart,
+ headers: userAuthenticationService.getAuthorizationHeader(),
+ errorInterceptor: errorHandler.getHTTPErrorHandler(),
+ };
+
+ // TODO -> Two clients sucks, but its better than 1000.
+ // TODO -> We'll need to merge auth later.
+ qidoDicomWebClient = dicomWebConfig.staticWado
+ ? new StaticWadoClient(qidoConfig)
+ : new api.DICOMwebClient(qidoConfig);
+
+ wadoDicomWebClient = dicomWebConfig.staticWado
+ ? new StaticWadoClient(wadoConfig)
+ : new api.DICOMwebClient(wadoConfig);
},
query: {
studies: {
mapParams: mapParams.bind(),
- search: async function(origParams) {
- const headers = userAuthenticationService.getAuthorizationHeader();
- if (headers) {
- qidoDicomWebClient.headers = headers;
- }
-
+ search: async function (origParams) {
+ qidoDicomWebClient.headers = getAuthrorizationHeader();
const { studyInstanceUid, seriesInstanceUid, ...mappedParams } =
mapParams(origParams, {
- supportsFuzzyMatching,
- supportsWildcard,
+ supportsFuzzyMatching: dicomWebConfig.supportsFuzzyMatching,
+ supportsWildcard: dicomWebConfig.supportsWildcard,
}) || {};
- const results = await qidoSearch(
- qidoDicomWebClient,
- undefined,
- undefined,
- mappedParams
- );
+ const results = await qidoSearch(qidoDicomWebClient, undefined, undefined, mappedParams);
return processResults(results);
},
@@ -134,16 +129,9 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
},
series: {
// mapParams: mapParams.bind(),
- search: async function(studyInstanceUid) {
- const headers = userAuthenticationService.getAuthorizationHeader();
- if (headers) {
- qidoDicomWebClient.headers = headers;
- }
-
- const results = await seriesInStudy(
- qidoDicomWebClient,
- studyInstanceUid
- );
+ search: async function (studyInstanceUid) {
+ qidoDicomWebClient.headers = getAuthrorizationHeader();
+ const results = await seriesInStudy(qidoDicomWebClient, studyInstanceUid);
return processSeriesResults(results);
},
@@ -151,18 +139,8 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
},
instances: {
search: (studyInstanceUid, queryParameters) => {
- const headers = userAuthenticationService.getAuthorizationHeader();
- if (headers) {
- qidoDicomWebClient.headers = headers;
- }
-
- qidoSearch.call(
- undefined,
- qidoDicomWebClient,
- studyInstanceUid,
- null,
- queryParameters
- );
+ qidoDicomWebClient.headers = getAuthrorizationHeader();
+ qidoSearch.call(undefined, qidoDicomWebClient, studyInstanceUid, null, queryParameters);
},
},
},
@@ -179,9 +157,16 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
* or is already retrieved, or a promise to a URL for such use if a BulkDataURI
*/
directURL: params => {
- return getDirectURL({ wadoRoot, singlepart }, params);
+ return getDirectURL(
+ {
+ wadoRoot: dicomWebConfig.wadoRoot,
+ singlepart: dicomWebConfig.singlepart,
+ },
+ params
+ );
},
bulkDataURI: async ({ StudyInstanceUID, BulkDataURI }) => {
+ qidoDicomWebClient.headers = getAuthrorizationHeader();
const options = {
multipart: false,
BulkDataURI,
@@ -200,18 +185,11 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
sortFunction,
madeInClient = false,
} = {}) => {
- const headers = userAuthenticationService.getAuthorizationHeader();
- if (headers) {
- wadoDicomWebClient.headers = headers;
- }
-
if (!StudyInstanceUID) {
- throw new Error(
- 'Unable to query for SeriesMetadata without StudyInstanceUID'
- );
+ throw new Error('Unable to query for SeriesMetadata without StudyInstanceUID');
}
- if (enableStudyLazyLoad) {
+ if (dicomWebConfig.enableStudyLazyLoad) {
return implementation._retrieveSeriesMetadataAsync(
StudyInstanceUID,
filters,
@@ -234,22 +212,16 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
store: {
dicom: async (dataset, request) => {
- const headers = userAuthenticationService.getAuthorizationHeader();
- if (headers) {
- wadoDicomWebClient.headers = headers;
- }
-
+ wadoDicomWebClient.headers = getAuthrorizationHeader();
if (dataset instanceof ArrayBuffer) {
const options = {
datasets: [dataset],
request,
};
-
await wadoDicomWebClient.storeInstances(options);
} else {
const meta = {
- FileMetaInformationVersion:
- dataset._meta.FileMetaInformationVersion.Value,
+ FileMetaInformationVersion: dataset._meta?.FileMetaInformationVersion?.Value,
MediaStorageSOPClassUID: dataset.SOPClassUID,
MediaStorageSOPInstanceUID: dataset.SOPInstanceUID,
TransferSyntaxUID: EXPLICIT_VR_LITTLE_ENDIAN,
@@ -282,7 +254,7 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
madeInClient
) => {
const enableStudyLazyLoad = false;
-
+ wadoDicomWebClient.headers = generateWadoHeader();
// data is all SOPInstanceUIDs
const data = await retrieveStudyMetadata(
wadoDicomWebClient,
@@ -323,6 +295,8 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
});
instance.imageId = imageId;
+ instance.wadoRoot = dicomWebConfig.wadoRoot;
+ instance.wadoUri = dicomWebConfig.wadoUri;
metadataProvider.addImageIdToUIDs(imageId, {
StudyInstanceUID,
@@ -338,10 +312,7 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
DicomMetadataStore.addSeriesMetadata(seriesMetadata, madeInClient);
Object.keys(instancesPerSeries).forEach(seriesInstanceUID =>
- DicomMetadataStore.addInstances(
- instancesPerSeries[seriesInstanceUID],
- madeInClient
- )
+ DicomMetadataStore.addInstances(instancesPerSeries[seriesInstanceUID], madeInClient)
);
},
@@ -353,18 +324,17 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
madeInClient = false
) => {
const enableStudyLazyLoad = true;
+ wadoDicomWebClient.headers = generateWadoHeader();
// Get Series
- const {
- preLoadData: seriesSummaryMetadata,
- promises: seriesPromises,
- } = await retrieveStudyMetadata(
- wadoDicomWebClient,
- StudyInstanceUID,
- enableStudyLazyLoad,
- filters,
- sortCriteria,
- sortFunction
- );
+ const { preLoadData: seriesSummaryMetadata, promises: seriesPromises } =
+ await retrieveStudyMetadata(
+ wadoDicomWebClient,
+ StudyInstanceUID,
+ enableStudyLazyLoad,
+ filters,
+ sortCriteria,
+ sortFunction
+ );
/**
* naturalizes the dataset, and adds a retrieve bulkdata method
@@ -375,7 +345,7 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
const addRetrieveBulkData = instance => {
const naturalized = naturalizeDataset(instance);
- // if we konw the server doesn't use bulkDataURI, then don't
+ // if we know the server doesn't use bulkDataURI, then don't
if (!dicomWebConfig.bulkDataURI?.enabled) {
return naturalized;
}
@@ -409,8 +379,7 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
// the bulk data and DICOM video cases where the second ArrayBuffer is
// the bulk data. Here we play it safe and do a find.
const ret =
- (val instanceof Array &&
- val.find(arrayBuffer => arrayBuffer?.byteLength)) ||
+ (val instanceof Array && val.find(arrayBuffer => arrayBuffer?.byteLength)) ||
undefined;
value.Value = ret;
return ret;
@@ -453,10 +422,7 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
}
function setSuccessFlag() {
- const study = DicomMetadataStore.getStudy(
- StudyInstanceUID,
- madeInClient
- );
+ const study = DicomMetadataStore.getStudy(StudyInstanceUID, madeInClient);
study.isLoaded = true;
}
@@ -515,10 +481,23 @@ function createDicomWebApi(dicomWebConfig, userAuthenticationService) {
getConfig() {
return dicomWebConfigCopy;
},
+ getStudyInstanceUIDs({ params, query }) {
+ const { StudyInstanceUIDs: paramsStudyInstanceUIDs } = params;
+ const queryStudyInstanceUIDs = utils.splitComma(query.getAll('StudyInstanceUIDs'));
+
+ const StudyInstanceUIDs =
+ (queryStudyInstanceUIDs.length && queryStudyInstanceUIDs) || paramsStudyInstanceUIDs;
+ const StudyInstanceUIDsAsArray =
+ StudyInstanceUIDs && Array.isArray(StudyInstanceUIDs)
+ ? StudyInstanceUIDs
+ : [StudyInstanceUIDs];
+
+ return StudyInstanceUIDsAsArray;
+ },
};
- if (supportsReject) {
- implementation.reject = dcm4cheeReject(wadoRoot);
+ if (dicomWebConfig.supportsReject) {
+ implementation.reject = dcm4cheeReject(dicomWebConfig.wadoRoot);
}
return IWebApiDataSource.create(implementation);
diff --git a/extensions/default/src/DicomWebDataSource/qido.js b/extensions/default/src/DicomWebDataSource/qido.js
index ce372cd5fc..4bea9a0747 100644
--- a/extensions/default/src/DicomWebDataSource/qido.js
+++ b/extensions/default/src/DicomWebDataSource/qido.js
@@ -54,10 +54,7 @@ function processResults(qidoStudies) {
patientName: utils.formatPN(getName(qidoStudy['00100010'])) || '',
instances: Number(getString(qidoStudy['00201208'])) || 0, // number
description: getString(qidoStudy['00081030']) || '',
- modalities:
- getString(
- getModalities(qidoStudy['00080060'], qidoStudy['00080061'])
- ) || '',
+ modalities: getString(getModalities(qidoStudy['00080060'], qidoStudy['00080061'])) || '',
})
);
@@ -105,12 +102,7 @@ export function processSeriesResults(qidoSeries) {
* @param {string} [queryParamaters]
* @returns {Promise} - Promise that resolves results
*/
-async function search(
- dicomWebClient,
- studyInstanceUid,
- seriesInstanceUid,
- queryParameters
-) {
+async function search(dicomWebClient, studyInstanceUid, seriesInstanceUid, queryParameters) {
let searchResult = await dicomWebClient.searchForStudies({
studyInstanceUid: undefined,
queryParams: queryParameters,
@@ -136,10 +128,7 @@ export function seriesInStudy(dicomWebClient, studyInstanceUID) {
}
export default function searchStudies(server, filter) {
- const queryParams = getQIDOQueryParams(
- filter,
- server.qidoSupportsIncludeField
- );
+ const queryParams = getQIDOQueryParams(filter, server.qidoSupportsIncludeField);
const options = {
queryParams,
};
diff --git a/extensions/default/src/DicomWebDataSource/retrieveStudyMetadata.js b/extensions/default/src/DicomWebDataSource/retrieveStudyMetadata.js
index faf5e2c901..e4882d05e8 100644
--- a/extensions/default/src/DicomWebDataSource/retrieveStudyMetadata.js
+++ b/extensions/default/src/DicomWebDataSource/retrieveStudyMetadata.js
@@ -9,7 +9,7 @@ const StudyMetaDataPromises = new Map();
*
* @param {Object} server Object with server configuration parameters
* @param {string} StudyInstanceUID The UID of the Study to be retrieved
- * @param {boolean} enabledStudyLazyLoad Whether the study metadata should be loaded asynchronusly.
+ * @param {boolean} enabledStudyLazyLoad Whether the study metadata should be loaded asynchronously.
* @param {function} storeInstancesCallback A callback used to store the retrieved instance metadata.
* @param {Object} [filters] - Object containing filters to be applied on retrieve metadata process
* @param {string} [filter.seriesInstanceUID] - series instance uid to filter results against
@@ -28,14 +28,10 @@ export function retrieveStudyMetadata(
// corresponding promise from the "StudyMetaDataPromises" map...
if (!dicomWebClient) {
- throw new Error(
- `${moduleName}: Required 'dicomWebClient' parameter not provided.`
- );
+ throw new Error(`${moduleName}: Required 'dicomWebClient' parameter not provided.`);
}
if (!StudyInstanceUID) {
- throw new Error(
- `${moduleName}: Required 'StudyInstanceUID' parameter not provided.`
- );
+ throw new Error(`${moduleName}: Required 'StudyInstanceUID' parameter not provided.`);
}
// Already waiting on result? Return cached promise
@@ -52,7 +48,7 @@ export function retrieveStudyMetadata(
filters,
sortCriteria,
sortFunction
- ).then(function(data) {
+ ).then(function (data) {
resolve(data);
}, reject);
});
diff --git a/extensions/default/src/DicomWebDataSource/utils/StaticWadoClient.ts b/extensions/default/src/DicomWebDataSource/utils/StaticWadoClient.ts
index 9521e379b0..6d790cd7c7 100644
--- a/extensions/default/src/DicomWebDataSource/utils/StaticWadoClient.ts
+++ b/extensions/default/src/DicomWebDataSource/utils/StaticWadoClient.ts
@@ -36,24 +36,21 @@ export default class StaticWadoClient extends api.DICOMwebClient {
* @returns
*/
async searchForStudies(options) {
- if (!this.staticWado) return super.searchForStudies(options);
+ if (!this.staticWado) {
+ return super.searchForStudies(options);
+ }
const searchResult = await super.searchForStudies(options);
const { queryParams } = options;
- if (!queryParams) return searchResult;
+ if (!queryParams) {
+ return searchResult;
+ }
const lowerParams = this.toLowerParams(queryParams);
const filtered = searchResult.filter(study => {
for (const key of Object.keys(StaticWadoClient.studyFilterKeys)) {
- if (
- !this.filterItem(
- key,
- lowerParams,
- study,
- StaticWadoClient.studyFilterKeys
- )
- ) {
+ if (!this.filterItem(key, lowerParams, study, StaticWadoClient.studyFilterKeys)) {
return false;
}
}
@@ -63,23 +60,20 @@ export default class StaticWadoClient extends api.DICOMwebClient {
}
async searchForSeries(options) {
- if (!this.staticWado) return super.searchForSeries(options);
+ if (!this.staticWado) {
+ return super.searchForSeries(options);
+ }
const searchResult = await super.searchForSeries(options);
const { queryParams } = options;
- if (!queryParams) return searchResult;
+ if (!queryParams) {
+ return searchResult;
+ }
const lowerParams = this.toLowerParams(queryParams);
const filtered = searchResult.filter(series => {
for (const key of Object.keys(StaticWadoClient.seriesFilterKeys)) {
- if (
- !this.filterItem(
- key,
- lowerParams,
- series,
- StaticWadoClient.seriesFilterKeys
- )
- ) {
+ if (!this.filterItem(key, lowerParams, series, StaticWadoClient.seriesFilterKeys)) {
return false;
}
}
@@ -112,18 +106,19 @@ export default class StaticWadoClient extends api.DICOMwebClient {
actual = actual.Alphabetic;
}
if (typeof actual == 'string') {
- if (actual.length === 0) return true;
- if (desired.length === 0 || desired === '*') return true;
+ if (actual.length === 0) {
+ return true;
+ }
+ if (desired.length === 0 || desired === '*') {
+ return true;
+ }
if (desired[0] === '*' && desired[desired.length - 1] === '*') {
// console.log(`Comparing ${actual} to ${desired.substring(1, desired.length - 1)}`)
return actual.indexOf(desired.substring(1, desired.length - 1)) != -1;
} else if (desired[desired.length - 1] === '*') {
return actual.indexOf(desired.substring(0, desired.length - 1)) != -1;
} else if (desired[0] === '*') {
- return (
- actual.indexOf(desired.substring(1)) ===
- actual.length - desired.length + 1
- );
+ return actual.indexOf(desired.substring(1)) === actual.length - desired.length + 1;
}
}
return desired === actual;
@@ -131,9 +126,13 @@ export default class StaticWadoClient extends api.DICOMwebClient {
/** Compares a pair of dates to see if the value is within the range */
compareDateRange(range, value) {
- if (!value) return true;
+ if (!value) {
+ return true;
+ }
const dash = range.indexOf('-');
- if (dash === -1) return this.compareValues(range, value);
+ if (dash === -1) {
+ return this.compareValues(range, value);
+ }
const start = range.substring(0, dash);
const end = range.substring(dash + 1);
return (!start || value >= start) && (!end || value <= end);
@@ -150,11 +149,17 @@ export default class StaticWadoClient extends api.DICOMwebClient {
*/
filterItem(key: string, queryParams, study, sourceFilterMap) {
const altKey = sourceFilterMap[key] || key;
- if (!queryParams) return true;
+ if (!queryParams) {
+ return true;
+ }
const testValue = queryParams[key] || queryParams[altKey];
- if (!testValue) return true;
+ if (!testValue) {
+ return true;
+ }
const valueElem = study[key] || study[altKey];
- if (!valueElem) return false;
+ if (!valueElem) {
+ return false;
+ }
if (valueElem.vr == 'DA') {
return this.compareDateRange(testValue, valueElem.Value[0]);
}
diff --git a/extensions/default/src/DicomWebDataSource/utils/fixBulkDataURI.ts b/extensions/default/src/DicomWebDataSource/utils/fixBulkDataURI.ts
index 1a408b597f..2e592c7570 100644
--- a/extensions/default/src/DicomWebDataSource/utils/fixBulkDataURI.ts
+++ b/extensions/default/src/DicomWebDataSource/utils/fixBulkDataURI.ts
@@ -20,10 +20,7 @@ function fixBulkDataURI(value, instance, dicomWebConfig) {
// in case of the relative path, make it absolute. The current DICOM standard says
// the bulkdataURI is relative to the series. However, there are situations where
// it can be relative to the study too
- if (
- !value.BulkDataURI.startsWith('http') &&
- !value.BulkDataURI.startsWith('/')
- ) {
+ if (!value.BulkDataURI.startsWith('http') && !value.BulkDataURI.startsWith('/')) {
if (dicomWebConfig.bulkDataURI?.relativeResolution === 'studies') {
value.BulkDataURI = `${dicomWebConfig.wadoRoot}/studies/${instance.StudyInstanceUID}/${value.BulkDataURI}`;
} else if (
diff --git a/extensions/default/src/DicomWebDataSource/utils/getImageId.js b/extensions/default/src/DicomWebDataSource/utils/getImageId.js
index a493a3d3ad..29877bd432 100644
--- a/extensions/default/src/DicomWebDataSource/utils/getImageId.js
+++ b/extensions/default/src/DicomWebDataSource/utils/getImageId.js
@@ -24,12 +24,7 @@ function buildInstanceWadoUrl(config, instance) {
* @param thumbnail
* @returns {string} The imageId to be used by Cornerstone
*/
-export default function getImageId({
- instance,
- frame,
- config,
- thumbnail = false,
-}) {
+export default function getImageId({ instance, frame, config, thumbnail = false }) {
if (!instance) {
return;
}
diff --git a/extensions/default/src/DicomWebDataSource/wado/retrieveMetadata.js b/extensions/default/src/DicomWebDataSource/wado/retrieveMetadata.js
index d70a2cdccd..ba62cca1da 100644
--- a/extensions/default/src/DicomWebDataSource/wado/retrieveMetadata.js
+++ b/extensions/default/src/DicomWebDataSource/wado/retrieveMetadata.js
@@ -20,9 +20,7 @@ async function RetrieveMetadata(
sortFunction
) {
const RetrieveMetadataLoader =
- enableStudyLazyLoad !== false
- ? RetrieveMetadataLoaderAsync
- : RetrieveMetadataLoaderSync;
+ enableStudyLazyLoad !== false ? RetrieveMetadataLoaderAsync : RetrieveMetadataLoaderSync;
const retrieveMetadataLoader = new RetrieveMetadataLoader(
dicomWebClient,
diff --git a/extensions/default/src/DicomWebDataSource/wado/retrieveMetadataLoader.js b/extensions/default/src/DicomWebDataSource/wado/retrieveMetadataLoader.js
index 49302f7a83..da747c88bb 100644
--- a/extensions/default/src/DicomWebDataSource/wado/retrieveMetadataLoader.js
+++ b/extensions/default/src/DicomWebDataSource/wado/retrieveMetadataLoader.js
@@ -14,13 +14,7 @@ export default class RetrieveMetadataLoader {
* @param {string} [filter.seriesInstanceUID] - series instance uid to filter results against
* @param {Function} [sortSeries] - Custom sort function for series
*/
- constructor(
- client,
- studyInstanceUID,
- filters = {},
- sortCriteria,
- sortFunction
- ) {
+ constructor(client, studyInstanceUID, filters = {}, sortCriteria, sortFunction) {
this.client = client;
this.studyInstanceUID = studyInstanceUID;
this.filters = filters;
diff --git a/extensions/default/src/DicomWebDataSource/wado/retrieveMetadataLoaderAsync.js b/extensions/default/src/DicomWebDataSource/wado/retrieveMetadataLoaderAsync.js
index 096c3c8183..bca3094292 100644
--- a/extensions/default/src/DicomWebDataSource/wado/retrieveMetadataLoaderAsync.js
+++ b/extensions/default/src/DicomWebDataSource/wado/retrieveMetadataLoaderAsync.js
@@ -1,8 +1,5 @@
import dcmjs from 'dcmjs';
-import {
- sortStudySeries,
- sortingCriteria,
-} from '@ohif/core/src/utils/sortStudy';
+import { sortStudySeries, sortingCriteria } from '@ohif/core/src/utils/sortStudy';
import RetrieveMetadataLoader from './retrieveMetadataLoader';
/**
@@ -12,11 +9,7 @@ import RetrieveMetadataLoader from './retrieveMetadataLoader';
* @param {Array} seriesInstanceUIDList A list of Series Instance UIDs
* @returns {Object} Returns an object which supports loading of instances from each of given Series Instance UID
*/
-function makeSeriesAsyncLoader(
- client,
- studyInstanceUID,
- seriesInstanceUIDList
-) {
+function makeSeriesAsyncLoader(client, studyInstanceUID, seriesInstanceUIDList) {
return Object.freeze({
hasNext() {
return seriesInstanceUIDList.length > 0;
@@ -43,11 +36,7 @@ export default class RetrieveMetadataLoaderAsync extends RetrieveMetadataLoader
*/
*getPreLoaders() {
const preLoaders = [];
- const {
- studyInstanceUID,
- filters: { seriesInstanceUID } = {},
- client,
- } = this;
+ const { studyInstanceUID, filters: { seriesInstanceUID } = {}, client } = this;
if (seriesInstanceUID) {
const options = {
@@ -73,8 +62,7 @@ export default class RetrieveMetadataLoaderAsync extends RetrieveMetadataLoader
return sortStudySeries(
naturalized,
- sortCriteria ||
- sortingCriteria.seriesSortCriteria.seriesInfoSortingCriteria,
+ sortCriteria || sortingCriteria.seriesSortCriteria.seriesInfoSortingCriteria,
sortFunction
);
}
@@ -84,11 +72,7 @@ export default class RetrieveMetadataLoaderAsync extends RetrieveMetadataLoader
const seriesInstanceUIDs = preLoadData.map(s => s.SeriesInstanceUID);
- const seriesAsyncLoader = makeSeriesAsyncLoader(
- client,
- studyInstanceUID,
- seriesInstanceUIDs
- );
+ const seriesAsyncLoader = makeSeriesAsyncLoader(client, studyInstanceUID, seriesInstanceUIDs);
const promises = [];
diff --git a/extensions/default/src/DicomWebDataSource/wado/retrieveMetadataLoaderSync.js b/extensions/default/src/DicomWebDataSource/wado/retrieveMetadataLoaderSync.js
index 6ca47ce9db..1a7cd9d500 100644
--- a/extensions/default/src/DicomWebDataSource/wado/retrieveMetadataLoaderSync.js
+++ b/extensions/default/src/DicomWebDataSource/wado/retrieveMetadataLoaderSync.js
@@ -31,11 +31,7 @@ export default class RetrieveMetadataLoaderSync extends RetrieveMetadataLoader {
*/
*getLoaders() {
const loaders = [];
- const {
- studyInstanceUID,
- filters: { seriesInstanceUID } = {},
- client,
- } = this;
+ const { studyInstanceUID, filters: { seriesInstanceUID } = {}, client } = this;
if (seriesInstanceUID) {
loaders.push(
@@ -46,9 +42,7 @@ export default class RetrieveMetadataLoaderSync extends RetrieveMetadataLoader {
);
}
- loaders.push(
- client.retrieveStudyMetadata.bind(client, { studyInstanceUID })
- );
+ loaders.push(client.retrieveStudyMetadata.bind(client, { studyInstanceUID }));
yield* loaders;
}
diff --git a/extensions/default/src/DicomWebProxyDataSource/index.js b/extensions/default/src/DicomWebProxyDataSource/index.js
index e873237dde..ab1d8e49e3 100644
--- a/extensions/default/src/DicomWebProxyDataSource/index.js
+++ b/extensions/default/src/DicomWebProxyDataSource/index.js
@@ -9,24 +9,12 @@ import { createDicomWebApi } from '../DicomWebDataSource/index';
* dicomWeb configuration array
*
*/
-function createDicomWebProxyApi(
- dicomWebProxyConfig,
- UserAuthenticationService
-) {
+function createDicomWebProxyApi(dicomWebProxyConfig, UserAuthenticationService) {
const { name } = dicomWebProxyConfig;
let dicomWebDelegate = undefined;
const implementation = {
initialize: async ({ params, query }) => {
- let studyInstanceUIDs = [];
-
- // there seem to be a couple of variations of the case for this parameter
- const queryStudyInstanceUIDs =
- query.get('studyInstanceUIDs') || query.get('studyInstanceUids');
- if (!queryStudyInstanceUIDs) {
- throw new Error(`No studyInstanceUids in request for '${name}'`);
- }
-
const url = query.get('url');
if (!url) {
@@ -39,12 +27,11 @@ function createDicomWebProxyApi(
}
dicomWebDelegate = createDicomWebApi(
- data.servers.dicomWeb[0],
+ data.servers.dicomWeb[0].configuration,
UserAuthenticationService
);
- studyInstanceUIDs = queryStudyInstanceUIDs.split(';');
+ dicomWebDelegate.initialize({ params, query });
}
- return studyInstanceUIDs;
},
query: {
studies: {
@@ -55,28 +42,33 @@ function createDicomWebProxyApi(
},
instances: {
search: (studyInstanceUid, queryParameters) =>
- dicomWebDelegate.query.instances.search(
- studyInstanceUid,
- queryParameters
- ),
+ dicomWebDelegate.query.instances.search(studyInstanceUid, queryParameters),
},
},
retrieve: {
directURL: (...args) => dicomWebDelegate.retrieve.directURL(...args),
series: {
- metadata: (...args) =>
- dicomWebDelegate.retrieve.series.metadata(...args),
+ metadata: async (...args) => dicomWebDelegate.retrieve.series.metadata(...args),
},
},
store: {
dicom: (...args) => dicomWebDelegate.store(...args),
},
- deleteStudyMetadataPromise: (...args) =>
- dicomWebDelegate.deleteStudyMetadataPromise(...args),
- getImageIdsForDisplaySet: (...args) =>
- dicomWebDelegate.getImageIdsForDisplaySet(...args),
- getImageIdsForInstance: (...args) =>
- dicomWebDelegate.getImageIdsForInstance(...args),
+ deleteStudyMetadataPromise: (...args) => dicomWebDelegate.deleteStudyMetadataPromise(...args),
+ getImageIdsForDisplaySet: (...args) => dicomWebDelegate.getImageIdsForDisplaySet(...args),
+ getImageIdsForInstance: (...args) => dicomWebDelegate.getImageIdsForInstance(...args),
+ getStudyInstanceUIDs({ params, query }) {
+ let studyInstanceUIDs = [];
+
+ // there seem to be a couple of variations of the case for this parameter
+ const queryStudyInstanceUIDs =
+ query.get('studyInstanceUIDs') || query.get('studyInstanceUids');
+ if (!queryStudyInstanceUIDs) {
+ throw new Error(`No studyInstanceUids in request for '${name}'`);
+ }
+ studyInstanceUIDs = queryStudyInstanceUIDs.split(';');
+ return studyInstanceUIDs;
+ },
};
return IWebApiDataSource.create(implementation);
}
diff --git a/extensions/default/src/Panels/ActionButtons.tsx b/extensions/default/src/Panels/ActionButtons.tsx
index f372a1ee08..c21f8b6b65 100644
--- a/extensions/default/src/Panels/ActionButtons.tsx
+++ b/extensions/default/src/Panels/ActionButtons.tsx
@@ -2,21 +2,31 @@ import React from 'react';
import PropTypes from 'prop-types';
import { useTranslation } from 'react-i18next';
-import { Button, ButtonGroup } from '@ohif/ui';
+import { LegacyButton, LegacyButtonGroup } from '@ohif/ui';
function ActionButtons({ onExportClick, onCreateReportClick }) {
const { t } = useTranslation('MeasurementTable');
return (
-
-
-
-
+
+
);
}
diff --git a/extensions/default/src/Panels/DataSourceSelector.tsx b/extensions/default/src/Panels/DataSourceSelector.tsx
index decb24ad83..dcb62c2839 100644
--- a/extensions/default/src/Panels/DataSourceSelector.tsx
+++ b/extensions/default/src/Panels/DataSourceSelector.tsx
@@ -3,7 +3,7 @@ import classnames from 'classnames';
import { useNavigate } from 'react-router-dom';
import { useAppConfig } from '@state';
-import { Button } from '@ohif/ui';
+import { Button, ButtonEnums } from '@ohif/ui';
function DataSourceSelector() {
const [appConfig] = useAppConfig();
@@ -15,25 +15,24 @@ function DataSourceSelector() {
return (
-
-
+
+
-
-
+
{dsConfigs
- .filter(
- it =>
- it.sourceName !== 'dicomjson' &&
- it.sourceName !== 'dicomlocal'
- )
+ .filter(it => it.sourceName !== 'dicomjson' && it.sourceName !== 'dicomlocal')
.map(ds => (
-