Integration TrizRis OHIF: key images, annotations, layouts, access control and reconstruction
Build and Deploy Docs / build-and-deploy-docs (push) Canceled after 0s

This commit is contained in:
Kenza committed 2026-10-11 10:34:47 +02:00
1 parent bbe37ff388
commit f00379a672
28 files changed
+1898 -105

No files matched your search

@@ -4,6 +4,7 @@ import { Enums, eventTarget, getEnabledElement } from '@cornerstonejs/core';
import { MeasurementService, useViewportRef } from '@ohif/core';
import { useViewportDialog } from '@ohif/ui-next';
import type { Types as csTypes } from '@cornerstonejs/core';
import { deleteKeyImageFromTrizRis } from '../utils/keyImages/deleteKeyImageFromTrizRis';
import { setEnabledElement } from '../state';
@@ -17,6 +18,13 @@ import { getViewportPresentations } from '../utils/presentations/getViewportPres
import { useSynchronizersStore } from '../stores/useSynchronizersStore';
import ActiveViewportBehavior from '../utils/ActiveViewportBehavior';
import { WITH_NAVIGATION } from '../services/ViewportService/CornerstoneViewportService';
import { useKeyImagesStore } from '../stores/useKeyImagesStore';
import { loadKeyImagesFromTrizRis } from '../utils/keyImages/loadKeyImagesFromTrizRis';
import { useSavedKeyImages } from '../hooks/useSavedKeyImages';
import {
saveImageViewState,
getImageViewState,
} from '../../../default/src/services/TrizRisImageViewStateApi';
const STACK = 'stack';
@@ -80,7 +88,13 @@ const OHIFCornerstoneViewport = React.memo(
const [scrollbarHeight, setScrollbarHeight] = useState('100px');
const [enabledVPElement, setEnabledVPElement] = useState(null);
const [currentImageId, setCurrentImageId] = useState<string | null>(null);
const { savedKeyImageSOPs, removeSavedKeyImage, addSavedKeyImage } = useSavedKeyImages();
const keyImages = useKeyImagesStore(state => state.keyImages);
const addKeyImage = useKeyImagesStore(state => state.addKeyImage);
const removeKeyImage = useKeyImagesStore(state => state.removeKeyImage);
const elementRef = useRef() as React.MutableRefObject<HTMLDivElement>;
const viewportRef = useViewportRef(viewportId);
const {
@@ -142,6 +156,201 @@ const OHIFCornerstoneViewport = React.memo(
};
}, [onResize]);
// AJOUTER ICI
useEffect(() => {
const element = enabledVPElement;
let isRestoringViewState = true;
let lastRestoredImageId: string | null = null;
const lastSavedViewState = new Map<string, { zoom: number; rotation: number }>();
if (!element) {
return;
}
const updateCurrentImage = () => {
try {
const enabledElement = getEnabledElement(element);
const viewport = enabledElement?.viewport;
const imageId = viewport?.getCurrentImageId?.();
if (imageId) {
setCurrentImageId(imageId);
if (lastRestoredImageId === imageId) {
return;
}
lastRestoredImageId = imageId;
isRestoringViewState = true;
const match = imageId.match(/studies\/([^/]+)\/series\/([^/]+)\/instances\/([^/]+)/);
if (match) {
const studyInstanceUID = match[1];
const seriesInstanceUID = match[2];
const sopInstanceUID = match[3];
getImageViewState(studyInstanceUID, seriesInstanceUID, sopInstanceUID)
.then(state => {
console.log('### VIEW STATE RECUPERE ###');
console.log(state);
if (state) {
const imageKey = `${state.studyInstanceUID}|${state.seriesInstanceUID}|${state.sopInstanceUID}`;
lastSavedViewState.set(imageKey, {
zoom: state.zoom,
rotation: state.rotation,
});
const enabledElement = getEnabledElement(element);
const viewport = enabledElement?.viewport;
if (!viewport) {
// ===== CORRECTION 1 =====
isRestoringViewState = false;
return;
}
const currentImageId = viewport.getCurrentImageId?.();
if (currentImageId !== imageId) {
// ===== CORRECTION 2 =====
isRestoringViewState = false;
return;
}
viewport.setZoom(state.zoom);
viewport.setViewPresentation({
rotation: state.rotation,
});
viewport.render();
console.log('### VIEW STATE APPLIQUE ###');
console.log('zoom =', state.zoom);
console.log('rotation =', state.rotation);
}
// ===== CORRECTION 3 =====
// Important : même si state == null,
// on réactive la sauvegarde
isRestoringViewState = false;
})
.catch(error => {
console.error('Erreur récupération zoom/rotation :', error);
// ===== CORRECTION 4 =====
// Si le GET échoue, on ne reste pas bloqué
isRestoringViewState = false;
});
} else {
// ===== CORRECTION 5 =====
// Si l'imageId ne correspond pas au regex,
// on réactive quand même la sauvegarde
isRestoringViewState = false;
}
console.log('### IMAGE COURANTE VIEWPORT', viewportId, '###');
console.log(imageId);
}
} catch (error) {
console.error('Erreur récupération image courante :', error);
// ===== CORRECTION 6 =====
isRestoringViewState = false;
}
};
updateCurrentImage();
let saveViewStateTimeout: ReturnType<typeof setTimeout>;
const handleCameraModified = () => {
clearTimeout(saveViewStateTimeout);
saveViewStateTimeout = setTimeout(() => {
if (isRestoringViewState) {
console.log('### SAUVEGARDE IGNOREE - RESTAURATION EN COURS ###');
return;
}
try {
const enabledElement = getEnabledElement(element);
const viewport = enabledElement?.viewport;
if (!viewport) {
return;
}
const imageId = viewport.getCurrentImageId?.();
if (!imageId) {
return;
}
const zoom = viewport.getZoom();
const rotation = viewport.getRotation();
console.log('### CAMERA MODIFIED TERMINE ###');
console.log('zoom =', zoom);
console.log('rotation =', rotation);
const match = imageId.match(/studies\/([^/]+)\/series\/([^/]+)\/instances\/([^/]+)/);
if (!match) {
return;
}
const studyInstanceUID = match[1];
const seriesInstanceUID = match[2];
const sopInstanceUID = match[3];
const imageKey = `${studyInstanceUID}|${seriesInstanceUID}|${sopInstanceUID}`;
const previousState = lastSavedViewState.get(imageKey);
if (
previousState &&
Math.abs(previousState.zoom - zoom) < 0.000001 &&
previousState.rotation === rotation
) {
console.log('### VIEW STATE INCHANGE -> PAS DE SAUVEGARDE ###');
return;
}
console.log('### SAUVEGARDE VIEW STATE ###');
console.log('studyInstanceUID =', studyInstanceUID);
console.log('seriesInstanceUID =', seriesInstanceUID);
console.log('sopInstanceUID =', sopInstanceUID);
saveImageViewState({
studyInstanceUID,
seriesInstanceUID,
sopInstanceUID,
zoom,
rotation,
})
.then(() => {
lastSavedViewState.set(imageKey, {
zoom,
rotation,
});
})
.catch(error => {
console.error('Erreur sauvegarde zoom/rotation :', error);
});
} catch (error) {
console.error('Erreur récupération zoom/rotation :', error);
}
}, 400);
};
element.addEventListener(Enums.Events.IMAGE_RENDERED, updateCurrentImage);
element.addEventListener(Enums.Events.CAMERA_MODIFIED, handleCameraModified);
return () => {
clearTimeout(saveViewStateTimeout);
element.removeEventListener(Enums.Events.IMAGE_RENDERED, updateCurrentImage);
element.removeEventListener(Enums.Events.CAMERA_MODIFIED, handleCameraModified);
};
}, [enabledVPElement, viewportId]);
const cleanUpServices = useCallback(
viewportInfo => {
const renderingEngineId = viewportInfo.getRenderingEngineId();
@@ -304,11 +513,104 @@ const OHIFCornerstoneViewport = React.memo(
loadViewportData();
}, [viewportOptions, displaySets, dataSource]);
const getSopInstanceUIDFromImageId = (imageId: string | null) => {
if (!imageId) {
return null;
}
const match = imageId.match(/\/instances\/([^/]+)/i);
return match ? decodeURIComponent(match[1]) : null;
};
const currentSopInstanceUID = getSopInstanceUIDFromImageId(currentImageId);
const isSavedKeyImage = !!(
currentSopInstanceUID && savedKeyImageSOPs.includes(currentSopInstanceUID)
);
const isCurrentKeyImage = !!(currentImageId && (keyImages[currentImageId] || isSavedKeyImage));
const toggleCurrentKeyImage = async () => {
if (!currentImageId) {
console.log('Aucune image actuellement affichée');
return;
}
const sopInstanceUID = getSopInstanceUIDFromImageId(currentImageId);
if (!sopInstanceUID) {
console.error('SOP Instance UID introuvable');
return;
}
/*
* L'image est actuellement Key Image
* soit parce qu'elle est dans le store local,
* soit parce qu'elle vient de la base TrizRis.
*/
if (isCurrentKeyImage) {
console.log('### DESACTIVATION KEY IMAGE ###');
/*
* Si elle était sauvegardée dans TrizRis,
* supprimer fichier + base.
*/
if (isSavedKeyImage) {
await deleteKeyImageFromTrizRis(currentImageId);
removeSavedKeyImage(sopInstanceUID);
}
/*
* Si elle existe aussi dans le store local,
* on la retire explicitement.
*/
if (keyImages[currentImageId]) {
removeKeyImage(currentImageId);
}
console.log('### KEY IMAGE DESACTIVE ###');
} else {
/*
* Elle n'était pas active :
* on l'ajoute explicitement au store.
*/
addKeyImage(currentImageId, viewportId);
console.log('### KEY IMAGE ACTIVE ###');
}
};
const Notification = customizationService.getCustomization('ui.notificationComponent');
return (
<React.Fragment>
<div className="viewport-wrapper">
<button
type="button"
onClick={event => {
event.stopPropagation();
toggleCurrentKeyImage();
}}
style={{
position: 'absolute',
top: '35px',
right: '10px',
zIndex: 1000,
width: '36px',
height: '36px',
borderRadius: '50%',
border: '1px solid #666',
background: 'rgba(0, 0, 0, 0.65)',
color: currentImageId && isCurrentKeyImage ? '#FFD700' : '#FFFFFF',
fontSize: '22px',
cursor: 'pointer',
}}
title={
currentImageId && isCurrentKeyImage ? 'Désactiver Key Image' : 'Activer Key Image'
}
>
{currentImageId && isCurrentKeyImage ? '★' : '☆'}
</button>
<div
className="cornerstone-viewport-element"
style={{ height: '100%', width: '100%' }}
@@ -37,6 +37,8 @@ import { getFirstAnnotationSelected } from './utils/measurementServiceMappings/u
import { getViewportEnabledElement } from './utils/getViewportEnabledElement';
import getActiveViewportEnabledElement from './utils/getActiveViewportEnabledElement';
import toggleVOISliceSync from './utils/toggleVOISliceSync';
import { useKeyImagesStore } from './stores/useKeyImagesStore';
import { exportKeyImageToTrizRis } from './utils/keyImages/exportKeyImagesToTrizRis';
import {
isStackViewportType,
isOrthographicViewportType,
@@ -231,7 +233,31 @@ function commandsModule({
}
};
};
const extractDicomInfoFromImageId = (imageId: string) => {
if (!imageId) {
return null;
}
const imageIdWithoutPrefix = imageId.replace(/^wadors:/, '').replace(/^dicomweb:/, '');
const match = imageIdWithoutPrefix.match(
/\/studies\/([^/]+)\/series\/([^/]+)\/instances\/([^/]+)(?:\/frames\/(\d+))?/i
);
if (!match) {
console.error('Impossible d extraire les UID depuis imageId :', imageId);
return null;
}
return {
imageId,
studyInstanceUID: decodeURIComponent(match[1]),
seriesInstanceUID: decodeURIComponent(match[2]),
sopInstanceUID: decodeURIComponent(match[3]),
frameNumber: match[4] || null,
};
};
const actions = {
jumpToMeasurementViewport: ({ annotationUID, measurement }) => {
cornerstoneTools.annotation.selection.setAnnotationSelected(annotationUID, true);
@@ -1136,6 +1162,34 @@ function commandsModule({
bindings,
});
},
//key image button
toggleKeyImageMode: async () => {
console.log('### KEY IMAGES BUTTON CLICKED ###');
const keyImages = useKeyImagesStore.getState().keyImages;
const liste = Object.values(keyImages);
console.log('Nombre de Key Images =', liste.length);
if (liste.length === 0) {
console.log('Aucune Key Image sélectionnée');
return;
}
console.log('### EXPORT DE TOUTES LES KEY IMAGES ###');
for (let i = 0; i < liste.length; i++) {
const keyImage = liste[i];
console.log(`Export ${i + 1} / ${liste.length}`);
await exportKeyImageToTrizRis(keyImage.imageId, keyImage.viewportId);
}
console.log('### EXPORT KEY IMAGES TERMINE ###');
},
// capture viewport
showDownloadViewportModal: () => {
const { activeViewportId } = viewportGridService.getState();
@@ -2700,6 +2754,9 @@ function commandsModule({
deleteActiveAnnotation: {
commandFn: actions.deleteActiveAnnotation,
},
toggleKeyImageMode: {
commandFn: actions.toggleKeyImageMode,
},
setDisplaySetsForViewports: actions.setDisplaySetsForViewports,
undo: actions.undo,
redo: actions.redo,
@@ -38,6 +38,13 @@ const toolbarButtons: Button[] = [
buttonSection: true,
},
},
{
id: 'Reconstruction',
uiType: 'ohif.toolButtonList',
props: {
buttonSection: true,
},
},
{
id: 'AdvancedRenderingControls',
uiType: 'ohif.advancedRenderingControls',
@@ -633,6 +640,86 @@ const toolbarButtons: Button[] = [
],
},
},
{
id: 'MPR',
uiType: 'ohif.toolButton',
props: {
icon: 'layout-advanced-mpr',
label: 'MPR',
tooltip: 'Reconstruction multiplanaire',
commands: {
commandName: 'setHangingProtocol',
commandOptions: {
protocolId: 'mpr',
},
},
evaluate: 'evaluate.action',
},
},
{
id: 'MPR3D',
uiType: 'ohif.toolButton',
props: {
icon: 'layout-advanced-mpr',
label: 'MPR + 3D',
tooltip: 'Reconstruction multiplanaire avec rendu 3D',
commands: {
commandName: 'setHangingProtocol',
commandOptions: {
protocolId: 'mprAnd3DVolumeViewport',
},
},
evaluate: 'evaluate.action',
},
},
{
id: 'MIP',
uiType: 'ohif.toolButton',
props: {
icon: 'layout-advanced-mpr',
label: 'MIP',
tooltip: 'Maximum Intensity Projection',
commands: {
commandName: 'setHangingProtocol',
commandOptions: {
protocolId: 'mip',
},
},
evaluate: 'evaluate.action',
},
},
{
id: 'KeyImages',
uiType: 'ohif.toolButton',
props: {
icon: 'Export',
label: 'Key Images',
commands: 'toggleKeyImageMode',
evaluate: [
'evaluate.action',
{
name: 'evaluate.viewport.supported',
unsupportedViewportTypes: ['video', 'wholeSlide'],
},
],
},
},
{
id: 'Only3D',
uiType: 'ohif.toolButton',
props: {
icon: 'layout-advanced-mpr',
label: '3D',
tooltip: 'Rendu volumique 3D',
commands: {
commandName: 'setHangingProtocol',
commandOptions: {
protocolId: 'only3D',
},
},
evaluate: 'evaluate.action',
},
},
{
id: 'Layout',
uiType: 'ohif.layoutSelector',
@@ -723,11 +810,13 @@ export const toolbarSections = {
'TrackballRotate',
'WindowLevel',
'Capture',
'KeyImages',
'Layout',
'Crosshairs',
'MoreTools',
'Reconstruction',
],
Reconstruction: ['MPR', 'MPR3D', 'MIP', 'Only3D'],
[TOOLBAR_SECTIONS.viewportActionMenu.topLeft]: ['orientationMenu', 'dataOverlayMenu'],
[TOOLBAR_SECTIONS.viewportActionMenu.bottomMiddle]: ['AdvancedRenderingControls'],
@@ -6,9 +6,14 @@ import { only3D } from './hps/only3D';
import { primary3D } from './hps/primary3D';
import { primaryAxial } from './hps/primaryAxial';
import { frameView } from './hps/frameView';
import { mip } from './hps/mip';
function getHangingProtocolModule() {
return [
{
name: mip.id,
protocol: mip,
},
{
name: mpr.id,
protocol: mpr,
@@ -0,0 +1,37 @@
import { useEffect, useState } from 'react';
import { loadKeyImagesFromTrizRis } from '../utils/keyImages/loadKeyImagesFromTrizRis';
export const useSavedKeyImages = () => {
const [savedKeyImageSOPs, setSavedKeyImageSOPs] = useState<string[]>([]);
useEffect(() => {
const chargerKeyImages = async () => {
const sopInstanceUIDs = await loadKeyImagesFromTrizRis();
setSavedKeyImageSOPs(sopInstanceUIDs);
};
chargerKeyImages();
}, []);
const removeSavedKeyImage = (sopInstanceUID: string) => {
setSavedKeyImageSOPs(prev => prev.filter(sop => sop !== sopInstanceUID));
};
const addSavedKeyImage = (sopInstanceUID: string) => {
setSavedKeyImageSOPs(prev => {
if (prev.includes(sopInstanceUID)) {
return prev;
}
return [...prev, sopInstanceUID];
});
};
return {
savedKeyImageSOPs,
removeSavedKeyImage,
addSavedKeyImage,
};
};
+75
View File
@@ -0,0 +1,75 @@
import { HYDRATE_SEG_SYNC_GROUP, VOI_SYNC_GROUP } from './mpr';
export const mip = {
id: 'mip',
locked: true,
name: 'MIP',
createdDate: '2026-10-08T00:00:00.000Z',
modifiedDate: '2026-10-08T00:00:00.000Z',
availableTo: {},
editableBy: {},
protocolMatchingRules: [],
imageLoadStrategy: 'interleaveCenter',
displaySetSelectors: {
activeDisplaySet: {
seriesMatchingRules: [
{
weight: 1,
attribute: 'isReconstructable',
constraint: {
equals: {
value: true,
},
},
required: true,
},
],
},
},
stages: [
{
id: 'mipStage',
name: 'MIP',
viewportStructure: {
layoutType: 'grid',
properties: {
rows: 1,
columns: 1,
},
},
viewports: [
{
viewportOptions: {
viewportId: 'mip-axial',
toolGroupId: 'mpr',
viewportType: 'volume',
orientation: 'axial',
initialImageOptions: {
preset: 'middle',
},
syncGroups: [VOI_SYNC_GROUP, HYDRATE_SEG_SYNC_GROUP],
},
displaySets: [
{
id: 'activeDisplaySet',
options: {
blendMode: 'MIP',
},
},
],
},
],
},
],
};
@@ -0,0 +1,74 @@
import { create } from 'zustand';
type KeyImageInfo = {
imageId: string;
viewportId?: string;
};
type KeyImagesState = {
keyImages: Record<string, KeyImageInfo>;
addKeyImage: (imageId: string, viewportId?: string) => void;
removeKeyImage: (imageId: string) => void;
toggleKeyImage: (imageId: string, viewportId?: string) => void;
isKeyImage: (imageId: string) => boolean;
clearKeyImages: () => void;
};
export const useKeyImagesStore = create<KeyImagesState>((set, get) => ({
keyImages: {},
addKeyImage: (imageId, viewportId) => {
set(state => ({
keyImages: {
...state.keyImages,
[imageId]: {
imageId,
viewportId,
},
},
}));
console.log('### KEY IMAGE AJOUTEE ###', imageId);
},
removeKeyImage: imageId => {
set(state => {
const newKeyImages = {
...state.keyImages,
};
delete newKeyImages[imageId];
return {
keyImages: newKeyImages,
};
});
console.log('### KEY IMAGE RETIREE ###', imageId);
},
toggleKeyImage: (imageId, viewportId) => {
const existe = !!get().keyImages[imageId];
if (existe) {
get().removeKeyImage(imageId);
} else {
get().addKeyImage(imageId, viewportId);
}
},
isKeyImage: imageId => {
return !!get().keyImages[imageId];
},
clearKeyImages: () => {
set({
keyImages: {},
});
},
}));
@@ -0,0 +1,32 @@
import { extractDicomInfoFromImageId } from './extractDicomInfoFromImageId';
import { TrizRisConfig } from '@ohif/core/src/config/TrizRisConfig';
export const deleteKeyImageFromTrizRis = async (imageId: string) => {
const dicomInfo = extractDicomInfoFromImageId(imageId);
if (!dicomInfo) {
console.error('Informations DICOM introuvables');
return;
}
const response = await fetch(`${TrizRisConfig.apiBaseUrl}/dicom/key-image`, {
method: 'DELETE',
headers: {
'X-SOP-Instance-UID': dicomInfo.sopInstanceUID,
...(dicomInfo.frameNumber
? {
'X-Frame-Number': dicomInfo.frameNumber,
}
: {}),
},
});
const resultat = await response.text();
console.log('### SUPPRESSION KEY IMAGE TRIZRIS ###');
console.log('HTTP =', response.status);
console.log('Résultat =', resultat);
};
@@ -0,0 +1,322 @@
import html2canvas from 'html2canvas';
import { Enums, getEnabledElement, getRenderingEngine } from '@cornerstonejs/core';
import { getEnabledElement as OHIFgetEnabledElement } from '../../state';
import { extractDicomInfoFromImageId } from './extractDicomInfoFromImageId';
import { ToolGroupManager } from '@cornerstonejs/tools';
import { TrizRisConfig } from '@ohif/core/src/config/TrizRisConfig';
const attendreRenduImage = (element: HTMLElement) => {
return new Promise<void>(resolve => {
let termine = false;
const terminer = () => {
if (termine) {
return;
}
termine = true;
element.removeEventListener(Enums.Events.IMAGE_RENDERED, handler as EventListener);
resolve();
};
const handler = () => {
terminer();
};
element.addEventListener(Enums.Events.IMAGE_RENDERED, handler as EventListener);
// Sécurité si jamais l'événement ne remonte pas
setTimeout(() => {
terminer();
}, 1500);
});
};
export const exportKeyImageToTrizRis = async (imageId: string, viewportId: string) => {
console.log('====================================');
console.log('### DEBUT EXPORT KEY IMAGE ###');
console.log('ImageId demandé =', imageId);
console.log('Viewport source =', viewportId);
const dicomInfo = extractDicomInfoFromImageId(imageId);
if (!dicomInfo) {
console.error('Informations DICOM introuvables');
return;
}
/*
* ------------------------------------------------
* 1. Retrouver le viewport OHIF visible
* ------------------------------------------------
*
* On l'utilise uniquement pour retrouver
* le RenderingEngine et le type du viewport.
*
* ON NE MODIFIE PLUS SON IMAGE.
*/
const enabledElementOHIF = OHIFgetEnabledElement(viewportId);
if (!enabledElementOHIF?.element) {
console.error('Impossible de trouver le viewport OHIF :', viewportId);
return;
}
const sourceElement = enabledElementOHIF.element as HTMLElement;
const sourceEnabledElement = getEnabledElement(sourceElement);
if (!sourceEnabledElement) {
console.error('EnabledElement Cornerstone source introuvable');
return;
}
const sourceViewport = sourceEnabledElement.viewport;
const renderingEngineId = sourceEnabledElement.renderingEngineId;
console.log('RenderingEngine ID =', renderingEngineId);
console.log('Image visible utilisateur =', sourceViewport.getCurrentImageId?.());
const sourceToolGroup = ToolGroupManager.getToolGroupForViewport(
sourceViewport.id,
renderingEngineId
);
if (!sourceToolGroup) {
console.warn('Aucun ToolGroup trouvé pour le viewport source');
}
/*
* ------------------------------------------------
* 2. Retrouver le RenderingEngine
* ------------------------------------------------
*/
const renderingEngine = getRenderingEngine(renderingEngineId);
if (!renderingEngine) {
console.error('RenderingEngine introuvable');
return;
}
/*
* ------------------------------------------------
* 3. Créer un viewport caché hors écran
* ------------------------------------------------
*/
const hiddenViewportId = `key-image-export-${Date.now()}-${Math.random()
.toString(36)
.substring(2)}`;
const hiddenElement = document.createElement('div');
hiddenElement.setAttribute('data-key-image-viewport', hiddenViewportId);
hiddenElement.style.position = 'fixed';
/*
* IMPORTANT :
* ne pas utiliser display:none.
*
* Cornerstone doit réellement pouvoir rendre
* dans le div.
*/
hiddenElement.style.left = '-10000px';
hiddenElement.style.top = '0';
hiddenElement.style.width = '512px';
hiddenElement.style.height = '512px';
hiddenElement.style.pointerEvents = 'none';
hiddenElement.style.background = 'black';
document.body.appendChild(hiddenElement);
try {
/*
* ------------------------------------------------
* 4. Activer le viewport caché Cornerstone
* ------------------------------------------------
*/
console.log('### CREATION VIEWPORT CACHE ###');
renderingEngine.enableElement({
viewportId: hiddenViewportId,
element: hiddenElement,
/*
* On utilise le même type de viewport
* que le viewport source.
*/
type: sourceViewport.type,
defaultOptions: {
background: sourceViewport.defaultOptions?.background,
orientation: sourceViewport.defaultOptions?.orientation,
},
});
if (sourceToolGroup) {
sourceToolGroup.addViewport(hiddenViewportId, renderingEngineId);
}
const captureViewport = renderingEngine.getViewport(hiddenViewportId);
if (!captureViewport) {
console.error('Viewport caché introuvable');
return;
}
/*
* ------------------------------------------------
* 5. Charger LA Key Image dans le viewport caché
* ------------------------------------------------
*/
console.log('### CHARGEMENT KEY IMAGE DANS VIEWPORT CACHE ###');
const renderPromise = attendreRenduImage(hiddenElement);
await captureViewport.setStack([imageId], 0);
captureViewport.render();
await renderPromise;
const imageChargee = captureViewport.getCurrentImageId?.();
console.log('Image chargée dans viewport caché =', imageChargee);
/*
* Sécurité :
* vérifier qu'on capture bien la bonne image.
*/
if (imageChargee !== imageId) {
console.error('ERREUR : le viewport caché n affiche pas la Key Image demandée');
console.error('Demandée =', imageId);
console.error('Affichée =', imageChargee);
return;
}
/*
* ------------------------------------------------
* 6. Transformer le viewport caché en PNG
* ------------------------------------------------
*/
console.log('### CREATION PNG ###');
const canvas = await html2canvas(hiddenElement);
const blob = await new Promise<Blob>((resolve, reject) => {
canvas.toBlob(
blob => {
if (blob) {
resolve(blob);
} else {
reject(new Error('Impossible de créer le PNG'));
}
},
'image/png',
1.0
);
});
console.log('### PNG KEY IMAGE CREE ###');
console.log('StudyInstanceUID =', dicomInfo.studyInstanceUID);
console.log('SeriesInstanceUID =', dicomInfo.seriesInstanceUID);
console.log('SOPInstanceUID =', dicomInfo.sopInstanceUID);
console.log('FrameNumber =', dicomInfo.frameNumber);
console.log('Taille PNG =', blob.size);
/*
* ------------------------------------------------
* 7. Envoyer vers TrizRis
* ------------------------------------------------
*/
console.log('### ENVOI VERS TRIZRIS ###');
const response = await fetch(`${TrizRisConfig.apiBaseUrl}/dicom/save-image`, {
method: 'POST',
headers: {
'Content-Type': 'image/png',
'X-Study-Instance-UID': dicomInfo.studyInstanceUID,
'X-Series-Instance-UID': dicomInfo.seriesInstanceUID,
'X-SOP-Instance-UID': dicomInfo.sopInstanceUID,
...(dicomInfo.frameNumber
? {
'X-Frame-Number': dicomInfo.frameNumber,
}
: {}),
},
body: blob,
});
const resultat = await response.text();
console.log('### REPONSE TRIZRIS ###');
console.log('HTTP =', response.status);
console.log('Résultat =', resultat);
} catch (error) {
console.error('Erreur export Key Image :', error);
} finally {
/*
* ------------------------------------------------
* 8. Détruire le viewport caché
* ------------------------------------------------
*/
console.log('### SUPPRESSION VIEWPORT CACHE ###');
if (sourceToolGroup) {
try {
sourceToolGroup.removeViewports(renderingEngineId, hiddenViewportId);
} catch (error) {
console.warn('Erreur suppression viewport caché du ToolGroup', error);
}
}
try {
renderingEngine.disableElement(hiddenViewportId);
} catch (error) {
console.warn('Erreur lors de la désactivation du viewport caché :', error);
}
if (hiddenElement.parentNode) {
hiddenElement.parentNode.removeChild(hiddenElement);
}
console.log('### FIN EXPORT KEY IMAGE ###');
console.log('====================================');
}
};
@@ -0,0 +1,25 @@
export const extractDicomInfoFromImageId = (imageId: string) => {
if (!imageId) {
return null;
}
const imageIdWithoutPrefix = imageId.replace(/^wadors:/, '').replace(/^dicomweb:/, '');
const match = imageIdWithoutPrefix.match(
/\/studies\/([^/]+)\/series\/([^/]+)\/instances\/([^/]+)(?:\/frames\/(\d+))?/i
);
if (!match) {
console.error('Impossible d extraire les UID depuis imageId :', imageId);
return null;
}
return {
imageId,
studyInstanceUID: decodeURIComponent(match[1]),
seriesInstanceUID: decodeURIComponent(match[2]),
sopInstanceUID: decodeURIComponent(match[3]),
frameNumber: match[4] || null,
};
};
@@ -0,0 +1,41 @@
import { TrizRisConfig } from '@ohif/core/src/config/TrizRisConfig';
export const loadKeyImagesFromTrizRis = async (): Promise<string[]> => {
try {
const response = await fetch(`${TrizRisConfig.apiBaseUrl}/dicom/key-images`);
if (!response.ok) {
console.error('Erreur chargement Key Images :', response.status);
return [];
}
const text = await response.text();
/*
* Ton endpoint renvoie actuellement du XML :
*
* <List>
* <item>...</item>
* </List>
*/
const parser = new DOMParser();
const xml = parser.parseFromString(text, 'application/xml');
const items = Array.from(xml.getElementsByTagName('item'));
const sopInstanceUIDs = items.map(item => item.textContent?.trim()).filter(Boolean) as string[];
console.log('### KEY IMAGES CHARGEES DEPUIS TRIZRIS ###');
console.log(sopInstanceUIDs);
return sopInstanceUIDs;
} catch (error) {
console.error('Erreur récupération Key Images :', error);
return [];
}
};
+58 -10
View File
@@ -28,6 +28,7 @@ import { useViewportsByPositionStore } from './stores/useViewportsByPositionStor
import { useToggleOneUpViewportGridStore } from './stores/useToggleOneUpViewportGridStore';
import requestDisplaySetCreationForStudy from './Panels/requestDisplaySetCreationForStudy';
import promptSaveReport from './utils/promptSaveReport';
import { saveLayoutPreference } from './services/TrizRisLayoutApi';
export type HangingProtocolParams = {
protocolId?: string;
@@ -498,12 +499,21 @@ const commandsModule = ({
/**
* Changes the viewport grid layout in terms of the MxN layout.
*/
setViewportGridLayout: ({ numRows, numCols, isHangingProtocolLayout = false }) => {
const { protocol } = hangingProtocolService.getActiveProtocol();
const onLayoutChange = protocol.callbacks?.onLayoutChange;
if (commandsManager.run(onLayoutChange, { numRows, numCols }) === false) {
// Don't apply the layout if the run command returns false
return;
setViewportGridLayout: ({
numRows,
numCols,
isHangingProtocolLayout = false,
savePreference = true,
}) => {
const activeProtocol = hangingProtocolService.getActiveProtocol();
const protocol = activeProtocol?.protocol;
const onLayoutChange = protocol?.callbacks?.onLayoutChange;
if (onLayoutChange) {
if (commandsManager.run(onLayoutChange, { numRows, numCols }) === false) {
return;
}
}
const completeLayout = () => {
@@ -525,9 +535,49 @@ const commandsModule = ({
findOrCreateViewport,
isHangingProtocolLayout,
});
console.log('### LAYOUT CHOISI ###');
console.log('numRows =', numRows);
console.log('numCols =', numCols);
console.log('isHangingProtocolLayout =', isHangingProtocolLayout);
if (!isHangingProtocolLayout && savePreference) {
const hangingProtocolState = hangingProtocolService.getState();
const studyInstanceUID = hangingProtocolState.activeStudyUID;
console.log('### STUDY UID POUR LAYOUT ###', studyInstanceUID);
if (!studyInstanceUID) {
console.error('StudyInstanceUID introuvable dans URL');
return;
}
saveLayoutPreference(numRows, numCols, studyInstanceUID)
.then(() => {
console.log('### LAYOUT SAUVEGARDE AVEC SUCCES ###');
})
.catch(error => {
console.error('### ERREUR SAUVEGARDE LAYOUT ###', error);
});
}
};
// Need to finish any work in the callback
window.setTimeout(completeLayout, 0);
const applyLayoutWhenReady = () => {
const hpState = hangingProtocolService.getState();
if (!hpState) {
console.log('### HANGING PROTOCOL PAS ENCORE PRET -> ATTENTE ###');
window.setTimeout(applyLayoutWhenReady, 100);
return;
}
console.log('### HANGING PROTOCOL PRET -> APPLICATION LAYOUT ###');
completeLayout();
};
applyLayoutWhenReady();
},
toggleOneUp() {
@@ -805,9 +855,7 @@ const commandsModule = ({
}
const reportBlob = datasetToDicomBlob(instances[0]);
const type = defaultContentType || 'application/dicom';
await navigator.clipboard.write([
new ClipboardItem({ [type]: reportBlob }),
]);
await navigator.clipboard.write([new ClipboardItem({ [type]: reportBlob })]);
};
}
@@ -0,0 +1,29 @@
import { TrizRisConfig } from '@ohif/core/src/config/TrizRisConfig';
const ACCESS_URL = `${TrizRisConfig.apiBaseUrl}/ohif/access`;
export async function checkTrizRisAccess(): Promise<boolean> {
try {
const response = await fetch(ACCESS_URL, {
method: 'GET',
headers: {
Accept: 'application/json',
},
credentials: 'include',
});
if (!response.ok) {
return false;
}
const result = await response.json();
return result.authorized === true;
} catch (error) {
console.error('### ERREUR VERIFICATION ACCES TRIZRIS ###', error);
return false;
}
}
@@ -0,0 +1,61 @@
import { TrizRisConfig } from '@ohif/core/src/config/TrizRisConfig';
const BASE_URL = `${TrizRisConfig.apiBaseUrl}/image-view-state/current`;
export type ImageViewState = {
zoom: number;
rotation: number;
studyInstanceUID: string;
seriesInstanceUID: string;
sopInstanceUID: string;
};
export async function saveImageViewState(state: ImageViewState): Promise<void> {
const response = await fetch(BASE_URL, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
Accept: 'application/json',
},
credentials: 'include',
body: JSON.stringify(state),
});
if (!response.ok) {
throw new Error(`Erreur sauvegarde image view state : ${response.status}`);
}
}
export async function getImageViewState(
studyInstanceUID: string,
seriesInstanceUID: string,
sopInstanceUID: string
): Promise<ImageViewState | null> {
const url =
`${BASE_URL}` +
`?studyInstanceUID=${encodeURIComponent(studyInstanceUID)}` +
`&seriesInstanceUID=${encodeURIComponent(seriesInstanceUID)}` +
`&sopInstanceUID=${encodeURIComponent(sopInstanceUID)}`;
const response = await fetch(url, {
method: 'GET',
headers: {
Accept: 'application/json',
},
credentials: 'include',
});
if (response.status === 204) {
return null;
}
if (!response.ok) {
throw new Error(`Erreur récupération image view state : ${response.status}`);
}
return response.json();
}
@@ -0,0 +1,59 @@
import { TrizRisConfig } from '@ohif/core/src/config/TrizRisConfig';
const BASE_URL = `${TrizRisConfig.apiBaseUrl}/layout/current`;
export type SavedLayout = {
numRows: number;
numCols: number;
};
export async function saveLayoutPreference(
numRows: number,
numCols: number,
studyInstanceUID: string
): Promise<void> {
const response = await fetch(BASE_URL, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
Accept: 'application/json',
},
credentials: 'include',
body: JSON.stringify({
numRows,
numCols,
studyInstanceUID,
}),
});
if (!response.ok) {
throw new Error(`Erreur sauvegarde layout TrizRis : ${response.status}`);
}
}
export async function getLayoutPreference(studyInstanceUID: string): Promise<SavedLayout | null> {
const response = await fetch(
`${BASE_URL}?studyInstanceUID=${encodeURIComponent(studyInstanceUID)}`,
{
method: 'GET',
headers: {
Accept: 'application/json',
},
credentials: 'include',
}
);
if (response.status === 204) {
return null;
}
if (!response.ok) {
throw new Error(`Erreur récupération layout TrizRis : ${response.status}`);
}
return response.json();
}