| 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 d2aad74c276..b55cbfdfa0e 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 39fe445d11f..13d96924b9b 100644
--- a/commit.txt
+++ b/commit.txt
@@ -1 +1 @@
-1d38fe30a490010c7de487c7a0b1a5bfe3bc75a4
\ No newline at end of file
+c3a5847dcd3dce4f1c8d8b11af95f79e3f93f70d
\ No newline at end of file
diff --git a/extensions/_example/src/index.js b/extensions/_example/src/index.js
deleted file mode 100644
index c4fdb9eb1cd..00000000000
--- a/extensions/_example/src/index.js
+++ /dev/null
@@ -1,138 +0,0 @@
-import ImageSet from '@ohif/core/src/classes/ImageSet';
-import { IWebApiDataSource } from '@ohif/core';
-
-/**
- *
- */
-export default {
- id: '@ohif/extension-*',
-
- /**
- * LIFECYCLE HOOKS
- */
- preRegistration() {},
- beforeExtInit() {},
- beforeExtDestroy() {},
-
- /**
- * MODULES
- */
- getCommandsModule,
- getContextModule,
- getDataSourcesModule,
- getLayoutTemplateModule,
- getPanelModule,
- getSopClassHandlerModule,
- getToolbarModule() {},
- getViewportModule,
-};
-
-// appConfig,
-// extensionConfig,
-// dataSources,
-// servicesManager,
-// extensionManager,
-// commandsManager,
-
-/**
- *
- */
-const getCommandsModule = () => ({
- definitions: {
- exampleActionDef: {
- commandFn: ({ param1 }) => {
- console.log(`param1's value is: ${param1}`);
- },
- // storeContexts: ['viewports'],
- options: { param1: 'hello world' },
- context: 'VIEWER', // optional
- },
- },
- defaultContext: 'ACTIVE_VIEWPORT::DICOMSR',
-});
-
-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.5,
+ max: 99.5,
+ 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.5,
+ max: 99.5,
+ 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: 'Shapes',
+ icon: 'icon-tool-shape',
+ disabled: !toolsEnabled,
+ active:
+ state.activeTool === TOOL_TYPES.CIRCLE_SHAPE ||
+ state.activeTool === TOOL_TYPES.RECTANGLE_SHAPE ||
+ state.activeTool === TOOL_TYPES.SPHERE_SHAPE,
+ onClick: () => setToolActive(TOOL_TYPES.CIRCLE_SHAPE),
+ options: [
+ {
+ name: 'Mode',
+ type: 'radio',
+ value: state.Shapes.mode,
+ id: 'shape-mode',
+ values: [
+ { value: TOOL_TYPES.CIRCLE_SHAPE, label: 'Circle' },
+ { value: TOOL_TYPES.RECTANGLE_SHAPE, label: 'Rectangle' },
+ { value: TOOL_TYPES.SPHERE_SHAPE, 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.5,
+ max: 99.5,
+ 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 e032542f133..8ddc088c6c8 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 c0b9385f130..9f8c1dddf78 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 08ed004f077..fb39f8c36fe 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 +263,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 00000000000..f2d580cff46
--- /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_SHAPE: 'CircleScissor',
+ RECTANGLE_SHAPE: 'RectangleScissor',
+ SPHERE_SHAPE: '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'
+ },
+ Shapes: {
+ 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 69c30346975..6de2470d8bc 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 00000000000..1c6bb206701
--- /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 00000000000..38e85efb29c
--- /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 f359e3d2737..5636e6563d2 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 ac8e43003fa..e78b3c7f15c 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 889926d812b..bd4cf2d1e95 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 a1dd42d2c23..72416416510 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 99ffbe0b540..30e68157655 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 9f8a3129ada..138d72df983 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 18c5b8465eb..2c28311d57c 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 18a2ad1f5cc..1fa18ee9c51 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 346bfc5db10..17216a84422 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 41602dd257f..d6f6a748413 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 8d56f400d39..a1e728bdda7 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 fc483b5f475..70e03e534cb 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 ea0c42cb90a..69f7b10faa2 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 074e0a969ff..2f7b71a45da 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);
},
+ cleanUpCrosshairs: () => {
+ // if the crosshairs tool is active, deactivate it and set window level active
+ // since we are going back to main non-mpr HP
+ const activeViewportToolGroup = toolGroupService.getToolGroup(null);
+
+ if (activeViewportToolGroup._toolInstances?.Crosshairs?.mode === Enums.ToolModes.Active) {
+ actions.toolbarServiceRecordInteraction({
+ interactionType: 'tool',
+ commands: [
+ {
+ commandOptions: {
+ toolName: 'WindowLevel',
+ },
+ context: 'CORNERSTONE',
+ },
+ ],
+ });
+ }
+ },
toggleCine: () => {
const { viewports } = viewportGridService.getState();
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 +256,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 +266,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 +283,12 @@ function commandsModule({
toolbarServiceRecordInteraction: props => {
toolbarService.recordInteraction(props);
},
-
- setToolActive: ({ toolName, toolGroupId = null }) => {
+ // Enable or disable a toggleable command, without calling the activation
+ // Used to setup already active tools from hanging protocols
+ setToolbarToggled: props => {
+ toolbarService.setToggled(props.toolId, props.isActive ?? true);
+ },
+ setToolActive: ({ toolName, toolGroupId = null, toggledState }) => {
if (toolName === 'Crosshairs') {
const activeViewportToolGroup = toolGroupService.getToolGroup(null);
@@ -309,29 +305,15 @@ function commandsModule({
}
}
- const { viewports } = viewportGridService.getState() || {
- viewports: [],
- };
-
- const toolGroup = toolGroupService.getToolGroup(toolGroupId);
- const toolGroupViewportIds = toolGroup?.getViewportIds?.();
+ const { viewports } = viewportGridService.getState();
- // if toolGroup has been destroyed, or its viewports have been removed
- if (!toolGroupViewportIds || !toolGroupViewportIds.length) {
+ if (!viewports.size) {
return;
}
- const filteredViewports = viewports.filter(viewport => {
- if (!viewport.viewportOptions) {
- return false;
- }
-
- return toolGroupViewportIds.includes(
- viewport.viewportOptions.viewportId
- );
- });
+ const toolGroup = toolGroupService.getToolGroup(toolGroupId);
- if (!filteredViewports.length) {
+ if (!toolGroup) {
return;
}
@@ -357,6 +339,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 +357,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 +376,7 @@ function commandsModule({
content: CornerstoneViewportDownloadForm,
title: 'Download High Quality Image',
contentProps: {
- activeViewportIndex,
+ activeViewportId,
onClose: uiModalService.hide,
cornerstoneViewportService,
},
@@ -457,11 +443,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();
@@ -476,7 +460,7 @@ function commandsModule({
viewport.resetProperties();
viewport.resetCamera();
} else {
- // Todo: add reset properties for volume viewport
+ viewport.resetProperties();
viewport.resetCamera();
}
@@ -514,9 +498,7 @@ function commandsModule({
}
viewport = enabledElement.viewport;
} else {
- viewport = cornerstoneViewportService.getCornerstoneViewport(
- gridViewport.id
- );
+ viewport = cornerstoneViewportService.getCornerstoneViewport(gridViewport.id);
}
// Get number of slices
@@ -526,14 +508,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 +534,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,37 +551,29 @@ 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,
servicesManager,
toggledState,
});
},
- toggleReferenceLines: ({ toggledState }) => {
- const { activeViewportIndex } = viewportGridService.getState();
- const viewportInfo = cornerstoneViewportService.getViewportInfoByIndex(
- activeViewportIndex
- );
+ setSourceViewportForReferenceLinesTool: ({ toggledState, viewportId }) => {
+ if (!viewportId) {
+ const { activeViewportId } = viewportGridService.getState();
+ viewportId = activeViewportId;
+ }
- const viewportId = viewportInfo.getViewportId();
const toolGroup = toolGroupService.getToolGroupForViewport(viewportId);
- if (!toggledState) {
- toolGroup.setToolDisabled(ReferenceLinesTool.toolName);
- }
-
toolGroup.setToolConfiguration(
ReferenceLinesTool.toolName,
{
@@ -616,7 +581,9 @@ function commandsModule({
},
true // overwrite
);
- toolGroup.setToolEnabled(ReferenceLinesTool.toolName);
+ },
+ storePresentation: ({ viewportId }) => {
+ cornerstoneViewportService.storePresentation({ viewportId });
},
};
@@ -673,10 +640,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 +707,17 @@ function commandsModule({
toggleStackImageSync: {
commandFn: actions.toggleStackImageSync,
},
- toggleReferenceLines: {
- commandFn: actions.toggleReferenceLines,
+ setSourceViewportForReferenceLinesTool: {
+ commandFn: actions.setSourceViewportForReferenceLinesTool,
+ },
+ storePresentation: {
+ commandFn: actions.storePresentation,
+ },
+ setToolbarToggled: {
+ commandFn: actions.setToolbarToggled,
+ },
+ cleanUpCrosshairs: {
+ commandFn: actions.cleanUpCrosshairs,
},
};
diff --git a/extensions/cornerstone/src/components/CinePlayer/CinePlayer.tsx b/extensions/cornerstone/src/components/CinePlayer/CinePlayer.tsx
new file mode 100644
index 00000000000..92bb1510327
--- /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 00000000000..d31d4bed763
--- /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 55ddf7922e9..d37d2a6a649 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 26e596e9522..8284ee07055 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 8e431ac525e..2f33456a42c 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 d16ee4b9f05..c09d9698810 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 4a07f4e635a..99755fa73a5 100644
--- a/extensions/cornerstone/src/init.tsx
+++ b/extensions/cornerstone/src/init.tsx
@@ -12,8 +12,9 @@ import {
imageLoadPoolManager,
Settings,
utilities as csUtilities,
+ Enums as csEnums,
} from '@cornerstonejs/core';
-import { Enums, utilities, ReferenceLinesTool } from '@cornerstonejs/tools';
+import { Enums } from '@cornerstonejs/tools';
import { cornerstoneStreamingImageVolumeLoader } from '@cornerstonejs/streaming-image-volume-loader';
import initWADOImageLoader from './initWADOImageLoader';
@@ -26,6 +27,8 @@ import nthLoader from './utils/nthLoader';
import interleaveTopToBottom from './utils/interleaveTopToBottom';
import initContextMenu from './initContextMenu';
import initDoubleClick from './initDoubleClick';
+import { CornerstoneServices } from './types';
+import initViewTiming from './utils/initViewTiming';
// TODO: Cypress tests are currently grabbing this from the window?
window.cornerstone = cornerstone;
@@ -40,48 +43,61 @@ export default async function init({
configuration,
appConfig,
}: Types.Extensions.ExtensionParams): Promise {
- await cs3DInit();
+ // Note: this should run first before initializing the cornerstone
+ // DO NOT CHANGE THE ORDER
+ const value = appConfig.useSharedArrayBuffer;
+ let sharedArrayBufferDisabled = false;
+
+ if (value === 'AUTO') {
+ cornerstone.setUseSharedArrayBuffer(csEnums.SharedArrayBufferModes.AUTO);
+ } else if (value === 'FALSE' || value === false) {
+ cornerstone.setUseSharedArrayBuffer(csEnums.SharedArrayBufferModes.FALSE);
+ sharedArrayBufferDisabled = true;
+ } else {
+ cornerstone.setUseSharedArrayBuffer(csEnums.SharedArrayBufferModes.TRUE);
+ }
+
+ 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));
+
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,
cornerstoneViewportService,
hangingProtocolService,
toolGroupService,
+ toolbarService,
viewportGridService,
stateSyncService,
- } = servicesManager.services;
+ } = servicesManager.services as CornerstoneServices;
window.services = servicesManager.services;
window.extensionManager = extensionManager;
@@ -89,20 +105,18 @@ export default async function init({
if (
appConfig.showWarningMessageForCrossOrigin &&
- !window.crossOriginIsolated
+ !window.crossOriginIsolated &&
+ !sharedArrayBufferDisabled
) {
uiNotificationService.show({
title: 'Cross Origin Isolation',
message:
- 'Cross Origin Isolation is not enabled, volume rendering will not work (e.g., MPR)',
+ 'Cross Origin Isolation is not enabled, read more about it here: https://docs.ohif.org/faq/',
type: 'warning',
});
}
- if (
- appConfig.showCPUFallbackMessage &&
- cornerstone.getShouldUseCPURendering()
- ) {
+ if (appConfig.showCPUFallbackMessage && cornerstone.getShouldUseCPURendering()) {
_showCPURenderingModal(uiModalService, hangingProtocolService);
}
@@ -122,18 +136,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 +152,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 +170,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 +183,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);
}
}
);
@@ -221,16 +210,50 @@ export default async function init({
commandsManager,
});
- const newStackCallback = evt => {
+ /**
+ * When a viewport gets a new display set, this call will go through all the
+ * active tools in the toolbar, and call any commands registered in the
+ * toolbar service with a callback to re-enable on displaying the viewport.
+ */
+ const toolbarEventListener = evt => {
const { element } = evt.detail;
- utilities.stackPrefetch.enable(element);
+ const activeTools = toolbarService.getActiveTools();
+
+ activeTools.forEach(tool => {
+ const toolData = toolbarService.getNestedButton(tool);
+ const commands = toolData?.listeners?.[evt.type];
+ commandsManager.run(commands, { element, evt });
+ });
+ };
+
+ /** Listens for active viewport events and fires the toolbar listeners */
+ const activeViewportEventListener = evt => {
+ const { viewportId } = evt;
+ const toolGroup = toolGroupService.getToolGroupForViewport(viewportId);
+
+ const activeTools = toolbarService.getActiveTools();
+
+ activeTools.forEach(tool => {
+ if (!toolGroup?._toolInstances?.[tool]) {
+ return;
+ }
+
+ // check if tool is active on the new viewport
+ const toolEnabled = toolGroup._toolInstances[tool].mode === Enums.ToolModes.Enabled;
+
+ if (!toolEnabled) {
+ return;
+ }
+
+ const button = toolbarService.getNestedButton(tool);
+ const commands = button?.listeners?.[evt.type];
+ commandsManager.run(commands, { viewportId, evt });
+ });
};
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,
@@ -252,14 +275,18 @@ export default async function init({
}
};
+ eventTarget.addEventListener(EVENTS.STACK_VIEWPORT_NEW_STACK, evt => {
+ const { element } = evt.detail;
+ cornerstoneTools.utilities.stackContextPrefetch.enable(element);
+ });
+
function elementEnabledHandler(evt) {
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, toolbarEventListener);
+
+ initViewTiming({ element, eventTarget });
}
function elementDisabledHandler(evt) {
@@ -274,58 +301,23 @@ 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}`;
- const toolGroup = toolGroupService.getToolGroupForViewport(viewportId);
-
- if (!toolGroup || !toolGroup._toolInstances?.['ReferenceLines']) {
- return;
- }
-
- // check if reference lines are active
- const referenceLinesEnabled =
- toolGroup._toolInstances['ReferenceLines'].mode ===
- Enums.ToolModes.Enabled;
-
- if (!referenceLinesEnabled) {
- return;
- }
-
- toolGroup.setToolConfiguration(
- ReferenceLinesTool.toolName,
- {
- sourceViewportId: viewportId,
- },
- true // overwrite
+ viewportGridService.EVENTS.ACTIVE_VIEWPORT_ID_CHANGED,
+ activeViewportEventListener
);
-
- // make sure to set it to enabled again since we want to recalculate
- // the source-target lines
- toolGroup.setToolEnabled(ReferenceLinesTool.toolName);
}
- );
-}
function CPUModal() {
return (
);
diff --git a/extensions/cornerstone/src/initContextMenu.ts b/extensions/cornerstone/src/initContextMenu.ts
index c46e5053e94..488fdf85879 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 9549b17f911..767b607a772 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 da8fb8fa49f..049d72cbee5 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 3a883cc79da..2ab5cce55be 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 f5884643dba..1beda3885b7 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 31ea90cb236..a3db943ab27 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,13 @@ class CornerstoneCacheService {
for (const segmentation of segmentations) {
const segDisplaySetInstanceUID = segmentation.displaySetInstanceUID;
+ const segDisplaySet = displaySetService.getDisplaySetByUID(segDisplaySetInstanceUID);
+
+ const instance = segDisplaySet.instances?.[0] || segDisplaySet.instance;
const shouldDisplaySeg = segmentationService.shouldRenderSegmentation(
viewportDisplaySetInstanceUIDs,
- segDisplaySetInstanceUID
+ instance.FrameOfReferenceUID
);
if (shouldDisplaySeg) {
@@ -268,10 +242,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 f17ec5c7048..b613074128c 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 c03b0569860..eda99b7b2f4 100644
--- a/extensions/cornerstone/src/services/SegmentationService/SegmentationService.ts
+++ b/extensions/cornerstone/src/services/SegmentationService/SegmentationService.ts
@@ -7,7 +7,6 @@ import {
geometryLoader,
eventTarget,
getEnabledElementByIds,
- metaData,
utilities as csUtils,
volumeLoader,
} from '@cornerstonejs/core';
@@ -21,11 +20,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 +37,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 +58,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 +98,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._getApplicableToolGroupId();
- 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 +154,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 +164,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) {
@@ -204,17 +189,12 @@ class SegmentationService extends PubSubService {
);
}
- if (active !== undefined) {
+ if (active === true) {
this._setActiveSegment(segmentationId, segmentIndex, suppressEvents);
}
if (isLocked !== undefined) {
- this._setSegmentLocked(
- segmentationId,
- segmentIndex,
- isLocked,
- suppressEvents
- );
+ this._setSegmentLocked(segmentationId, segmentIndex, isLocked, suppressEvents);
}
}
@@ -285,9 +265,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 +291,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 +360,14 @@ class SegmentationService extends PubSubService {
this._setSegmentOpacity(segmentationId, segmentIndex, opacity, toolGroupId);
}
- public setActiveSegmentationForToolGroup(
- segmentationId: string,
- toolGroupId?: string
- ): void {
- toolGroupId = toolGroupId ?? this._getFirstToolGroupId();
+ public setActiveSegmentationForToolGroup(segmentationId: string, toolGroupId?: string): void {
+ toolGroupId = toolGroupId ?? this._getApplicableToolGroupId();
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 +383,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 +396,24 @@ 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]]);
+ }
+
+ public getActiveSegmentation(): Segmentation {
+ const segmentations = this.getSegmentations();
+
+ return segmentations.find(segmentation => segmentation.isActive);
+ }
+
+ public getActiveSegment() {
+ const activeSegmentation = this.getActiveSegmentation();
+ const { activeSegmentIndex, segments } = activeSegmentation;
+
+ if (activeSegmentIndex === null) {
+ return;
+ }
+
+ return segments[activeSegmentIndex];
}
/**
@@ -477,8 +452,7 @@ class SegmentationService extends PubSubService {
}
const representationType = segmentation.type;
- const representationData =
- segmentation.representationData[representationType];
+ const representationData = segmentation.representationData[representationType];
cstSegmentation.addSegmentations([
{
segmentationId,
@@ -491,12 +465,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 +481,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 +518,7 @@ class SegmentationService extends PubSubService {
id: segmentationId,
displaySetInstanceUID: segDisplaySet.displaySetInstanceUID,
type: representationType,
+ label: segDisplaySet.SeriesDescription,
representationData: {
[LABELMAP]: {
volumeId: segmentationId,
@@ -562,12 +539,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 +550,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: window.SharedArrayBuffer,
+ },
+ });
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 +599,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 +649,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 +661,7 @@ class SegmentationService extends PubSubService {
id: segmentationId,
displaySetInstanceUID: rtDisplaySetUID,
type: representationType,
+ label: rtDisplaySet.SeriesDescription,
representationData: {
[CONTOUR]: {
geometryIds,
@@ -816,45 +689,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 +769,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 +873,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 +897,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);
}
@@ -961,7 +929,7 @@ class SegmentationService extends PubSubService {
}
const segmentation = this.getSegmentation(segmentationId);
- toolGroupId = toolGroupId ?? this._getFirstToolGroupId();
+ toolGroupId = toolGroupId ?? this._getApplicableToolGroupId();
const segmentationRepresentation = this._getSegmentationRepresentation(
segmentationId,
@@ -972,9 +940,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 +959,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;
@@ -1015,7 +980,7 @@ class SegmentationService extends PubSubService {
volumeId: segmentationId,
targetBuffer: {
type: 'Uint8Array',
- sharedArrayBuffer: true,
+ sharedArrayBuffer: window.SharedArrayBuffer,
},
});
@@ -1029,6 +994,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 +1023,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 +1069,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 +1091,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 +1135,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 +1158,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 +1283,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 +1305,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,24 +1323,26 @@ class SegmentationService extends PubSubService {
if (wasActive) {
const remainingSegmentations = this._getSegmentations();
- if (remainingSegmentations.length) {
- const { id } = remainingSegmentations[0];
+ const remainingHydratedSegmentations = remainingSegmentations.filter(
+ segmentation => segmentation.hydrated
+ );
+
+ if (remainingHydratedSegmentations.length) {
+ const { id } = remainingHydratedSegmentations[0];
- this._setActiveSegmentationForToolGroup(
- id,
- this._getFirstToolGroupId(),
- false
- );
+ this._setActiveSegmentationForToolGroup(id, this._getApplicableToolGroupId(), false);
}
}
+ this._setDisplaySetIsHydrated(segmentationId, false);
+
this._broadcastEvent(this.EVENTS.SEGMENTATION_REMOVED, {
segmentationId,
});
}
public getConfiguration = (toolGroupId?: string): SegmentationConfig => {
- toolGroupId = toolGroupId ?? this._getFirstToolGroupId();
+ toolGroupId = toolGroupId ?? this._getApplicableToolGroupId();
const brushSize = 1;
// const brushSize = cstUtils.segmentation.getBrushSizeForToolGroup(
@@ -1405,9 +1354,8 @@ class SegmentationService extends PubSubService {
// toolGroupId
// );
- const segmentationRepresentations = this.getSegmentationRepresentationsForToolGroup(
- toolGroupId
- );
+ const segmentationRepresentations =
+ this.getSegmentationRepresentationsForToolGroup(toolGroupId);
const typeToUse = segmentationRepresentations?.[0]?.type || LABELMAP;
@@ -1465,11 +1413,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 +1447,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 +1458,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 +1477,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 +1490,8 @@ class SegmentationService extends PubSubService {
}
}
- public shouldRenderSegmentation(
- viewportDisplaySetInstanceUIDs,
- segDisplaySetInstanceUID
- ) {
- if (
- !viewportDisplaySetInstanceUIDs ||
- !viewportDisplaySetInstanceUIDs.length
- ) {
+ public shouldRenderSegmentation(viewportDisplaySetInstanceUIDs, segmentationFrameOfReferenceUID) {
+ if (!viewportDisplaySetInstanceUIDs?.length) {
return false;
}
@@ -1570,26 +1499,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 +1550,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 +1564,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 +1582,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 +1613,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,12 +1634,10 @@ 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();
+ toolGroupId = toolGroupId ?? this._getApplicableToolGroupId();
const segmentationRepresentation = this._getSegmentationRepresentation(
segmentationId,
@@ -1744,9 +1645,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 +1710,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, {
@@ -1838,12 +1731,12 @@ class SegmentationService extends PubSubService {
toolGroupId?: string,
suppressEvents = false
) {
- toolGroupId = toolGroupId ?? this._getFirstToolGroupId();
+ toolGroupId = toolGroupId ?? this._getApplicableToolGroupId();
- 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 +1745,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,12 +1787,10 @@ 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();
+ toolGroupId = toolGroupId ?? this._getApplicableToolGroupId();
const segmentationRepresentation = this._getSegmentationRepresentation(
segmentationId,
@@ -1909,9 +1798,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 +1839,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 +1852,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 +1926,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 +1962,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 +1978,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 +1996,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 +2025,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 +2046,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 +2074,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 +2086,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;
}
@@ -2252,11 +2107,21 @@ class SegmentationService extends PubSubService {
}
}
- private _getFirstToolGroupId = () => {
- const { toolGroupService } = this.servicesManager.services;
- const toolGroupIds = toolGroupService.getToolGroupIds();
+ private _getApplicableToolGroupId = () => {
+ const { toolGroupService, viewportGridService, cornerstoneViewportService } =
+ this.servicesManager.services;
+
+ const viewportInfo = cornerstoneViewportService.getViewportInfo(
+ viewportGridService.getActiveViewportId()
+ );
+
+ if (!viewportInfo) {
+ const toolGroupIds = toolGroupService.getToolGroupIds();
+
+ return toolGroupIds[0];
+ }
- return toolGroupIds[0];
+ return viewportInfo.getToolGroupId();
};
private getNextColorLUTIndex = (): number => {
diff --git a/extensions/cornerstone/src/services/SegmentationService/SegmentationServiceTypes.ts b/extensions/cornerstone/src/services/SegmentationService/SegmentationServiceTypes.ts
index e170197c36f..d6d231fd0ab 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 39e919fc5de..0b1c22fb2bc 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 b8f6c970985..3a85342b381 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 d20ef2f76b3..497df2d544d 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,68 +170,86 @@ 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();
const background = viewportInfo.getBackground();
const orientation = viewportInfo.getOrientation();
+ const displayArea = viewportInfo.getDisplayArea();
const viewportInput: Types.PublicViewportInput = {
viewportId,
@@ -282,15 +258,30 @@ class CornerstoneViewportService extends PubSubService
defaultOptions: {
background,
orientation,
+ displayArea,
},
};
+ // 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 +290,6 @@ class CornerstoneViewportService extends PubSubService
// invalid data.
this._broadcastEvent(this.EVENTS.VIEWPORT_DATA_CHANGED, {
viewportData,
- viewportIndex,
viewportId,
});
}
@@ -309,11 +299,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 +308,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 +320,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 +348,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 +373,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 +388,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 +410,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 +465,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 +480,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 +542,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 +563,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 +572,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 +584,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 +626,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 +649,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 +684,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 +707,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 +731,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 +765,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 87168cb7f67..e96a7d70293 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 1f5247bb1f7..685652279f7 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';
@@ -24,6 +21,7 @@ export type ViewportOptions = {
presentationIds?: UITypes.PresentationIds;
orientation?: Enums.OrientationAxis;
background?: Types.Point3;
+ displayArea?: Types.DisplayArea;
syncGroups?: SyncGroup[];
initialImageOptions?: InitialImageOptions;
customViewportProps?: Record;
@@ -42,6 +40,7 @@ export type PublicViewportOptions = {
viewportId?: string;
orientation?: Enums.OrientationAxis;
background?: Types.Point3;
+ displayArea?: Types.DisplayArea;
syncGroups?: SyncGroup[];
initialImageOptions?: InitialImageOptions;
customViewportProps?: Record;
@@ -90,12 +89,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 +101,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 +118,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 +146,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 +159,6 @@ class ViewportInfo {
return this.viewportData;
}
- public getViewportIndex(): number {
- return this.viewportIndex;
- }
-
public getElement(): HTMLDivElement {
return this.element;
}
@@ -183,13 +169,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 +184,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 +198,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 +226,8 @@ class ViewportInfo {
toolGroupId,
presentationIds,
});
+
+ return this.viewportOptions;
}
public setViewportOptions(viewportOptions: ViewportOptions): void {
@@ -254,9 +238,7 @@ class ViewportInfo {
return this.viewportOptions;
}
- public setDisplaySetOptions(
- displaySetOptions: Array
- ): void {
+ public setDisplaySetOptions(displaySetOptions: Array): void {
this.displaySetOptions = displaySetOptions;
}
@@ -285,6 +267,10 @@ class ViewportInfo {
return this.viewportOptions.orientation;
}
+ public getDisplayArea(): Types.DisplayArea {
+ return this.viewportOptions.displayArea;
+ }
+
public getInitialImageOptions(): InitialImageOptions {
return this.viewportOptions.initialImageOptions;
}
diff --git a/extensions/cornerstone/src/state.ts b/extensions/cornerstone/src/state.ts
index e1d67a56159..76afcdbb8d6 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 1db404034c5..3b4a9bede0b 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 00000000000..20cb8b9aeef
--- /dev/null
+++ b/extensions/cornerstone/src/tools/ImageOverlayViewerTool.tsx
@@ -0,0 +1,259 @@
+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 instanceof Array) {
+ pixelData = overlay.pixelData[0];
+ } 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 2f52dc9ff90..b7b791ae6a3 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 6c729817d6e..c8db85fb761 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 cfab216e789..4de163c791c 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;
@@ -162,15 +142,16 @@ const CornerstoneViewportDownloadForm = ({
const properties = viewport.getProperties();
downloadViewport.setStack([imageId]).then(() => {
- downloadViewport.setProperties(properties);
-
- const newWidth = Math.min(width || image.width, MAX_TEXTURE_SIZE);
- const newHeight = Math.min(
- height || image.height,
- MAX_TEXTURE_SIZE
- );
-
- resolve({ width: newWidth, height: newHeight });
+ try {
+ downloadViewport.setProperties(properties);
+ const newWidth = Math.min(width || image.width, MAX_TEXTURE_SIZE);
+ const newHeight = Math.min(height || image.height, MAX_TEXTURE_SIZE);
+
+ resolve({ width: newWidth, height: newHeight });
+ } catch (e) {
+ // Happens on clicking the cancel button
+ console.warn('Unable to set properties', e);
+ }
});
} else if (downloadViewport instanceof VolumeViewport) {
const actors = viewport.getActors();
@@ -190,31 +171,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 +237,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 64465e597e9..cfbad0745b1 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 b141ece63b5..37d5021c509 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 d188ece9af0..e63e85f791d 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 4bc7cb449f3..37dca4c10bc 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 8ac7b2cb518..6e47fe80765 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 47a5ede85b3..9a5dd71de10 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 d8eae131a21..b380a9350b3 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 09bfc0b1ec2..38df66d9587 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/initViewTiming.ts b/extensions/cornerstone/src/utils/initViewTiming.ts
new file mode 100644
index 00000000000..8c4ad9f03de
--- /dev/null
+++ b/extensions/cornerstone/src/utils/initViewTiming.ts
@@ -0,0 +1,45 @@
+import { log, Types } from '@ohif/core';
+import { EVENTS } from '@cornerstonejs/core';
+
+const { TimingEnum } = Types;
+
+const IMAGE_TIMING_KEYS = [
+ TimingEnum.DISPLAY_SETS_TO_ALL_IMAGES,
+ TimingEnum.DISPLAY_SETS_TO_FIRST_IMAGE,
+ TimingEnum.STUDY_TO_FIRST_IMAGE,
+];
+
+const imageTiming = {
+ viewportsWaiting: 0,
+};
+
+/**
+ * Defines the initial view timing reporting.
+ * This allows knowing how many viewports are waiting for initial views and
+ * when the IMAGE_RENDERED gets sent out.
+ * The first image rendered will fire the FIRST_IMAGE timeEnd logs, while
+ * the last of the enabled viewport will fire the ALL_IMAGES timeEnd logs.
+ *
+ */
+
+export default function initViewTiming({ element }) {
+ if (!IMAGE_TIMING_KEYS.find(key => log.timingKeys[key])) {
+ return;
+ }
+ imageTiming.viewportsWaiting += 1;
+ element.addEventListener(EVENTS.IMAGE_RENDERED, imageRenderedListener);
+}
+
+function imageRenderedListener(evt) {
+ if (evt.detail.viewportStatus === 'preRender') {
+ return;
+ }
+ log.timeEnd(TimingEnum.DISPLAY_SETS_TO_FIRST_IMAGE);
+ log.timeEnd(TimingEnum.STUDY_TO_FIRST_IMAGE);
+ log.timeEnd(TimingEnum.SCRIPT_TO_VIEW);
+ imageTiming.viewportsWaiting -= 1;
+ evt.detail.element.removeEventListener(EVENTS.IMAGE_RENDERED, imageRenderedListener);
+ if (!imageTiming.viewportsWaiting) {
+ log.timeEnd(TimingEnum.DISPLAY_SETS_TO_ALL_IMAGES);
+ }
+}
diff --git a/extensions/cornerstone/src/utils/interleave.js b/extensions/cornerstone/src/utils/interleave.js
index 05fe2cab19a..a21d3fb7e0b 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 0047f0ac0ab..d8f64b5d838 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 162bb5588cf..0caf4037292 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 dfbe9aa62af..5708582a46b 100644
--- a/extensions/cornerstone/src/utils/measurementServiceMappings/Angle.ts
+++ b/extensions/cornerstone/src/utils/measurementServiceMappings/Angle.ts
@@ -1,9 +1,10 @@
import SUPPORTED_TOOLS from './constants/supportedTools';
+import { getDisplayUnit } from './utils';
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 +33,7 @@ const Angle = {
throw new Error('Tool not supported');
}
- const {
- SOPInstanceUID,
- SeriesInstanceUID,
- StudyInstanceUID,
- } = getSOPInstanceAttributes(
+ const { SOPInstanceUID, SeriesInstanceUID, StudyInstanceUID } = getSOPInstanceAttributes(
referencedImageId,
CornerstoneViewportService,
viewportId
@@ -55,14 +52,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 +92,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 +167,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,10 +178,12 @@ 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})`
+ `${roundedAngle} ${getDisplayUnit(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 9a6f6e49b3b..d5a7129da29 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 781a0f909fa..11e1c7c02e7 100644
--- a/extensions/cornerstone/src/utils/measurementServiceMappings/Bidirectional.ts
+++ b/extensions/cornerstone/src/utils/measurementServiceMappings/Bidirectional.ts
@@ -3,6 +3,7 @@ import { annotation } from '@cornerstonejs/tools';
import SUPPORTED_TOOLS from './constants/supportedTools';
import getSOPInstanceAttributes from './utils/getSOPInstanceAttributes';
import { utils } from '@ohif/core';
+import { getDisplayUnit } from './utils';
const Bidirectional = {
toAnnotation: measurement => {},
@@ -27,11 +28,7 @@ const Bidirectional = {
throw new Error('Tool not supported');
}
- const {
- SOPInstanceUID,
- SeriesInstanceUID,
- StudyInstanceUID,
- } = getSOPInstanceAttributes(
+ const { SOPInstanceUID, SeriesInstanceUID, StudyInstanceUID } = getSOPInstanceAttributes(
referencedImageId,
cornerstoneViewportService,
viewportId
@@ -50,14 +47,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 +87,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 +100,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 +130,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) {
@@ -175,19 +162,11 @@ function getDisplayText(mappedAnnotations, displaySet) {
const displayText = [];
// Area is the same for all series
- const {
- length,
- width,
- SeriesNumber,
- SOPInstanceUID,
- frameNumber,
- } = mappedAnnotations[0];
+ const { length, width, unit, SeriesNumber, SOPInstanceUID, frameNumber } = mappedAnnotations[0];
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 +177,9 @@ function getDisplayText(mappedAnnotations, displaySet) {
const frameText = displaySet.isMultiFrame ? ` F: ${frameNumber}` : '';
displayText.push(
- `L: ${roundedLength} mm (S: ${SeriesNumber}${instanceText}${frameText})`
+ `L: ${roundedLength} ${getDisplayUnit(unit)} (S: ${SeriesNumber}${instanceText}${frameText})`
);
- displayText.push(`W: ${roundedWidth} mm`);
+ displayText.push(`W: ${roundedWidth} ${getDisplayUnit(unit)}`);
return displayText;
}
diff --git a/extensions/cornerstone/src/utils/measurementServiceMappings/CircleROI.ts b/extensions/cornerstone/src/utils/measurementServiceMappings/CircleROI.ts
index c55d7da4bd6..6ec79919bda 100644
--- a/extensions/cornerstone/src/utils/measurementServiceMappings/CircleROI.ts
+++ b/extensions/cornerstone/src/utils/measurementServiceMappings/CircleROI.ts
@@ -1,6 +1,6 @@
import SUPPORTED_TOOLS from './constants/supportedTools';
+import { getDisplayUnit } from './utils';
import getSOPInstanceAttributes from './utils/getSOPInstanceAttributes';
-import getModalityUnit from './utils/getModalityUnit';
import { utils } from '@ohif/core';
const CircleROI = {
@@ -26,11 +26,7 @@ const CircleROI = {
throw new Error('Tool not supported');
}
- const {
- SOPInstanceUID,
- SeriesInstanceUID,
- StudyInstanceUID,
- } = getSOPInstanceAttributes(
+ const { SOPInstanceUID, SeriesInstanceUID, StudyInstanceUID } = getSOPInstanceAttributes(
referencedImageId,
CornerstoneViewportService,
viewportId
@@ -49,14 +45,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 +86,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 +99,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 +107,12 @@ function getMappedAnnotations(annotation, DisplaySetService) {
SeriesNumber,
frameNumber,
Modality,
- unit,
+ unit: modalityUnit,
mean,
stdDev,
max,
area,
+ areaUnit,
});
});
@@ -146,19 +133,14 @@ 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;
}
- columns.push(
- `max (${unit})`,
- `mean (${unit})`,
- `std (${unit})`,
- `area (mm2)`
- );
- values.push(max, mean, stdDev, area);
+ columns.push(`max (${unit})`, `mean (${unit})`, `std (${unit})`, 'Area', 'Unit');
+ values.push(max, mean, stdDev, area, areaUnit);
});
if (FrameOfReferenceUID) {
@@ -188,11 +170,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 +184,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} ${getDisplayUnit(areaUnit)}`);
// Todo: we need a better UI for displaying all these information
mappedAnnotations.forEach(mappedAnnotation => {
@@ -213,7 +193,7 @@ function getDisplayText(mappedAnnotations, displaySet) {
let maxStr = '';
if (max) {
const roundedMax = utils.roundNumber(max, 2);
- maxStr = `Max: ${roundedMax} ${unit} `;
+ maxStr = `Max: ${roundedMax} ${getDisplayUnit(unit)} `;
}
const str = `${maxStr}(S:${SeriesNumber}${instanceText}${frameText})`;
diff --git a/extensions/cornerstone/src/utils/measurementServiceMappings/CobbAngle.ts b/extensions/cornerstone/src/utils/measurementServiceMappings/CobbAngle.ts
index 53dace2b40b..f61356c29d8 100644
--- a/extensions/cornerstone/src/utils/measurementServiceMappings/CobbAngle.ts
+++ b/extensions/cornerstone/src/utils/measurementServiceMappings/CobbAngle.ts
@@ -1,9 +1,10 @@
import SUPPORTED_TOOLS from './constants/supportedTools';
+import { getDisplayUnit } from './utils';
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 +33,7 @@ const CobbAngle = {
throw new Error('Tool not supported');
}
- const {
- SOPInstanceUID,
- SeriesInstanceUID,
- StudyInstanceUID,
- } = getSOPInstanceAttributes(
+ const { SOPInstanceUID, SeriesInstanceUID, StudyInstanceUID } = getSOPInstanceAttributes(
referencedImageId,
CornerstoneViewportService,
viewportId
@@ -55,14 +52,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 +92,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 +167,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,10 +178,12 @@ 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})`
+ `${roundedAngle} ${getDisplayUnit(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 00684260225..a38b6f8357c 100644
--- a/extensions/cornerstone/src/utils/measurementServiceMappings/EllipticalROI.ts
+++ b/extensions/cornerstone/src/utils/measurementServiceMappings/EllipticalROI.ts
@@ -1,6 +1,6 @@
import SUPPORTED_TOOLS from './constants/supportedTools';
+import { getDisplayUnit } from './utils';
import getSOPInstanceAttributes from './utils/getSOPInstanceAttributes';
-import getModalityUnit from './utils/getModalityUnit';
import { utils } from '@ohif/core';
const EllipticalROI = {
@@ -26,11 +26,7 @@ const EllipticalROI = {
throw new Error('Tool not supported');
}
- const {
- SOPInstanceUID,
- SeriesInstanceUID,
- StudyInstanceUID,
- } = getSOPInstanceAttributes(
+ const { SOPInstanceUID, SeriesInstanceUID, StudyInstanceUID } = getSOPInstanceAttributes(
referencedImageId,
cornerstoneViewportService,
viewportId
@@ -49,14 +45,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 +86,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 +99,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 +107,8 @@ function getMappedAnnotations(annotation, displaySetService) {
SeriesNumber,
frameNumber,
Modality,
- unit,
+ unit: modalityUnit,
+ areaUnit,
mean,
stdDev,
max,
@@ -146,19 +133,14 @@ 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;
}
- columns.push(
- `max (${unit})`,
- `mean (${unit})`,
- `std (${unit})`,
- `area (mm2)`
- );
- values.push(max, mean, stdDev, area);
+ columns.push(`max (${unit})`, `mean (${unit})`, `std (${unit})`, 'Area', 'Unit');
+ values.push(max, mean, stdDev, area, areaUnit);
});
if (FrameOfReferenceUID) {
@@ -188,11 +170,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 +182,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} ${getDisplayUnit(areaUnit)}`);
// Todo: we need a better UI for displaying all these information
mappedAnnotations.forEach(mappedAnnotation => {
@@ -213,7 +192,7 @@ function getDisplayText(mappedAnnotations, displaySet) {
let maxStr = '';
if (max) {
const roundedMax = utils.roundNumber(max, 2);
- maxStr = `Max: ${roundedMax} ${unit} `;
+ maxStr = `Max: ${roundedMax} ${getDisplayUnit(unit)} `;
}
const str = `${maxStr}(S:${SeriesNumber}${instanceText}${frameText})`;
diff --git a/extensions/cornerstone/src/utils/measurementServiceMappings/Length.ts b/extensions/cornerstone/src/utils/measurementServiceMappings/Length.ts
index 44cf64ac067..5c5072d2c19 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 71ded00c1f2..b6db513b66b 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 01f1178b9c9..c7cdb3e41e9 100644
--- a/extensions/cornerstone/src/utils/measurementServiceMappings/RectangleROI.ts
+++ b/extensions/cornerstone/src/utils/measurementServiceMappings/RectangleROI.ts
@@ -1,6 +1,6 @@
import SUPPORTED_TOOLS from './constants/supportedTools';
+import { getDisplayUnit } from './utils';
import getSOPInstanceAttributes from './utils/getSOPInstanceAttributes';
-import getModalityUnit from './utils/getModalityUnit';
import { utils } from '@ohif/core';
const RectangleROI = {
@@ -26,12 +26,11 @@ 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 +45,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,9 +86,7 @@ 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 } =
@@ -106,8 +99,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 +107,12 @@ function getMappedAnnotations(annotation, DisplaySetService) {
SeriesNumber,
frameNumber,
Modality,
- unit,
+ unit: modalityUnit,
mean,
stdDev,
max,
area,
+ areaUnit,
});
});
@@ -140,19 +133,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 +170,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 +184,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} ${getDisplayUnit(areaUnit)}`);
// Todo: we need a better UI for displaying all these information
mappedAnnotations.forEach(mappedAnnotation => {
@@ -207,7 +193,7 @@ function getDisplayText(mappedAnnotations, displaySet) {
let maxStr = '';
if (max) {
const roundedMax = utils.roundNumber(max, 2);
- maxStr = `Max: ${roundedMax} ${unit} `;
+ maxStr = `Max: ${roundedMax} ${getDisplayUnit(unit)} `;
}
const str = `${maxStr}(S:${SeriesNumber}${instanceText}${frameText})`;
diff --git a/extensions/cornerstone/src/utils/measurementServiceMappings/measurementServiceMappingsFactory.ts b/extensions/cornerstone/src/utils/measurementServiceMappings/measurementServiceMappingsFactory.ts
index 2a4562e7dbc..e3ccf4e51e8 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/getDisplayUnit.js b/extensions/cornerstone/src/utils/measurementServiceMappings/utils/getDisplayUnit.js
new file mode 100644
index 00000000000..4c9d86413c6
--- /dev/null
+++ b/extensions/cornerstone/src/utils/measurementServiceMappings/utils/getDisplayUnit.js
@@ -0,0 +1,3 @@
+const getDisplayUnit = unit => (unit == null ? '' : unit);
+
+export default getDisplayUnit;
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 7cc005e4193..00000000000
--- 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 c313921964c..82ec07f842c 100644
--- a/extensions/cornerstone/src/utils/measurementServiceMappings/utils/index.ts
+++ b/extensions/cornerstone/src/utils/measurementServiceMappings/utils/index.ts
@@ -4,14 +4,14 @@ import {
setAnnotationSelected,
getFirstAnnotationSelected,
} from './selection';
-import getModalityUnit from './getModalityUnit';
import getSOPInstanceAttributes from './getSOPInstanceAttributes';
+import getDisplayUnit from './getDisplayUnit';
export {
- getModalityUnit,
getHandlesFromPoints,
getSOPInstanceAttributes,
isAnnotationSelected,
setAnnotationSelected,
getFirstAnnotationSelected,
+ getDisplayUnit,
};
diff --git a/extensions/cornerstone/src/utils/measurementServiceMappings/utils/selection.ts b/extensions/cornerstone/src/utils/measurementServiceMappings/utils/selection.ts
index 156133306de..1de09d9426f 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 bce0d22f5fb..90aab65a8b4 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 513321b32ff..b0f3e57968d 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 cbb976534be..aae2882b051 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 5a0de4677f0..d18768f38b4 100644
--- a/extensions/cornerstone/src/utils/stackSync/toggleStackImageSync.ts
+++ b/extensions/cornerstone/src/utils/stackSync/toggleStackImageSync.ts
@@ -1,48 +1,65 @@
-import calculateViewportRegistrations from './calculateViewportRegistrations';
-
-// [ {
-// synchronizerId: string,
-// viewports: [ { viewportId: number, renderingEngineId: string, index: number } , ...]
-// ]}
-let STACK_IMAGE_SYNC_GROUPS_INFO = [];
+const STACK_SYNC_NAME = 'stackImageSync';
export default function toggleStackImageSync({
toggledState,
servicesManager,
- getEnabledElement,
+ viewports: providedViewports,
}) {
- const {
- syncGroupService,
- viewportGridService,
- displaySetService,
- cornerstoneViewportService,
- } = servicesManager.services;
-
if (!toggledState) {
- STACK_IMAGE_SYNC_GROUPS_INFO.forEach(syncGroupInfo => {
- const { viewports, synchronizerId } = syncGroupInfo;
+ return disableSync(STACK_SYNC_NAME, servicesManager);
+ }
- viewports.forEach(({ viewportId, renderingEngineId }) => {
- syncGroupService.removeViewportFromSyncGroup(
- viewportId,
- renderingEngineId,
- synchronizerId
- );
- });
- });
+ const { syncGroupService, viewportGridService, displaySetService, cornerstoneViewportService } =
+ servicesManager.services;
- return;
- }
+ const viewports =
+ providedViewports || getReconstructableStackViewports(viewportGridService, displaySetService);
+
+ // create synchronization group and add the viewports to it.
+ viewports.forEach(gridViewport => {
+ const { viewportId } = gridViewport.viewportOptions;
+ const viewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
+ if (!viewport) {
+ return;
+ }
+ syncGroupService.addViewportToSyncGroup(viewportId, viewport.getRenderingEngine().id, {
+ type: 'stackimage',
+ id: STACK_SYNC_NAME,
+ source: true,
+ target: true,
+ });
+ });
+}
- STACK_IMAGE_SYNC_GROUPS_INFO = [];
+function disableSync(syncName, servicesManager) {
+ const { syncGroupService, viewportGridService, displaySetService, cornerstoneViewportService } =
+ servicesManager.services;
+ const viewports = getReconstructableStackViewports(viewportGridService, displaySetService);
+ viewports.forEach(gridViewport => {
+ const { viewportId } = gridViewport.viewportOptions;
+ const viewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
+ if (!viewport) {
+ return;
+ }
+ syncGroupService.removeViewportFromSyncGroup(
+ viewport.id,
+ viewport.getRenderingEngine().id,
+ syncName
+ );
+ });
+}
- // create synchronization groups and add viewports
+/**
+ * Gets the consistent spacing stack viewport types, which are the ones which
+ * can be navigated using the stack image sync right now.
+ */
+function getReconstructableStackViewports(viewportGridService, displaySetService) {
let { viewports } = viewportGridService.getState();
+ viewports = [...viewports.values()];
// filter empty viewports
viewports = viewports.filter(
- viewport =>
- viewport.displaySetInstanceUIDs && viewport.displaySetInstanceUIDs.length
+ viewport => viewport.displaySetInstanceUIDs && viewport.displaySetInstanceUIDs.length
);
// filter reconstructable viewports
@@ -50,10 +67,9 @@ export default function toggleStackImageSync({
const { displaySetInstanceUIDs } = viewport;
for (const displaySetInstanceUID of displaySetInstanceUIDs) {
- const displaySet = displaySetService.getDisplaySetByUID(
- displaySetInstanceUID
- );
+ const displaySet = displaySetService.getDisplaySetByUID(displaySetInstanceUID);
+ // TODO - add a better test than isReconstructable
if (displaySet && displaySet.isReconstructable) {
return true;
}
@@ -61,55 +77,5 @@ export default function toggleStackImageSync({
return false;
}
});
-
- const viewportsByOrientation = viewports.reduce((acc, viewport) => {
- const { viewportId, viewportType } = viewport.viewportOptions;
-
- if (viewportType !== 'stack') {
- console.warn('Viewport is not a stack, cannot sync images yet');
- return acc;
- }
-
- const { element } = cornerstoneViewportService.getViewportInfo(viewportId);
- 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
- const orientation = viewPlaneNormal.map(v => Math.round(v)).join(',');
-
- if (!acc[orientation]) {
- acc[orientation] = [];
- }
-
- acc[orientation].push({ viewportId, renderingEngineId });
-
- return acc;
- }, {});
-
- // create synchronizer for each group
- Object.values(viewportsByOrientation).map(viewports => {
- let synchronizerId = viewports
- .map(({ viewportId }) => viewportId)
- .join(',');
-
- synchronizerId = `imageSync_${synchronizerId}`;
-
- calculateViewportRegistrations(viewports);
-
- viewports.forEach(({ viewportId, renderingEngineId }) => {
- syncGroupService.addViewportToSyncGroup(viewportId, renderingEngineId, {
- type: 'stackimage',
- id: synchronizerId,
- source: true,
- target: true,
- });
- });
-
- STACK_IMAGE_SYNC_GROUPS_INFO.push({
- synchronizerId,
- viewports,
- });
- });
+ return viewports;
}
diff --git a/extensions/default/.webpack/webpack.dev.js b/extensions/default/.webpack/webpack.dev.js
index 96d68096d9d..6aea859ca74 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 ea7b2e5bb02..1151efc8b2e 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 00000000000..9e65f81ae25
--- /dev/null
+++ b/extensions/default/CHANGELOG.md
@@ -0,0 +1,459 @@
+# 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.108](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.107...v3.7.0-beta.108) (2023-10-10)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.107](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.106...v3.7.0-beta.107) (2023-10-10)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.106](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.105...v3.7.0-beta.106) (2023-10-10)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.105](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.104...v3.7.0-beta.105) (2023-10-10)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.104](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.103...v3.7.0-beta.104) (2023-10-09)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.103](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.102...v3.7.0-beta.103) (2023-10-09)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.102](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.101...v3.7.0-beta.102) (2023-10-06)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.101](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.100...v3.7.0-beta.101) (2023-10-06)
+
+
+### Bug Fixes
+
+* **bugs:** fixing lots of bugs regarding release candidate ([#3700](https://github.com/OHIF/Viewers/issues/3700)) ([8bc12a3](https://github.com/OHIF/Viewers/commit/8bc12a37d0353160ae5ea4624dc0b244b7d59c07))
+
+
+
+
+
+# [3.7.0-beta.100](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.99...v3.7.0-beta.100) (2023-10-06)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.99](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.98...v3.7.0-beta.99) (2023-10-04)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.98](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.97...v3.7.0-beta.98) (2023-10-04)
+
+
+### Features
+
+* **locale:** add German translations - community PR ([#3697](https://github.com/OHIF/Viewers/issues/3697)) ([ebe8f71](https://github.com/OHIF/Viewers/commit/ebe8f71da22c1d24b58f889c5d803951e19817b6))
+
+
+
+
+
+# [3.7.0-beta.97](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.96...v3.7.0-beta.97) (2023-10-04)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.96](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.95...v3.7.0-beta.96) (2023-10-04)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.95](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.94...v3.7.0-beta.95) (2023-10-04)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.94](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.93...v3.7.0-beta.94) (2023-10-03)
+
+
+### Features
+
+* **debug:** Add timing information about time to first image/all images, and query time ([#3681](https://github.com/OHIF/Viewers/issues/3681)) ([108383b](https://github.com/OHIF/Viewers/commit/108383b9ef51e4bef82d9c932b9bc7aa5354e799))
+
+
+
+
+
+# [3.7.0-beta.93](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.92...v3.7.0-beta.93) (2023-10-03)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.92](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.91...v3.7.0-beta.92) (2023-10-03)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.91](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.90...v3.7.0-beta.91) (2023-10-03)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.90](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.89...v3.7.0-beta.90) (2023-10-03)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.89](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.88...v3.7.0-beta.89) (2023-10-03)
+
+
+### Bug Fixes
+
+* **StackSync:** Miscellaneous fixes for stack image sync ([#3663](https://github.com/OHIF/Viewers/issues/3663)) ([8a335bd](https://github.com/OHIF/Viewers/commit/8a335bd03d14ba87d65d7468d93f74040aa828d9))
+
+
+
+
+
+# [3.7.0-beta.88](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.87...v3.7.0-beta.88) (2023-10-03)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.87](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.86...v3.7.0-beta.87) (2023-09-29)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [3.7.0-beta.86](https://github.com/OHIF/Viewers/compare/v3.7.0-beta.85...v3.7.0-beta.86) (2023-09-29)
+
+**Note:** Version bump only for package @ohif/extension-default
+
+
+
+
+
+# [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 0dbddf6c755..91d3f945d59 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.108",
"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.108",
+ "@ohif/i18n": "3.7.0-beta.108",
"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 98080288b0d..d0f34a48a23 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 00000000000..97896a92c7f
--- /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 82879bf02af..9d65b971d87 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 b5555f71f12..00ee469dd58 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 2fe20e8d96d..8b8b985326f 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 23075d05787..c251fd33d79 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 00000000000..4e02cafae9f
--- /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 241d430af9e..c4bfb75ce6c 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 fc8554b92aa..a7628e80a9c 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 fe6a9609631..2845f2f39c1 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 57cf04fa83c..22eea9bc85a 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 00000000000..c709a45e193
--- /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 00000000000..d8c30714f09
--- /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 00000000000..23e9841b068
--- /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 982af013b48..a661da9f7bb 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 00f82841ed6..b265e4a07a9 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 ce372cd5fc6..4bea9a07472 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 faf5e2c9010..e4882d05e84 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 9521e379b09..1ba2aad9069 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,12 +149,18 @@ 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.vr == 'DA') {
+ if (!valueElem) {
+ return false;
+ }
+ if (valueElem.vr === 'DA' && valueElem.Value?.[0]) {
return this.compareDateRange(testValue, valueElem.Value[0]);
}
const value = valueElem.Value;
diff --git a/extensions/default/src/DicomWebDataSource/utils/fixBulkDataURI.ts b/extensions/default/src/DicomWebDataSource/utils/fixBulkDataURI.ts
index 1a408b597fe..2e592c75700 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 a493a3d3ad1..29877bd432c 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 d70a2cdccd0..ba62cca1da8 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 49302f7a835..da747c88bbe 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 096c3c8183f..bca30942929 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 6ca47ce9db2..1a7cd9d500b 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 e873237dde4..ab1d8e49e31 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 f372a1ee086..c21f8b6b652 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 decb24ad83d..dcb62c28399 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 => (
-