Update app.py

app.py

@@ -1,69 +1,98 @@
 import streamlit as st
-from transformers import AutoModelForObjectDetection
+from transformers import pipeline
 import torch
-from PIL import Image
-import numpy as np
-import cv2
+from PIL import Image, ImageDraw
+import io
 
-st.set_page_config(page_title="Détection de nodules pulmonaires")
-st.title("Détection de nodules pulmonaires sur images scanner")
+st.set_page_config(page_title="Détection de Fractures Osseuses", layout="wide")
 
 @st.cache_resource
 def load_model():
-    model = AutoModelForObjectDetection.from_pretrained("monai-test/lung_nodule_ct_detection")
-    model.eval()
-    return model
+    return pipeline("object-detection", model="D3STRON/bone-fracture-detr")
 
-def process_image(image):
-    # Convertir en niveau de gris
-    img_array = np.array(image.convert('L'))
-    # Normaliser
-    normalized = (img_array - img_array.min()) / (img_array.max() - img_array.min())
-    # Redimensionner
-    resized = cv2.resize(normalized, (512, 512))
-    # Préparer pour PyTorch
-    tensor = torch.FloatTensor(resized).unsqueeze(0).unsqueeze(0)
-    return tensor
+def draw_boxes(image, predictions):
+    draw = ImageDraw.Draw(image)
+    for pred in predictions:
+        box = pred['box']
+        label = f"{pred['label']} ({pred['score']:.2%})"
+        
+        # Draw bounding box
+        draw.rectangle(
+            [(box['xmin'], box['ymin']), (box['xmax'], box['ymax'])],
+            outline="red",
+            width=3
+        )
+        
+        # Draw label background
+        text_bbox = draw.textbbox((box['xmin'], box['ymin']), label)
+        draw.rectangle(text_bbox, fill="red")
+        
+        # Draw label text
+        draw.text(
+            (box['xmin'], box['ymin']),
+            label,
+            fill="white"
+        )
+    return image
+
+def main():
+    st.title("🦴 Détecteur de Fractures Osseuses")
+    st.write("Téléchargez une radiographie pour détecter les fractures osseuses.")
 
-try:
-    model = load_model()
+    pipe = load_model()
+    
+    uploaded_file = st.file_uploader(
+        "Choisissez une image de radiographie", 
+        type=['png', 'jpg', 'jpeg']
+    )
 
-    uploaded_file = st.file_uploader("Téléchargez une image scanner", type=["jpg", "jpeg", "png"])
+    conf_threshold = st.slider(
+        "Seuil de confiance",
+        min_value=0.0,
+        max_value=1.0,
+        value=0.5,
+        step=0.05
+    )
 
     if uploaded_file:
-        image = Image.open(uploaded_file)
-        
         col1, col2 = st.columns(2)
         
-        with col1:
-            st.image(image, caption="Image originale", use_container_width=True)
-        
-        with col2:
-            with torch.no_grad():
-                input_tensor = process_image(image)
-                predictions = model(input_tensor)
-                
-            # Visualisation
-            img_array = np.array(image)
-            for pred in predictions:
-                if pred['score'] > 0.5:
-                    box = pred['box']
-                    x1, y1, x2, y2 = map(int, [box['xmin'], box['ymin'], box['xmax'], box['ymax']])
-                    cv2.rectangle(img_array, (x1, y1), (x2, y2), (255, 0, 0), 2)
-                    text = f"Nodule: {pred['score']:.2f}"
-                    cv2.putText(img_array, text, (x1, y1-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
+        # Original image
+        image = Image.open(uploaded_file)
+        col1.header("Image originale")
+        col1.image(image)
+
+        # Process image
+        with st.spinner("Analyse en cours..."):
+            predictions = pipe(image)
             
-            st.image(img_array, caption="Détections", use_container_width=True)
-        
-        # Résultats
-        if len(predictions) > 0:
-            st.warning(f"⚠️ {len(predictions)} nodules détectés")
-            for i, pred in enumerate(predictions, 1):
-                if pred['score'] > 0.5:
-                    st.write(f"Nodule {i}: Confiance {pred['score']:.1%}")
-        else:
-            st.success("✅ Aucun nodule détecté")
+            # Filter predictions based on confidence threshold
+            filtered_preds = [
+                pred for pred in predictions 
+                if pred['score'] >= conf_threshold
+            ]
+            
+            # Draw boxes on a copy of the image
+            result_image = image.copy()
+            result_image = draw_boxes(result_image, filtered_preds)
+            
+            # Display results
+            col2.header("Résultats de la détection")
+            col2.image(result_image)
+            
+            # Display detailed predictions
+            if filtered_preds:
+                st.subheader("Détails des détections")
+                for pred in filtered_preds:
+                    st.write(
+                        f"• Type: {pred['label']} - "
+                        f"Confiance: {pred['score']:.2%}"
+                    )
+            else:
+                st.warning(
+                    "Aucune fracture détectée avec le seuil de confiance actuel. "
+                    "Essayez de baisser le seuil pour plus de résultats."
+                )
 
-except Exception as e:
-    st.error(f"Erreur lors du chargement du modèle: {str(e)}")
-    st.info("Veuillez vérifier que le modèle est correctement configuré sur Hugging Face.")
+if __name__ == "__main__":
+    main()