ajout mock version 2

Author: Romain Andres

api.py

@@ -1,15 +1,18 @@
 import os
 import shutil
 import tempfile
+from io import BytesIO
+from typing import List
 
 import pydicom
 import requests
 from dotenv import load_dotenv
 from flask import Flask, g, jsonify, render_template, request
 from flask_cors import CORS
+from pydicom.dataset import Dataset
 
 from BDD.MesuresSQLite import MesuresDB
-from mock import simulate_modele_transform, simulate_rtstruct_generation
+from mock import simulate_rtstruct_generation2
 
 load_dotenv()
 
@@ -133,78 +136,39 @@ def segmentation(study_instance_uid):
         return jsonify({"error": "StudyInstanceUID not found"}), 404
 
     try:
-        # Utiliser l'ID Orthanc pour récupérer les instances DICOM pour l'étude spécifiée
-        response = requests.get(f"{ORTHANC_URL}/studies/{orthanc_study_id}/instances")
-        if response.status_code == 200:
-            dicom_instances = response.json()
-            print("DICOM Instances for StudyInstanceUID", study_instance_uid, ":", dicom_instances)
-            
-            # Ici, ajouter logique de traitement des images DICOM récupérées
-            # Pour le moment, on simule la génération du RTStruct
-            rtstruct_path = simulate_rtstruct_generation()  # mock
-            
-            return upload_rtstruct_mocked(rtstruct_path)
-        else:
-            return jsonify({"error": "Failed to retrieve DICOM instances"}), response.status_code
-    except requests.exceptions.RequestException as e:
-        print(f"Erreur lors du traitement du fichier DICOM : {e}")
-        return jsonify({"error": "Server error"}), 500
-    
-
-
-@app.route('/seuillage/<study_instance_uid>', methods=['POST'])
-def apply_seuillage_to_study(study_instance_uid):
-    orthanc_study_id = find_orthanc_study_id_by_study_instance_uid(study_instance_uid)
-    if not orthanc_study_id:
-        return jsonify({"error": "StudyInstanceUID not found"}), 404
-
-    try:
+        # Récupérer les métadonnées des instances DICOM pour l'étude spécifiée
         response = requests.get(f"{ORTHANC_URL}/studies/{orthanc_study_id}/instances")
         if response.status_code != 200:
             return jsonify({"error": "Failed to retrieve DICOM instances"}), response.status_code
-        
-        dicom_instances = response.json()
-        temp_dir = tempfile.mkdtemp()
 
-        file_paths = []
-        for instance in dicom_instances:
+        # Extraire les identifiants des instances DICOM à partir de la réponse JSON
+        instances = response.json()
+        dicom_data = []
+
+        # Télécharger chaque fichier DICOM en utilisant son identifiant
+        for instance in instances:
             instance_id = instance['ID']
-            dicom_file = requests.get(f"{ORTHANC_URL}/instances/{instance_id}/file", stream=True)
-            temp_file_path = os.path.join(temp_dir, f"{instance_id}.dcm")
-            with open(temp_file_path, 'wb') as f:
-                for chunk in dicom_file:
-                    f.write(chunk)
-            file_paths.append(temp_file_path)
+            dicom_response = requests.get(f"{ORTHANC_URL}/instances/{instance_id}/file", stream=True)
 
-        # Apply the seuillage transformation
-        modified_dicoms = simulate_modele_transform(file_paths)
-        print("test")
-        # Optionally upload modified DICOMs back to Orthanc
+            if dicom_response.status_code == 200:
+                # Vous pouvez ici charger les données DICOM directement dans pydicom si nécessaire
+                dicom_file = pydicom.dcmread(BytesIO(dicom_response.content))
+                dicom_data.append(dicom_file)
+            else:
+                print(f"Failed to download DICOM file for instance ID {instance_id}")
 
