Update app.py

app.py

@@ -1,8 +1,7 @@
 import streamlit as st
 from transformers import pipeline
 from PIL import Image, ImageDraw
-import numpy as np
-import colorsys
+import torch
 
 st.set_page_config(
     page_title="Fraktur Detektion",
@@ -12,85 +11,98 @@ st.set_page_config(
 
 st.markdown("""
 <style>
+    /* Reset et base */
     .stApp {
-        background: #f0f2f5 !important;
+        background-color: var(--background-color) !important;
+        padding: 0 !important;
+        overflow: hidden !important;
     }
     
+    /* Variables de thème */
+    [data-theme="light"] {
+        --background-color: #ffffff;
+        --text-color: #1f2937;
+        --border-color: #e5e7eb;
+        --secondary-bg: #f3f4f6;
+    }
+    
+    [data-theme="dark"] {
+        --background-color: #1f2937;
+        --text-color: #f3f4f6;
+        --border-color: #4b5563;
+        --secondary-bg: #374151;
+    }
+    
+    /* Layout principal */
     .block-container {
-        padding-top: 0 !important;
-        padding-bottom: 0 !important;
-        max-width: 1400px !important;
+        padding: 0.5rem !important;
+        max-width: 100% !important;
     }
     
-    .upload-container {
-        background: white;
-        padding: 1.5rem;
-        border-radius: 10px;
-        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-        margin-bottom: 1rem;
-        text-align: center;
+    /* Contrôles et upload */
+    .uploadedFile {
+        border: 1px dashed var(--border-color);
+        border-radius: 0.375rem;
+        padding: 0.25rem;
+        background: var(--secondary-bg);
     }
     
-    .results-container {
-        background: white;
-        padding: 1.5rem;
-        border-radius: 10px;
-        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    /* Ajustement des colonnes */
+    [data-testid="column"] {
+        padding: 0 0.5rem !important;
     }
     
-    .result-box {
-        background: #f8f9fa;
-        padding: 0.75rem;
-        border-radius: 8px;
-        margin: 0.5rem 0;
-        border: 1px solid #e9ecef;
+    /* Images adaptatives */
+    .stImage > img {
+        width: 100% !important;
+        height: auto !important;
+        max-height: 400px !important;
+        object-fit: contain !important;
     }
     
-    h1, h2, h3, h4, p {
-        color: #1a1a1a !important;
-        margin: 0.5rem 0 !important;
+    /* Résultats */
+    .result-box {
+        padding: 0.375rem;
+        border-radius: 0.375rem;
+        margin: 0.25rem 0;
+        background: var(--secondary-bg);
+        border: 1px solid var(--border-color);
+        color: var(--text-color);
     }
     
-    .stImage {
-        background: white;
-        padding: 0.5rem;
-        border-radius: 8px;
-        box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+    /* Titres */
+    h2, h3 {
+        margin: 0 !important;
+        padding: 0.5rem 0 !important;
+        font-size: 1rem !important;
+        color: var(--text-color) !important;
     }
     
-    .stImage > img {
-        max-height: 300px !important;
-        width: auto !important;
-        margin: 0 auto !important;
-        display: block !important;
+    /* Nettoyage des éléments inutiles */
+    #MainMenu, footer, header, .viewerBadge_container__1QSob, .stDeployButton {
+        display: none !important;
     }
     
-    [data-testid="stFileUploader"] {
-        width: 100% !important;
+    /* Ajustements espacement */
+    div[data-testid="stVerticalBlock"] {
+        gap: 0.5rem !important;
     }
     
-    .stButton > button {
-        width: 200px;
-        background-color: #0066cc !important;
-        color: white !important;
-        border: none !important;
-        padding: 0.5rem 1rem !important;
-        border-radius: 5px !important;
-        transition: all 0.3s ease !important;
+    .element-container {
+        margin: 0.25rem 0 !important;
     }
     
-    .stButton > button:hover {
-        background-color: #0052a3 !important;
-        transform: translateY(-1px);
+    /* Éléments spécifiques */
+    .high-confidence {
+        color: #22c55e !important;
     }
     
-    #MainMenu, footer, header, [data-testid="stToolbar"] {
-        display: none !important;
+    .medium-confidence {
+        color: #eab308 !important;
     }
     
-    /* Hide deprecation warning */
-    [data-testid="stExpander"], .element-container:has(>.stAlert) {
-        display: none !important;
+    .low-confidence {
+        color: #dc2626 !important;
     }
 </style>
 """, unsafe_allow_html=True)
@@ -107,7 +119,7 @@ def load_models():
 def translate_label(label):
     translations = {
         "fracture": "Knochenbruch",
-        "no fracture": "Kein Knochenbruch",
+        "no fracture": "Kein Bruch",
         "normal": "Normal",
         "abnormal": "Auffällig",
         "F1": "Knochenbruch",
@@ -115,184 +127,149 @@ def translate_label(label):
     }
     return translations.get(label.lower(), label)
 
-def create_heatmap_overlay(image, box, score):
-    overlay = Image.new('RGBA', image.size, (0, 0, 0, 0))
-    draw = ImageDraw.Draw(overlay)
-    
-    def get_temp_color(value):
-        if value > 0.8:
-            return (255, 0, 0)  # Rouge vif
-        elif value > 0.6:
-            return (255, 69, 0)  # Rouge-orange
-        elif value > 0.4:
-            return (255, 165, 0)  # Orange
-        else:
-            return (255, 255, 0)  # Jaune
-    
-    x1, y1 = box['xmin'], box['ymin']
-    x2, y2 = box['xmax'], box['ymax']
-    width = x2 - x1
-    height = y2 - y1
-    
-    steps = 30
-    for i in range(steps):
-        alpha = int(255 * (1 - (i / steps)) * 0.7)
-        base_color = get_temp_color(score)
-        color = base_color + (alpha,)
-        
-        shrink_x = (i * width) / (steps * 2)
-        shrink_y = (i * height) / (steps * 2)
-        
-        draw.rectangle(
-            [x1 + shrink_x, y1 + shrink_y, x2 - shrink_x, y2 - shrink_y],
-            fill=color,
-            outline=None
-        )
-    
-    border_color = get_temp_color(score) + (200,)
-    draw.rectangle([x1, y1, x2, y2], outline=border_color, width=2)
-    
-    return overlay
-
 def draw_boxes(image, predictions):
-    result_image = image.copy().convert('RGBA')
-    
-    sorted_predictions = sorted(predictions, key=lambda x: x['score'])
-    
-    for pred in sorted_predictions:
+    draw = ImageDraw.Draw(image)
+    for pred in predictions:
         box = pred['box']
         score = pred['score']
         
-        heatmap = create_heatmap_overlay(image, box, score)
-        result_image = Image.alpha_composite(result_image, heatmap)
+        # Calcul de la température simulée basée sur le score
+        # Score 1.0 -> 39°C (forte probabilité = "plus chaud")
+        # Score 0.6 -> 36.5°C (seuil minimum = "normal")
+        temp = 36.5 + (score - 0.6) * (39 - 36.5) / 0.4
         
-        draw = ImageDraw.Draw(result_image)
-        temp = 36.5 + (score * 2.5)
-        label = f"{translate_label(pred['label'])} ({score:.1%}) • {temp:.1f}°C"
+        # Couleur basée sur le score
+        if score > 0.8:
+            color = "#dc2626"  # rouge pour haute confiance
+        elif score > 0.7:
+            color = "#ea580c"  # orange pour confiance moyenne-haute
+        else:
+            color = "#eab308"  # jaune pour confiance moyenne
         
-        text_bbox = draw.textbbox((box['xmin'], box['ymin']-25), label)
-        padding = 3
-        text_bbox = (
-            text_bbox[0]-padding, text_bbox[1]-padding,
-            text_bbox[2]+padding, text_bbox[3]+padding
+        # Dessiner la boîte
+        draw.rectangle(
+            [(box['xmin'], box['ymin']), (box['xmax'], box['ymax'])],
+            outline=color,
+            width=2
         )
-        draw.rectangle(text_bbox, fill="#000000CC")
         
+        # Créer le label avec température
+        label = f"{translate_label(pred['label'])} ({score:.1%} • {temp:.1f}°C)"
+        
+        # Fond pour le texte
+        text_bbox = draw.textbbox((box['xmin'], box['ymin']-15), label)
+        draw.rectangle(text_bbox, fill=color)
+        
+        # Texte
         draw.text(
-            (box['xmin'], box['ymin']-25),
+            (box['xmin'], box['ymin']-15),
             label,
-            fill="#FFFFFF",
-            stroke_width=1,
-            stroke_fill="#000000"
+            fill="white"
         )
     
-    return result_image
+    return image
 
 def main():
     models = load_models()
-    
-    with st.container():
-        st.write("### 📤 Röntgenbild hochladen")
-        uploaded_file = st.file_uploader("Bild auswählen", type=['png', 'jpg', 'jpeg'], label_visibility="collapsed")
+
+    # Disposition en deux colonnes principales
+    col1, col2 = st.columns([1, 2])
+
+    with col1:
+        st.markdown("### 📤 Röntgenbild Upload")
+        uploaded_file = st.file_uploader("", type=['png', 'jpg', 'jpeg'])
         
-        col1, col2 = st.columns([2, 1])
-        with col1:
+        if uploaded_file:
             conf_threshold = st.slider(
                 "Konfidenzschwelle",
                 min_value=0.0, max_value=1.0,
-                value=0.60, step=0.05,
-                label_visibility="visible"
+                value=0.60, step=0.05
             )
-        with col2:
-            analyze_button = st.button("Analysieren")
 
-    if uploaded_file and analyze_button:
-        with st.spinner("Bild wird analysiert..."):
+    with col2:
+        if uploaded_file:
             image = Image.open(uploaded_file)
-            results_container = st.container()
             
-            predictions_watcher = models["KnochenWächter"](image)
-            predictions_master = models["RöntgenMeister"](image)
-            predictions_locator = models["KnochenAuge"](image)
+            st.markdown("### 🔍 Meinung der KI-Experten")
             
-            has_fracture = False
-            max_fracture_score = 0
-            filtered_locations = [p for p in predictions_locator 
-                                if p['score'] >= conf_threshold 
-                                and 'fracture' in p['label'].lower()]
+            # KnochenAuge Analysis (Localisation)
+            st.markdown("#### 👁️ Das KnochenAuge - Lokalisation")
+            predictions = models["KnochenAuge"](image)
+            filtered_preds = [p for p in predictions if p['score'] >= conf_threshold]
             
-            for pred in predictions_watcher:
-                if pred['score'] >= conf_threshold and 'fracture' in pred['label'].lower():
-                    has_fracture = True
-                    max_fracture_score = max(max_fracture_score, pred['score'])
+            if filtered_preds:
+                result_image = image.copy()
+                result_image = draw_boxes(result_image, filtered_preds)
+                st.image(result_image, use_container_width=True)
+            else:
+                st.image(image, use_container_width=True)
+                st.info("Keine signifikanten Auffälligkeiten gefunden.")
             
-            with results_container:
-                st.write("### 🔍 Analyse Ergebnisse")
-                col1, col2 = st.columns(2)
-                
-                with col1:
-                    st.write("#### 🤖 KI-Diagnose")
-                    
-                    st.write("##### 🛡️ KnochenWächter")
-                    for pred in predictions_watcher:
-                        if pred['score'] >= conf_threshold:
-                            confidence_color = '#0066cc' if pred['score'] > 0.7 else '#ffa500'
-                            label_lower = pred['label'].lower()
-                            if 'fracture' in label_lower:
-                                has_fracture = True
-                                max_fracture_score = max(max_fracture_score, pred['score'])
-                            st.markdown(f"""
-                                <div class="result-box" style="color: #1a1a1a;">
-                                    <span style="color: {confidence_color}; font-weight: 500;">
-                                        {pred['score']:.1%}
-                                    </span> - {translate_label(pred['label'])}
-                                </div>
-                            """, unsafe_allow_html=True)
-                    
-                    st.write("#### 🎓 RöntgenMeister")
-                    for pred in predictions_master:
-                        if pred['score'] >= conf_threshold:
-                            confidence_color = '#0066cc' if pred['score'] > 0.7 else '#ffa500'
-                            st.markdown(f"""
-                                <div class="result-box" style="color: #1a1a1a;">
-                                    <span style="color: {confidence_color}; font-weight: 500;">
-                                        {pred['score']:.1%}
-                                    </span> - {translate_label(pred['label'])}
-                                </div>
-                            """, unsafe_allow_html=True)
-                    
-                    if max_fracture_score > 0:
-                        st.write("#### 📊 Wahrscheinlichkeit")
-                        no_fracture_prob = 1 - max_fracture_score
+            # Other Models Analysis
+            st.markdown("#### 🎯 KI-Analyse")
+            col_left, col_right = st.columns(2)
+            
+            def get_score_class(score):
+                if score > 0.8:
+                    return "high-confidence"
+                elif score > 0.7:
+                    return "medium-confidence"
+                return "low-confidence"
+            
+            with col_left:
+                st.markdown("**🛡️ Der KnochenWächter**")
+                predictions = models["KnochenWächter"](image)
+                has_predictions = False
+                for pred in predictions:
+                    if pred['score'] >= conf_threshold:
+                        has_predictions = True
+                        score_class = get_score_class(pred['score'])
+                        st.markdown(f"""
+                            <div class='result-box'>
+                                <span class='{score_class}' style='font-weight: 500;'>
+                                    {pred['score']:.1%}
+                                </span> - {translate_label(pred['label'])}
+                            </div>
+                        """, unsafe_allow_html=True)
+                if not has_predictions:
+                    st.info("Keine ausreichend sicheren Vorhersagen.")
+            
+            with col_right:
+                st.markdown("**🎓 Der RöntgenMeister**")
+                predictions = models["RöntgenMeister"](image)
+                has_predictions = False
+                for pred in predictions:
+                    if pred['score'] >= conf_threshold:
+                        has_predictions = True
+                        score_class = get_score_class(pred['score'])
                         st.markdown(f"""
-                            <div class="result-box" style="color: #1a1a1a;">
-                                Knochenbruch: <strong style="color: #0066cc">{max_fracture_score:.1%}</strong><br>
-                                Kein Knochenbruch: <strong style="color: #ffa500">{no_fracture_prob:.1%}</strong>
+                            <div class='result-box'>
+                                <span class='{score_class}' style='font-weight: 500;'>
+                                    {pred['score']:.1%}
+                                </span> - {translate_label(pred['label'])}
                             </div>
                         """, unsafe_allow_html=True)
-                
-                with col2:
-                    predictions = models["KnochenAuge"](image)
-                    # Debug: Afficher toutes les prédictions avant filtrage
-                    st.write("Debug - Toutes les prédictions:")
-                    for p in predictions:
-                        st.write(f"Label: {p['label']}, Score: {p['score']}")
-                    
-                    filtered_preds = [p for p in predictions if p['score'] >= conf_threshold 
-                                    and 'fracture' in p['label'].lower()]
-                    
-                    # Debug: Afficher les prédictions filtrées
-                    st.write("Debug - Prédictions filtrées:")
-                    for p in filtered_preds:
-                        st.write(f"Label: {p['label']}, Score: {p['score']}, Box: {p['box']}")
-                    
-                    if filtered_preds:
-                        st.write("#### 🎯 Fraktur Lokalisation")
-                        result_image = draw_boxes(image, filtered_preds)
-                        st.image(result_image, use_container_width=True)
-                    else:
-                        st.write("#### 🖼️ Röntgenbild")
-                        st.image(image, use_container_width=True)
+                if not has_predictions:
+                    st.info("Keine ausreichend sicheren Vorhersagen.")
+        else:
+            st.info("Bitte laden Sie ein Röntgenbild hoch (JPEG, PNG)")
+
+    # Script pour la synchronisation du thème
+    st.markdown("""
+        <script>
+            function updateTheme(isDark) {
+                document.documentElement.setAttribute('data-theme', isDark ? 'dark' : 'light');
+            }
+            
+            window.addEventListener('message', function(e) {
+                if (e.data.type === 'theme-change') {
+                    updateTheme(e.data.theme === 'dark');
+                }
+            });
+            
+            updateTheme(window.matchMedia('(prefers-color-scheme: dark)').matches);
+        </script>
+    """, unsafe_allow_html=True)
 
 if __name__ == "__main__":
     main()