95 lines
3.4 KiB
TypeScript
95 lines
3.4 KiB
TypeScript
import { HangingProtocolService, Types } from '@ohif/core';
|
|
import { useViewportGridStore } from '../stores/useViewportGridStore';
|
|
import { useDisplaySetSelectorStore } from '../stores/useDisplaySetSelectorStore';
|
|
import { useHangingProtocolStageIndexStore } from '../stores/useHangingProtocolStageIndexStore';
|
|
|
|
export type ReturnType = {
|
|
hangingProtocolStageIndexMap: Record<string, Types.HangingProtocol.HPInfo>;
|
|
viewportGridStore: Record<string, unknown>;
|
|
displaySetSelectorMap: Record<string, Array<string>>;
|
|
};
|
|
|
|
/**
|
|
* Calculates a set of state information for hanging protocols and viewport grid
|
|
* which defines the currently applied hanging protocol state.
|
|
* @param state is the viewport grid state
|
|
* @param syncService is the state sync service to use for getting existing state
|
|
* @returns Set of states that can be applied to the state sync to remember
|
|
* the current view state.
|
|
*/
|
|
const reuseCachedLayout = (state, hangingProtocolService: HangingProtocolService): ReturnType => {
|
|
const { activeViewportId } = state;
|
|
const { protocol } = hangingProtocolService.getActiveProtocol();
|
|
|
|
if (!protocol) {
|
|
return;
|
|
}
|
|
|
|
const hpInfo = hangingProtocolService.getState();
|
|
const { protocolId, stageIndex, activeStudyUID } = hpInfo;
|
|
|
|
const { viewportGridState, setViewportGridState } = useViewportGridStore.getState();
|
|
const { displaySetSelectorMap, setDisplaySetSelector } = useDisplaySetSelectorStore.getState();
|
|
const { hangingProtocolStageIndexMap, setHangingProtocolStageIndex } =
|
|
useHangingProtocolStageIndexStore.getState();
|
|
|
|
const stage = protocol.stages[stageIndex];
|
|
const storeId = `${activeStudyUID}:${protocolId}:${stageIndex}`;
|
|
const cacheId = `${activeStudyUID}:${protocolId}`;
|
|
const { rows, columns } = stage.viewportStructure.properties;
|
|
const custom =
|
|
stage.viewports.length !== state.viewports.size ||
|
|
state.layout.numRows !== rows ||
|
|
state.layout.numCols !== columns;
|
|
|
|
hangingProtocolStageIndexMap[cacheId] = hpInfo;
|
|
|
|
if (storeId && custom) {
|
|
setViewportGridState(storeId, { ...state });
|
|
}
|
|
|
|
state.viewports.forEach((viewport, viewportId) => {
|
|
const { displaySetOptions, displaySetInstanceUIDs } = viewport;
|
|
if (!displaySetOptions) {
|
|
return;
|
|
}
|
|
const activeDisplaySetUIDs = [];
|
|
|
|
for (let i = 0; i < displaySetOptions.length; i++) {
|
|
const displaySetUID = displaySetInstanceUIDs[i];
|
|
if (!displaySetUID) {
|
|
continue;
|
|
}
|
|
if (viewportId === activeViewportId) {
|
|
activeDisplaySetUIDs.push(displaySetUID);
|
|
}
|
|
|
|
// The activeDisplaySet selector should only be set once (i.e. for the actual active display set)
|
|
if (displaySetOptions[i]?.id && displaySetOptions[i].id !== 'activeDisplaySet') {
|
|
// TODO: handle multiple layers/display sets for the non-active viewports
|
|
setDisplaySetSelector(
|
|
`${activeStudyUID}:${displaySetOptions[i].id}:${
|
|
displaySetOptions[i].matchedDisplaySetsIndex || 0
|
|
}`,
|
|
[displaySetUID]
|
|
);
|
|
}
|
|
}
|
|
|
|
if (viewportId === activeViewportId) {
|
|
// After going through all the display set options for the active viewport, store the display set selector array
|
|
setDisplaySetSelector(`${activeStudyUID}:activeDisplaySet:0`, activeDisplaySetUIDs);
|
|
}
|
|
});
|
|
|
|
setHangingProtocolStageIndex(cacheId, hpInfo);
|
|
|
|
return {
|
|
hangingProtocolStageIndexMap,
|
|
viewportGridStore: viewportGridState,
|
|
displaySetSelectorMap,
|
|
};
|
|
};
|
|
|
|
export default reuseCachedLayout;
|