-        delete_dicom_instance(study_instance_uid)
-        
-        """
-        for modified_dicom in modified_dicoms:
-            print("Uploading")
-            temp_file_path = os.path.join(temp_dir, modified_dicom.filename)
-            modified_dicom.save_as(temp_file_path)
-            with open(temp_file_path, 'rb') as f:
-                files = {'file': (os.path.basename(temp_file_path), f, 'application/dicom')}
-                upload_response = requests.post(f"{ORTHANC_URL}/instances", files=files)
-                print("Upload response:", upload_response.status_code)
-                if upload_response.status_code not in [200, 202]:
-                    print("Failed to upload modified DICOM file to Orthanc:", upload_response.status_code)
-        """
-        shutil.rmtree(temp_dir)  # Clean up temporary files
+        print("DICOM files retrieved and processed successfully.")
+        #print(dicom_data[0])
+        rtstruct = simulate_rtstruct_generation2(dicom_data)  # mock
+        print("mon rtstruct c'est cela")
+        print(rtstruct)
+        upload_rtstruct(rtstruct)
 
+        return jsonify({"success": "DICOM files retrieved and processed successfully."}), 200
     except requests.exceptions.RequestException as e:
-        return jsonify({"error": str(e)}), 500
-
-    return jsonify({"success": "Seuillage applied and DICOMs uploaded."}), 200
+        return jsonify({"error": f"Server error: {str(e)}"}), 500
 
 
-
-    
 def find_orthanc_study_id_by_study_instance_uid(study_instance_uid):
     studies_response = requests.get(f"{ORTHANC_URL}/studies")
 
@@ -228,7 +192,8 @@ def find_orthanc_study_id_by_study_instance_uid(study_instance_uid):
 
     return None
 
-def upload_rtstruct_mocked(rtstruct_path):
+"""
+def upload_rtstruct(rtstruct_path):
     try:
         print(f"Uploading RTStruct from {rtstruct_path}")
         
@@ -244,6 +209,45 @@ def upload_rtstruct_mocked(rtstruct_path):
     except Exception as e:
         print(e)
         return jsonify({"error": "Server error"}), 500
+"""
+
+def upload_rtstruct(rtstruct):
+    buffer = rtstruct.save_to_memory()  # Récupère le buffer en mémoire contenant le RTStruct
+    print("Uploading RTStruct...")
+    print(buffer)
+    try:
+        files = {'file': ('rtstruct.dcm', buffer, 'application/dicom')}
+        response = requests.post(f"{ORTHANC_URL}/instances", files=files)
+
+        if response.status_code in [200, 202]:
+            orthanc_response = response.json() if response.content else "No JSON content in response"
+            return jsonify({"success": "RTStruct uploaded successfully", "OrthancResponse": orthanc_response}), response.status_code
+        else:
+            return jsonify({"error": "Failed to upload RTStruct to Orthanc", "OrthancResponse": response.text}), response.status_code
+    except Exception as e:
+        print(e)
+        return jsonify({"error": "Server error"}), 500
+    
+
+def load_dicom_datasets(dicom_folder_path: str) -> List[Dataset]:
+    """
+    Charge tous les fichiers DICOM d'un dossier donné en datasets pydicom.
+    """
+    dicom_datasets = []
+    for filename in os.listdir(dicom_folder_path):
+        if filename.endswith('.dcm'):
+            file_path = os.path.join(dicom_folder_path, filename)
+            try:
+                ds = pydicom.dcmread(file_path)
+                dicom_datasets.append(ds)
+            except Exception as e:
+                print(f"Erreur lors de la lecture du fichier DICOM {filename}: {e}")
+                continue  # ou lever une exception selon les besoins de votre application
+
+    if not dicom_datasets:
+        raise Exception("Aucun fichier DICOM valide trouvé dans le dossier spécifié.")
+
+    return dicom_datasets
 
 def get_db():
     db = getattr(g, '_database', None)

mock.py

@@ -1,45 +1,21 @@
 import os
+import sys
 import time as t
+from typing import List
 
 import matplotlib.pyplot as plt
+import nibabel as nib
 import numpy as np
 import pydicom
 import torch
+from pydicom.dataset import Dataset
 from pydicom.encaps import encapsulate
-from MetIA.Modele import Net 
+from scipy.ndimage import gaussian_filter, sobel
 
-import nibabel as nib
+from rt_utils import RTStructBuilder
 
 PATH_MODEL = './MetIA/resultsult/'
 
