feat: cornerstone3D stack and volume viewports (#2787)

* feat: cs3d working stack viewport and tools (#19)

* Squashed everything

* fix weird react issue

* fix eslint / prettier stuff

* thumbnails work now with cpu rendering

* feat: use new loadImageToCanvas in cs3d

* make jump to measurement work

* fix active thumbnail

* fix measurement delete

* fix window level presets

* remove segmentation and sync groups for now

* fix the dicom pdf and dicom video

* fix cornerstone window assignment for cypress

* apply review comments

Co-authored-by: Erik <erik.sweed@gmail.com>

* feat: cs3d tools and toolGroups (#20)

* add more tools to work with cs3d mode

* fix hotkeys

* add stack manager usage for stach viewports

* add image scrollbar

* wip viewport overlay

* fix toAnnotation schema for tools

* fix the unnecessary size change that triggered resize

* hanging protocol improvement to allow unmatched errors

* study description matching for hanging protocol

* fix the displaysetOptions to work

* fix handle the active tool when a new viewport is added

* fix separate toolGroups for mode

* apply review comments

* apply review comments

* yarn lock

* feat: overlay component (#21)

* fix default displayset options

* add viewport overlay

* apply review comments

* feat: loading and orientation indicators (#22)

* add loading indicator

* add orientation marker initial work

* apply review comments

* fix: orientation markers (#23)

* finished the orientation markers

* fix various broken cypress tests

* apply review comments

* update yarn lock

* feat: re-working measurement tracking mode with cornerstone3d (#2805)

* feat: cs3d working stack viewport and tools (#19)

* Squashed everything

* fix weird react issue

* fix eslint / prettier stuff

* thumbnails work now with cpu rendering

* feat: use new loadImageToCanvas in cs3d

* make jump to measurement work

* fix active thumbnail

* fix measurement delete

* fix window level presets

* remove segmentation and sync groups for now

* fix the dicom pdf and dicom video

* fix cornerstone window assignment for cypress

* apply review comments

Co-authored-by: Erik <erik.sweed@gmail.com>

* feat: Add Measurement tracking mode with cs3D (#2789)

* feat: first render for cornerstone3d tracked viewport

* make tool active work

* wip for SR extension

* renamed dicom sr to cornerstone dicom sr

* remove cornerstone from dicom pdf and video

* move dicom sr logic to sr extension

* feat: Add hydration for the length tool

* fix SR display tool for length using cs3d

* fix default config

* fix: various bugs with sr viewport and tracking

* fix promptying to continue tracking for when SR is created

* feat: add keep trackign of unique identifiers

* fix hydration for same imageIds

* feat: Add SR toolGroup creation on modeEnter

* feat: remove the need for separate mapper for SR hydration

* add SR display for ellipse

* handle hydration of elliptical ROI tool

* remove cornerstone extension

* add arrow mapping

* feat: Add ArrowAnnotate SR display and hydration

* apply review comments

* apply review comments

* move viewport labels to the viewportData

* apply review comments

* fix: integration cypress tests with cornerstone3D and add CINE tool (#2795)

* fix: integration cypress tests with cornerstone3D

* revert to addOrUpdate as it makes more sense

* fix local drag and drop

* fix tests

* move dicomLoaderService to cornerstone extension

* fix various import bugs

* fix bug for local PT series

* fix various unit tests

* bump cs3d versions

* add angle and magnify tool

* bump dependencies to avoid broken peerDeps

* feat: add initial work for capture using cs3d

* feat: show annotations on the image capture

* feat: add svg layer export

* feat: Add CINE Tool

* feat: remove unnecessary viewport rendering for cine state changes

Co-authored-by: Erik Ziegler <erik.sweed@gmail.com>

* docs: modify and improve documentation (#2800)

* cleanup docs versionings

* feat: Add all version explanations

* version docs for 3.0

* wip for changing docs

* wip for updated docs

* add utility module documentation

* fix demo with nohoisting of history

* add slides and video to resources

* apply review comments

* fix: drag and drop SR into SR viewport (#2803)

* update yarn lock

Co-authored-by: Erik <erik.sweed@gmail.com>

* update pathnames to match v3-stable

* update the e2e pathname

* fix: various bugs with regard to tracking workflow (#2811)

* fix: various issues with measurement panel

* fix: update default tool style for annotations

* fix: annotatoin label getting removed

* feat: Add backward compatibility for SR hydration with legacy cornerstone

* fix: cursors and ellipse ROI max style

* fix: ArrowAnnotate SRDisplay

* apply review comments

* bump package versions

* fix: bugin rehydration of SR

* fix: e2e tests

* fix active viewport thickness and arrowTool ui

* add readme for measurement tracking

* use uploaded image for readme

* add back images

* try to fix e2e test

* fix: window level presets hotkeys

* Update README.md

* update yarn lock

* feat: volume api and TMTV mode (#2817)

* feat: volumeAPI and TMTV mode

* feat: use cs3d cache service to obtain viewportData

* wip for volume api

* wip: fusion viewport

* feat: add blend mode option

* wip for image scrollbar

* fix drag and drop thumbnail

* wip for image scrollbar for voluems

* fix: element mismatch bug for scroll

* feat: Add image scrollbar to volumes

* feat: add syncGroups to volume api

* feat: add tmtv mode initial setup

* feat: add initial image options for the stack viewports

* feat: Add custom load strategy for volume viewports via HP

* apply review comments

fix: Jump presets cs3d (#2812)

* feat: Add JumpPreset to OHIF for Cornerstone3D

* fix: accessing viewport service from servicesManager

feat: volume API and TMTV mode (#2814)

* fix: do not display overlays on mip viewports

* feat: add optional disableCommands for toggle buttons

* fix: toggleCrossharis

* feat: config the crosshairs

* feat: add PetSUV Panel for changing metadata

* feat: initial work for the rectangleROIThreshold panel

* wip: measurement service

* roi threshold working

* feat: Add displayText to segmentations

* feat: add remove segmentation

* feat: add csv export

* feat: add RT export for annotations in tmtv mode

* fix: fusion to use pt in tmtv mode and measuremet mappings

* fix: various bugs

* apply review comments

* apply review comments

* feat: add fusion color maps

* add readme to tmtv mode

* Update README.md

* fix: try to fix build

* fix unit tests

* Update README.md

* feat: add about to the panel

* fix: changing strategy in roi panel

* apply review comments

* update package versions

* wip for stackPrefetch

* fix: cornerstone3d hydration and renaming (#2818)

* update readme

* renamed cornerstone extension

* wip for renaming cornerstone3D variables

* wip for renaming cornerstone3D variables

* wip for fixing bugs for SR viewport

* fix: jumpToMeasurement and initial label after hydration

* fix: fileName capitalization

* feat: use the new prefetch stack in the cs3d (#2820)

* feat: use the new prefetch stack in the cs3d

* use viewport scroll api for stack viewport

* fix cine stop when scrollbar changes

* feat: use new prefetch events

* fix loading state to not show repeatedly

* fix: various bugs for tmtv mode thresholding and new icons (#2823)

* feat: make tmtv mode available in worklist

* feat: add new icons for tmtv mode

* feat: add fusion color icon

* fix: parallel scale calculation

* fix: bump Cornerstone to get large image support working

* fix: Fix issues with CPU viewport flipping, including config files

* fix: bump cornerstone to fix magnify tool

* fix: Bump Cornerstone version to fix resetCamera issue in StackViewport

* ci: Add _headers file to enable CORS headers for Netlify Drag/Drop deploys

* fix: WADO-URI was not working. PET Metadata was coming from the wrong place. Fixed some minor React errors

* feat(OHIF):Allow modes and extensions to be added after commpile time. (#2838)

Also works with the compile time add that the existing cli uses, so that both build types work.
Eric and I agreed this doesn't change existing functionality, but is almost entirely build issues/fixes.

* bump: dependency versions to fix hydration bugs (#2848)

* bump: dcmjs version to fix hydration bugs

* try to fix tests

* bump dependency versions

Co-authored-by: Alireza <ar.sedghi@gmail.com>
Co-authored-by: Bill Wallace <wayfarer3130@gmail.com>
This commit is contained in:
authored and GitHub committed 2022-07-27 12:39:04 -04:00
1 parent 86dcaf6293
commit bd1c38c00c
668 files changed
+41669 -13410

No files matched your search

@@ -1,286 +0,0 @@
/**
* CSS Grid Reference: http://grid.malven.co/
*/
import React, { useEffect, useCallback } from 'react';
import PropTypes from 'prop-types';
import { ViewportGrid, ViewportPane, useViewportGrid } from '@ohif/ui';
import EmptyViewport from './EmptyViewport';
import classNames from 'classnames';
function ViewerViewportGrid(props) {
const { servicesManager, viewportComponents, dataSource } = props;
const [viewportGrid, viewportGridService] = useViewportGrid();
const {
numCols,
numRows,
activeViewportIndex,
viewports,
cachedLayout,
} = viewportGrid;
// TODO -> Need some way of selecting which displaySets hit the viewports.
const {
DisplaySetService,
MeasurementService,
HangingProtocolService,
} = servicesManager.services;
const updateDisplaysetForViewports = useCallback(
(displaySets) => {
const [
matchDetails,
hpAlreadyApplied,
] = HangingProtocolService.getState();
if (!matchDetails.length) return;
// Match each viewport individually
const numViewports = viewportGrid.numRows * viewportGrid.numCols;
for (let i = 0; i < numViewports; i++) {
if (hpAlreadyApplied[i] === true) {
continue;
}
// if current viewport doesn't have a match
if (matchDetails[i] === undefined) return
const { SeriesInstanceUID } = matchDetails[i];
const matchingDisplaySet = displaySets.find(ds => {
return ds.SeriesInstanceUID === SeriesInstanceUID;
});
if (!matchingDisplaySet) {
continue;
}
viewportGridService.setDisplaysetForViewport({
viewportIndex: i,
displaySetInstanceUID: matchingDisplaySet.displaySetInstanceUID,
});
HangingProtocolService.setHangingProtocolAppliedForViewport(i);
}
},
[viewportGrid, numRows, numCols],
)
// Using Hanging protocol engine to match the displaySets
useEffect(() => {
const { unsubscribe } = DisplaySetService.subscribe(
DisplaySetService.EVENTS.DISPLAY_SETS_ADDED,
eventData => {
const { displaySetsAdded } = eventData;
updateDisplaysetForViewports(displaySetsAdded)
}
);
return () => {
unsubscribe();
};
}, [viewportGrid]);
// Changing the Hanging protocol while viewing
useEffect(() => {
const displaySets = DisplaySetService.getActiveDisplaySets();
updateDisplaysetForViewports(displaySets)
}, [viewportGrid])
// Layout change based on hanging protocols
useEffect(() => {
const { unsubscribe } = HangingProtocolService.subscribe(
HangingProtocolService.EVENTS.NEW_LAYOUT,
({ numRows, numCols }) => {
viewportGridService.setLayout({ numRows, numCols });
}
);
return () => {
unsubscribe();
};
}, [viewports]);
useEffect(() => {
const { unsubscribe } = MeasurementService.subscribe(
MeasurementService.EVENTS.JUMP_TO_MEASUREMENT,
({ viewportIndex, measurement }) => {
const referencedDisplaySetInstanceUID =
measurement.displaySetInstanceUID;
const viewportsDisplaySetInstanceUIDs = viewports.map(
vp => vp.displaySetInstanceUID
);
// if we already have the displayset in one of the viewports
if (
viewportsDisplaySetInstanceUIDs.indexOf(
referencedDisplaySetInstanceUID
) > -1
) {
return;
}
// If not in any of the viewports, hang it inside the active viewport
viewportGridService.setDisplaysetForViewport({
viewportIndex,
displaySetInstanceUID: referencedDisplaySetInstanceUID,
});
}
);
return () => {
unsubscribe();
};
}, [viewports]);
const onDoubleClick = viewportIndex => {
// TODO -> Disabled for now.
// onNewImage on a cornerstone viewport is firing setDisplaySetForViewport.
// Which it really really shouldn't. We need a larger fix for jump to
// measurements and all cornerstone "imageIndex" state to fix this.
if (cachedLayout) {
viewportGridService.set({
numCols: cachedLayout.numCols,
numRows: cachedLayout.numRows,
activeViewportIndex: cachedLayout.activeViewportIndex,
viewports: cachedLayout.viewports,
cachedLayout: null,
});
return;
}
const cachedViewports = viewports.map(viewport => {
return {
displaySetInstanceUID: viewport.displaySetInstanceUID,
};
});
viewportGridService.set({
numCols: 1,
numRows: 1,
activeViewportIndex: 0,
viewports: [
{
displaySetInstanceUID: viewports[viewportIndex].displaySetInstanceUID,
imageIndex: undefined,
},
],
cachedLayout: {
numCols,
numRows,
viewports: cachedViewports,
activeViewportIndex: viewportIndex,
},
});
};
const onDropHandler = (viewportIndex, { displaySetInstanceUID }) => {
viewportGridService.setDisplaysetForViewport({
viewportIndex,
displaySetInstanceUID,
});
};
const getViewportPanes = () => {
const viewportPanes = [];
const numViewportPanes = numCols * numRows;
for (let i = 0; i < numViewportPanes; i++) {
const viewportIndex = i;
const isActive = activeViewportIndex === viewportIndex;
const paneMetadata = viewports[i] || {};
const { displaySetInstanceUID } = paneMetadata;
const displaySet =
DisplaySetService.getDisplaySetByUID(displaySetInstanceUID) || {};
const ViewportComponent = _getViewportComponent(
displaySet.SOPClassHandlerId,
viewportComponents
);
const onInterationHandler = event => {
if (isActive) return;
if (event) {
event.preventDefault();
event.stopPropagation();
}
viewportGridService.setActiveViewportIndex(viewportIndex);
};
// TEMP -> Double click disabled for now
// onDoubleClick={() => onDoubleClick(viewportIndex)}
viewportPanes[i] = (
<ViewportPane
key={viewportIndex}
className="m-1"
acceptDropsFor="displayset"
onDrop={onDropHandler.bind(null, viewportIndex)}
onInteraction={onInterationHandler}
isActive={isActive}
>
<div
className={classNames('h-full w-full flex flex-col', {
'pointer-events-none': !isActive,
})}
>
<ViewportComponent
displaySet={displaySet}
viewportIndex={viewportIndex}
dataSource={dataSource}
/>
</div>
</ViewportPane>
);
}
return viewportPanes;
};
if (!numCols || !numCols) {
return null;
}
return (
<ViewportGrid numRows={numRows} numCols={numCols}>
{/* {ViewportPanes} */}
{getViewportPanes()}
</ViewportGrid>
);
}
ViewerViewportGrid.propTypes = {
viewportComponents: PropTypes.array.isRequired,
};
ViewerViewportGrid.defaultProps = {
viewportComponents: [],
};
function _getViewportComponent(SOPClassHandlerId, viewportComponents) {
if (!SOPClassHandlerId) {
return EmptyViewport;
}
for (let i = 0; i < viewportComponents.length; i++) {
if (
viewportComponents[i].displaySetsToDisplay.includes(SOPClassHandlerId)
) {
const { component } = viewportComponents[i];
return component;
}
}
}
export default ViewerViewportGrid;
@@ -0,0 +1,381 @@
import React, { useEffect, useCallback } from 'react';
import PropTypes from 'prop-types';
import { ViewportGrid, ViewportPane, useViewportGrid } from '@ohif/ui';
import EmptyViewport from './EmptyViewport';
import classNames from 'classnames';
function ViewerViewportGrid(props) {
const { servicesManager, viewportComponents, dataSource } = props;
const [viewportGrid, viewportGridService] = useViewportGrid();
const { numCols, numRows, activeViewportIndex, viewports } = viewportGrid;
// TODO -> Need some way of selecting which displaySets hit the viewports.
const {
DisplaySetService,
MeasurementService,
HangingProtocolService,
} = servicesManager.services;
/**
* This callback runs only after displaySets have changed (created and added or modified)
*/
const updateDisplaySetsForViewports = useCallback(
availableDisplaySets => {
if (!availableDisplaySets.length) {
return;
}
const [
matchDetails,
hpAlreadyApplied,
] = HangingProtocolService.getState();
if (!matchDetails.length) {
return;
}
// Match each viewport individually
const numViewports = viewportGrid.numRows * viewportGrid.numCols;
for (let i = 0; i < numViewports; i++) {
if (hpAlreadyApplied[i] === true) {
continue;
}
// if current viewport doesn't have a match
if (matchDetails[i] === undefined) return;
const { displaySetsInfo, viewportOptions } = matchDetails[i];
const displaySetUIDsToHang = [];
const displaySetUIDsToHangOptions = [];
displaySetsInfo.forEach(({ SeriesInstanceUID, displaySetOptions }) => {
const matchingDisplaySet = availableDisplaySets.find(ds => {
return ds.SeriesInstanceUID === SeriesInstanceUID;
});
if (!matchingDisplaySet) {
return;
}
displaySetUIDsToHang.push(matchingDisplaySet.displaySetInstanceUID);
displaySetUIDsToHangOptions.push(displaySetOptions);
});
if (!displaySetUIDsToHang.length) {
continue;
}
viewportGridService.setDisplaySetsForViewport({
viewportIndex: i,
displaySetInstanceUIDs: displaySetUIDsToHang,
viewportOptions,
displaySetOptions: displaySetUIDsToHangOptions,
});
// During setting displaySets for viewport, we need to update the hanging protocol
// but some viewports contain more than one display set (fusion), and their displaySet
// will not be available at the time of setting displaySets for viewport. So we need to
// update the hanging protocol after making sure all the matched display sets are available
// and set on the viewport
if (displaySetUIDsToHang.length === displaySetsInfo.length) {
// The following will set the hpAlreadyApplied state
HangingProtocolService.setHangingProtocolAppliedForViewport(i);
}
}
},
[viewportGrid, numRows, numCols]
);
useEffect(() => {
const displaySets = DisplaySetService.getActiveDisplaySets();
updateDisplaySetsForViewports(displaySets);
}, [numRows, numCols]);
// Layout change based on hanging protocols
useEffect(() => {
const { unsubscribe } = HangingProtocolService.subscribe(
HangingProtocolService.EVENTS.NEW_LAYOUT,
({ layoutType, numRows, numCols, layoutOptions }) => {
viewportGridService.setLayout({
numRows,
numCols,
layoutType,
layoutOptions,
});
}
);
return () => {
unsubscribe();
};
}, [viewports]);
// Using Hanging protocol engine to match the displaySets
useEffect(() => {
const { unsubscribe } = DisplaySetService.subscribe(
DisplaySetService.EVENTS.DISPLAY_SETS_CHANGED,
activeDisplaySets => {
updateDisplaySetsForViewports(activeDisplaySets);
}
);
return () => {
unsubscribe();
};
}, [viewports]);
useEffect(() => {
const { unsubscribe } = MeasurementService.subscribe(
MeasurementService.EVENTS.JUMP_TO_MEASUREMENT,
({ viewportIndex, measurement }) => {
const referencedDisplaySetInstanceUID =
measurement.displaySetInstanceUID;
// if we already have the displaySet in one of the viewports
// Todo: handle fusion display sets?
for (const viewport of viewports) {
const isMatch = viewport.displaySetInstanceUIDs.includes(
referencedDisplaySetInstanceUID
);
if (isMatch) {
return;
}
}
const displaySet = DisplaySetService.getDisplaySetByUID(
referencedDisplaySetInstanceUID
);
let imageIndex;
// jump straight to the initial image index if we can
if (displaySet.images && measurement.SOPInstanceUID) {
imageIndex = displaySet.images.findIndex(
image => image.SOPInstanceUID === measurement.SOPInstanceUID
);
}
// If not in any of the viewports, hang it inside the active viewport
viewportGridService.setDisplaySetsForViewport({
viewportIndex,
displaySetInstanceUIDs: [referencedDisplaySetInstanceUID],
viewportOptions: {
initialImageOptions: {
index: imageIndex,
},
},
});
}
);
return () => {
unsubscribe();
};
}, [viewports]);
/**
//Changing the Hanging protocol while viewing
useEffect(() => {
const displaySets = DisplaySetService.getActiveDisplaySets();
updateDisplaySetsForViewports(displaySets);
}, [viewports]);
// subscribe to displayset metadata changes
useEffect(() => {
const { unsubscribe } = DisplaySetService.subscribe(
DisplaySetService.EVENTS.DISPLAY_SETS_METADATA_UPDATED,
displaySets => {
// Todo: properly refresh the viewportGrid to use the new displaySet
// with the new metadata.
setState({});
}
);
return () => {
unsubscribe();
};
}, [viewports]);
const onDoubleClick = viewportIndex => {
// TODO -> Disabled for now.
// onNewImage on a cornerstone viewport is firing setDisplaySetsForViewport.
// Which it really really shouldn't. We need a larger fix for jump to
// measurements and all cornerstone "imageIndex" state to fix this.
if (cachedLayout) {
viewportGridService.set({
numCols: cachedLayout.numCols,
numRows: cachedLayout.numRows,
activeViewportIndex: cachedLayout.activeViewportIndex,
viewports: cachedLayout.viewports,
cachedLayout: null,
});
return;
}
const cachedViewports = viewports.map(viewport => {
return {
displaySetInstanceUID: viewport.displaySetInstanceUID,
};
});
viewportGridService.set({
numCols: 1,
numRows: 1,
activeViewportIndex: 0,
viewports: [
{
displaySetInstanceUID: viewports[viewportIndex].displaySetInstanceUID,
imageIndex: undefined,
},
],
cachedLayout: {
numCols,
numRows,
viewports: cachedViewports,
activeViewportIndex: viewportIndex,
},
});
};
*/
const onDropHandler = (viewportIndex, { displaySetInstanceUID }) => {
viewportGridService.setDisplaySetsForViewport({
viewportIndex,
displaySetInstanceUIDs: [displaySetInstanceUID],
});
};
const getViewportPanes = useCallback(() => {
const viewportPanes = [];
for (let i = 0; i < viewports.length; i++) {
const viewportIndex = i;
const isActive = activeViewportIndex === viewportIndex;
const paneMetadata = viewports[i] || {};
const {
displaySetInstanceUIDs,
viewportOptions,
displaySetOptions, // array of options for each display set in the viewport
x: viewportX,
y: viewportY,
width: viewportWidth,
height: viewportHeight,
viewportLabel,
} = paneMetadata;
const displaySetInstanceUIDsToUse = displaySetInstanceUIDs || [];
// This is causing the viewport components re-render when the activeViewportIndex changes
const displaySets = displaySetInstanceUIDsToUse.map(
displaySetInstanceUID => {
return (
DisplaySetService.getDisplaySetByUID(displaySetInstanceUID) || {}
);
}
);
const ViewportComponent = _getViewportComponent(
displaySets,
viewportComponents
);
// look inside displaySets to see if they need reRendering
const displaySetsNeedsRerendering = displaySets.some(displaySet => {
return displaySet.needsRerendering;
});
const onInteractionHandler = event => {
if (isActive) return;
if (event) {
event.preventDefault();
event.stopPropagation();
}
viewportGridService.setActiveViewportIndex(viewportIndex);
};
// TEMP -> Double click disabled for now
// onDoubleClick={() => onDoubleClick(viewportIndex)}
viewportPanes[i] = (
<ViewportPane
key={viewportIndex}
acceptDropsFor="displayset"
onDrop={onDropHandler.bind(null, viewportIndex)}
onInteraction={onInteractionHandler}
customStyle={{
position: 'absolute',
top: viewportY * 100 + 0.2 + '%',
left: viewportX * 100 + 0.2 + '%',
width: viewportWidth * 100 - 0.3 + '%',
height: viewportHeight * 100 - 0.3 + '%',
}}
isActive={isActive}
>
<div
className={classNames('h-full w-full flex flex-col', {
'pointer-events-none': !isActive,
})}
>
<ViewportComponent
displaySets={displaySets}
viewportIndex={viewportIndex}
viewportLabel={viewports.length > 1 ? viewportLabel : ''}
dataSource={dataSource}
viewportOptions={viewportOptions}
displaySetOptions={displaySetOptions}
needsRerendering={displaySetsNeedsRerendering}
/>
</div>
</ViewportPane>
);
}
return viewportPanes;
}, [viewports, activeViewportIndex, viewportComponents, dataSource]);
/**
* Loading indicator until numCols and numRows are gotten from the HangingProtocolService
*/
if (!numRows || !numCols) {
return null;
}
return (
<ViewportGrid numRows={numRows} numCols={numCols}>
{/* {ViewportPanes} */}
{getViewportPanes()}
</ViewportGrid>
);
}
ViewerViewportGrid.propTypes = {
viewportComponents: PropTypes.array.isRequired,
};
ViewerViewportGrid.defaultProps = {
viewportComponents: [],
};
function _getViewportComponent(displaySets, viewportComponents) {
if (!displaySets || !displaySets.length) {
return EmptyViewport;
}
// Todo: Do we have a viewport that has two different SOPClassHandlerIds?
const SOPClassHandlerId = displaySets[0].SOPClassHandlerId;
for (let i = 0; i < viewportComponents.length; i++) {
if (
viewportComponents[i].displaySetsToDisplay.includes(SOPClassHandlerId)
) {
const { component } = viewportComponents[i];
return component;
}
}
}
export default ViewerViewportGrid;