-def simulate_modele_transform(file_paths):
-    modified_dicoms = []  # Liste pour stocker les objets DICOM modifiés
-
-    for file_path in file_paths:
-        # Chargement du fichier DICOM
-        dicom_data = pydicom.dcmread(file_path)
-
-        # Extraction de l'image des données DICOM
-        image = dicom_data.pixel_array
-        
-        # Application du seuillage simple
-        thresholded_image = np.where(image > 1000, image, 0)
-
-        # Vérifiez si les données sont compressées et encapsulez-les si nécessaire
-        if dicom_data.file_meta.TransferSyntaxUID in [pydicom.uid.JPEGBaseline, pydicom.uid.JPEGExtended, pydicom.uid.JPEG2000]:
-            # Encapsulate the modified data
-            dicom_data.PixelData = encapsulate([thresholded_image.tobytes()])
-        else:
-            dicom_data.PixelData = thresholded_image.tobytes()
-
-        dicom_data.Rows, dicom_data.Columns = thresholded_image.shape
-        
-        # Ajout de l'objet DICOM modifié à la liste
-        modified_dicoms.append(dicom_data)
-    
-    # Retourne la liste des données DICOM modifiées
-    return modified_dicoms
-
 
 def simulate_rtstruct_generation():
     print()
@@ -53,19 +29,51 @@ def simulate_rtstruct_generation():
     rtstruct_path = '/home/romain/Documents/P_R_O_J_E_C_T_S/projetIRM/BrainMetaSegmentatorUI-Back/1-1.dcm'
     return rtstruct_path
 
+# pour détecter les contours d'une image DICOM
+def detect_contours(image):
+    """
+    Si tu ne comprends rien :  
+    Un filtre de Sobel est appliqué pour trouver les gradients dans les deux directions x et y. 
+    Le gradient total (magnitude) est calculé et un seuil est appliqué pour obtenir un masque de contour.
+    """
+    
+    # lissage de l'image pour réduire le bruit avant la détection des contours
+    smoothed_image = gaussian_filter(image, sigma=2)
+    
+    # calcul du gradient de l'image lissée
+    sx = sobel(smoothed_image, axis=0, mode='constant')
+    sy = sobel(smoothed_image, axis=1, mode='constant')
+    sobel_mag = np.hypot(sx, sy)
+    
+    # seuil de détection du contour
+    threshold = np.percentile(sobel_mag, 95)
+    
+    # matrice boolenne
+    return sobel_mag > threshold
+
+def simulate_rtstruct_generation2(dicom_datasets: List[Dataset]):
 
-def prediction(ArrayDicoms):
-    # conversion des dicoms en nifti 
-    # ArrayDicoms : liste des dicoms
-    # prediction : liste des nifti
-    prediction = []
-    for dicom in ArrayDicoms:
-        # co
+    dicom_files = dicom_datasets
+    # lire et trier les fichiers dicoms par 'InstanceNumber' #si c pas fait, les rois corespondront pas aux dicoms
+    dicom_files.sort(key=lambda x: x.InstanceNumber if 'InstanceNumber' in dir(x) else 0)
+    # creation du rtstruct vierge
+    rtstruct = RTStructBuilder.create_new_from_memory(dicom_datasets)
+
+
+    # init du masque 3D basé sur le nombre de fichiers et la taille des images
+    num_slices = len(dicom_files)
+    mask_shape = (dicom_files[0].Rows, dicom_files[0].Columns, num_slices)
+    full_mask = np.zeros(mask_shape, dtype=bool)
+
+    # pour chaque fichier dicom :
+    for i, dicom_data in enumerate(dicom_files):
+        # calculer le masque correspondant et le mettre dans le masque 3D
+        image = dicom_data.pixel_array
+        contour_mask = detect_contours(image)
+        full_mask[:, :, i] = contour_mask  # remplissage du masque 3D
 
-    # prediction du modele, recharger le modele : 
-    model = Net()
-    model.load_state_dict(torch.load(PATH_MODEL)) 
-    model.eval()
-    # prediction : application du modele sur les images converties en nifti
+    # ajouter le masque au fichier RTStruct
+    rtstruct.add_roi(mask=full_mask, color=[255, 0, 0], name='Brain Contours')
 
-    return prediction
+    # sauvegarde du fichier rtstruct
+    return rtstruct

rt_utils/__init__.py

@@ -0,0 +1,3 @@
+from .rtstruct import RTStruct
+from .rtstruct_builder import RTStructBuilder
+from .rtstruct_merger import RTStructMerger