Update src/ui_components_original.py

src/ui_components_original.py

@@ -9,6 +9,8 @@ from datetime import datetime
 from PIL import Image
 import html
 from typing import Optional, Dict, Any
+import numpy as np
+import cv2
 
 # ---- Safe imports for local vs package execution ----
 try:
@@ -456,46 +458,57 @@ button.gr-button:hover, button.gr-button-primary:hover {
 }
 
 .status-warning {
-    background: linear-gradient(135deg, #FFFAF0 0%, #FEEBC8 100%) !important;
-    border: 2px solid #DD6B20 !important;
-    color: #9C4221 !important;
+    background: linear-gradient(135deg, #FFFBEB 0%, #FEF3C7 100%) !important;
+    border: 2px solid #F59E0B !important;
+    color: #92400E !important;
     padding: 20px 24px !important;
     border-radius: 16px !important;
     font-weight: 600 !important;
     margin: 16px 0 !important;
-    box-shadow: 0 8px 24px rgba(221, 107, 32, 0.2) !important;
+    box-shadow: 0 8px 24px rgba(245, 158, 11, 0.2) !important;
     backdrop-filter: blur(10px) !important;
 }
 
-/* Image gallery styling */
+/* Image Gallery */
 .image-gallery {
-    display: grid;
-    grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
-    gap: 20px;
-    margin: 20px 0;
+    display: grid !important;
+    grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)) !important;
+    gap: 20px !important;
+    margin: 20px 0 !important;
 }
-.image-item { background: #f8f9fa; border-radius: 12px; padding: 15px; box-shadow: 0 4px 12px rgba(0,0,0,0.1); text-align: center; }
-.image-item img { max-width: 100%; height: auto; border-radius: 8px; box-shadow: 0 2px 8px rgba(0,0,0,0.15); }
-.image-item h4 { margin: 15px 0 5px 0; color: #2d3748; font-weight: 600; }
-.image-item p { margin: 0; color: #666; font-size: 0.9em; }
-
-/* Analyze button */
-#analyze-btn {
-    background: linear-gradient(135deg, #1B5CF3 0%, #1E3A8A 100%) !important;
-    color: #FFFFFF !important;
-    border: none !important;
-    border-radius: 8px !important;
+
+.image-item {
+    background: white !important;
+    border-radius: 16px !important;
+    padding: 20px !important;
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1) !important;
+    transition: transform 0.3s ease !important;
+}
+
+.image-item:hover {
+    transform: translateY(-5px) !important;
+    box-shadow: 0 16px 48px rgba(0, 0, 0, 0.15) !important;
+}
+
+.image-item img {
+    width: 100% !important;
+    height: auto !important;
+    border-radius: 12px !important;
+    margin-bottom: 12px !important;
+}
+
+.image-item h4 {
+    color: #2D3748 !important;
+    margin: 0 0 8px 0 !important;
+    font-size: 1.2rem !important;
     font-weight: 700 !important;
-    padding: 14px 28px !important;
-    font-size: 1.1rem !important;
-    letter-spacing: 0.5px !important;
-    text-align: center !important;
-    transition: all 0.2s ease-in-out !important;
 }
-#analyze-btn:hover {
-    background: linear-gradient(135deg, #174ea6 0%, #123b82 100%) !important;
-    box-shadow: 0 4px 14px rgba(27, 95, 193, 0.4) !important;
-    transform: translateY(-2px) !important;
+
+.image-item p {
+    color: #4A5568 !important;
+    margin: 0 !important;
+    font-size: 0.95rem !important;
+    line-height: 1.5 !important;
 }
 
 /* Responsive */
@@ -675,13 +688,7 @@ button.gr-button:hover, button.gr-button-primary:hover {
                                 with gr.Column(scale=1):
                                     gr.HTML("<h3>📸 Wound Image</h3>")
                                     wound_image = gr.Image(label="Upload Wound Image", type="filepath")
-                                    # Optional manual segmentation mask provided by the clinician. This allows clinicians
-                                    # to manually mark the wound boundary after the automatic segmentation has run.
-                                    manual_mask_input = gr.Image(
-                                        label="Manual Segmentation Mask (optional)",
-                                        type="filepath",
-                                        interactive=True,
-                                    )
+                                    
                                     # Slider to adjust the automatic segmentation mask. Positive values dilate
                                     # (expand) the mask, negative values erode (shrink) it. The value represents
                                     # roughly percentage change where each 5 units corresponds to one iteration.
@@ -693,6 +700,7 @@ button.gr-button:hover, button.gr-button-primary:hover {
                                         label="Segmentation Adjustment",
                                         info="Adjust the automatic segmentation (negative shrinks, positive expands)"
                                     )
+                                    
                                     gr.HTML("<h3>📝 Medical History</h3>")
                                     previous_treatment = gr.Textbox(label="Previous Treatment", lines=3)
                                     medical_history = gr.Textbox(label="Medical History", lines=3)
@@ -700,7 +708,43 @@ button.gr-button:hover, button.gr-button-primary:hover {
                                     allergies = gr.Textbox(label="Known Allergies", lines=2)
                                     additional_notes = gr.Textbox(label="Additional Notes", lines=3)
 
-                            analyze_btn = gr.Button("🔬 Analyze Wound", variant="primary", elem_id="analyze-btn")
+                            # Initial analysis button
+                            analyze_btn = gr.Button("🔬 Preview Segmentation", variant="primary", elem_id="analyze-btn")
+                            
+                            # Segmentation preview section (initially hidden)
+                            with gr.Group(visible=False) as segmentation_preview_group:
+                                gr.HTML("<h3>🎯 Segmentation Preview</h3>")
+                                segmentation_preview = gr.Image(label="Automatic Segmentation", interactive=False)
+                                
+                                with gr.Row():
+                                    accept_segmentation_btn = gr.Button("✅ Accept & Generate Full Report", variant="primary")
+                                    manual_edit_btn = gr.Button("✏️ Manual Edit", variant="secondary")
+                                
+                                # Manual editing section (initially hidden)
+                                with gr.Group(visible=False) as manual_edit_group:
+                                    gr.HTML("""
+                                    <div style="background: #e6f3ff; padding: 15px; border-radius: 8px; margin: 10px 0;">
+                                        <h4 style="margin: 0 0 10px 0; color: #1a365d;">📝 Manual Segmentation Instructions</h4>
+                                        <p style="margin: 0; color: #2c5282;">
+                                            Use the drawing tool below to manually mark the wound area. 
+                                            Select the pen tool and draw over the wound region to create your mask.
+                                        </p>
+                                    </div>
+                                    """)
+                                    
+                                    # Manual mask input using ImageMask component
+                                    manual_mask_input = gr.ImageMask(
+                                        sources=["upload"],
+                                        layers=False,
+                                        transforms=[],
+                                        format="png",
+                                        label="Manual Segmentation - Draw on the image to mark wound area",
+                                        show_label=True,
+                                        interactive=True
+                                    )
+                                    
+                                    process_manual_btn = gr.Button("🔬 Generate Report with Manual Mask", variant="primary")
+
                             analysis_output = gr.HTML("")
 
                         # ------------------- PATIENT HISTORY -------------------
@@ -792,213 +836,436 @@ button.gr-button:hover, button.gr-button-primary:hover {
                 return {
                     auth_panel: gr.update(visible=True),
                     practitioner_panel: gr.update(visible=False),
-                    organization_panel: gr.update(visible=False)
+                    organization_panel: gr.update(visible=False),
+                    login_status: "<div class='status-warning'>Please sign in.</div>",
+                    segmentation_preview_group: gr.update(visible=False),
+                    manual_edit_group: gr.update(visible=False),
+                    analysis_output: ""
                 }
 
-            def on_patient_mode_change(mode):
+            def toggle_patient_mode(mode):
                 return {
-                    new_patient_group: gr.update(visible=(mode == "New patient")),
-                    existing_patient_dd: gr.update(interactive=(mode == "Existing patient"))
+                    existing_patient_dd: gr.update(visible=(mode == "Existing patient")),
+                    new_patient_group: gr.update(visible=(mode == "New patient"))
                 }
 
-            def load_history():
+            def process_image_for_segmentation(
+                mode, existing_label, np_name, np_age, np_gender,
+                w_loc, w_dur, pain, moist, infect, diabetic,
+                prev_tx, med_hist, meds, alls, notes, img_path, seg_adjust
+            ):
+                """Process image and show segmentation preview"""
+                if not img_path:
+                    return {
+                        segmentation_preview_group: gr.update(visible=False),
+                        analysis_output: "<div class='status-error'>❌ Please upload a wound image.</div>"
+                    }
+
                 try:
-                    uid = int(self.current_user.get("id", 0) or 0)
+                    # Run initial analysis to get segmentation
+                    user_id = int(self.current_user.get("id", 0) or 0)
+                    if not user_id:
+                        return {
+                            segmentation_preview_group: gr.update(visible=False),
+                            analysis_output: "<div class='status-error'>❌ Please login first.</div>"
+                        }
+
+                    # Prepare questionnaire data for AI
+                    if mode == "Existing patient":
+                        pid = _label_to_id(existing_label)
+                        if not pid:
+                            return {
+                                segmentation_preview_group: gr.update(visible=False),
+                                analysis_output: "<div class='status-warning'>⚠️ Select an existing patient.</div>"
+                            }
+                        # Fetch patient data
+                        row = self.database_manager.execute_query_one(
+                            "SELECT id, name, age, gender FROM patients WHERE id=%s LIMIT 1", (pid,)
+                        )
+                        pcore = row or {}
+                        patient_name_v = pcore.get("name")
+                        patient_age_v = pcore.get("age")
+                        patient_gender_v = pcore.get("gender")
+                    else:
+                        patient_name_v = np_name
+                        patient_age_v = np_age
+                        patient_gender_v = np_gender
+
+                    q_for_ai = {
+                        'age': patient_age_v,
+                        'diabetic': 'Yes' if diabetic != 'Non-diabetic' else 'No',
+                        'allergies': alls,
+                        'date_of_injury': 'Unknown',
+                        'professional_care': 'Yes',
+                        'oozing_bleeding': 'Minor Oozing' if infect != 'None' else 'None',
+                        'infection': 'Yes' if infect != 'None' else 'No',
+                        'moisture': moist,
+                        'patient_name': patient_name_v,
+                        'patient_gender': patient_gender_v,
+                        'wound_location': w_loc,
+                        'wound_duration': w_dur,
+                        'pain_level': pain,
+                        'previous_treatment': prev_tx,
+                        'medical_history': med_hist,
+                        'medications': meds,
+                        'additional_notes': notes
+                    }
+
+                    # Run visual analysis only to get segmentation
+                    image_pil = Image.open(img_path)
+                    visual_results = self.wound_analyzer.perform_visual_analysis(image_pil)
+                    
+                    if not visual_results:
+                        return {
+                            segmentation_preview_group: gr.update(visible=False),
+                            analysis_output: "<div class='status-error'>❌ Failed to analyze image.</div>"
+                        }
+
+                    # Get segmentation image path
+                    seg_path = visual_results.get("segmentation_image_path")
+                    if not seg_path or not os.path.exists(seg_path):
+                        return {
+                            segmentation_preview_group: gr.update(visible=False),
+                            analysis_output: "<div class='status-error'>❌ Segmentation failed.</div>"
+                        }
+
+                    return {
+                        segmentation_preview_group: gr.update(visible=True),
+                        segmentation_preview: seg_path,
+                        manual_edit_group: gr.update(visible=False),
+                        analysis_output: "<div class='status-success'>✅ Segmentation preview ready. Review and choose to accept or manually edit.</div>"
+                    }
+
+                except Exception as e:
+                    logging.error(f"Segmentation preview error: {e}")
+                    return {
+                        segmentation_preview_group: gr.update(visible=False),
+                        analysis_output: f"<div class='status-error'>❌ Error: {html.escape(str(e))}</div>"
+                    }
+
+            def show_manual_edit_interface(img_path):
+                """Show manual editing interface with the original image"""
+                if not img_path or not os.path.exists(img_path):
+                    return {
+                        manual_edit_group: gr.update(visible=False),
+                        analysis_output: "<div class='status-error'>❌ Original image not available for editing.</div>"
+                    }
+                
+                return {
+                    manual_edit_group: gr.update(visible=True),
+                    manual_mask_input: img_path,  # Load the original image for manual editing
+                    analysis_output: "<div class='status-warning'>⚠️ Use the drawing tool to manually mark the wound area, then click 'Generate Report with Manual Mask'.</div>"
+                }
+
+            def process_manual_mask(mask_data):
+                """Process the manual mask from ImageMask component"""
+                if not mask_data:
+                    return "<div class='status-error'>❌ No manual mask provided.</div>"
+                
+                try:
+                    # Extract the mask from the ImageMask component
+                    # The mask_data contains both the background image and the drawn mask
+                    if isinstance(mask_data, dict) and "layers" in mask_data:
+                        # Get the alpha channel from the first layer (the drawn mask)
+                        alpha_channel = mask_data["layers"][0][:, :, 3]
+                        # Convert to binary mask
+                        mask = np.where(alpha_channel == 0, 0, 255).astype(np.uint8)
+                        
+                        # Save the mask temporarily
+                        import tempfile
+                        with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp:
+                            cv2.imwrite(tmp.name, mask)
+                            manual_mask_path = tmp.name
+                        
+                        return manual_mask_path
+                    else:
+                        return None
+                        
+                except Exception as e:
+                    logging.error(f"Manual mask processing error: {e}")
+                    return None
+
+            def run_full_analysis_with_manual_mask(
+                mode, existing_label, np_name, np_age, np_gender,
+                w_loc, w_dur, pain, moist, infect, diabetic,
+                prev_tx, med_hist, meds, alls, notes, img_path, seg_adjust, mask_data
+            ):
+                """Run full analysis with manual mask"""
+                try:
+                    # Process manual mask
+                    manual_mask_path = process_manual_mask(mask_data)
+                    
+                    # Run the full analysis with manual mask
+                    result_html = standalone_run_analysis(
+                        self, self.current_user, self.database_manager, self.wound_analyzer,
+                        mode, existing_label, np_name, np_age, np_gender,
+                        w_loc, w_dur, pain, moist, infect, diabetic,
+                        prev_tx, med_hist, meds, alls, notes, img_path,
+                        seg_adjust, manual_mask_path
+                    )
+                    
+                    # Clean up temporary file
+                    if manual_mask_path and os.path.exists(manual_mask_path):
+                        try:
+                            os.unlink(manual_mask_path)
+                        except:
+                            pass
+                    
+                    return {
+                        analysis_output: result_html,
+                        segmentation_preview_group: gr.update(visible=False),
+                        manual_edit_group: gr.update(visible=False)
+                    }
+                    
+                except Exception as e:
+                    logging.error(f"Manual analysis error: {e}")
+                    return {
+                        analysis_output: f"<div class='status-error'>❌ Analysis failed: {html.escape(str(e))}</div>"
+                    }
+
+            def run_full_analysis_accept_segmentation(
+                mode, existing_label, np_name, np_age, np_gender,
+                w_loc, w_dur, pain, moist, infect, diabetic,
+                prev_tx, med_hist, meds, alls, notes, img_path, seg_adjust
+            ):
+                """Run full analysis accepting the automatic segmentation"""
+                try:
+                    result_html = standalone_run_analysis(
+                        self, self.current_user, self.database_manager, self.wound_analyzer,
+                        mode, existing_label, np_name, np_age, np_gender,
+                        w_loc, w_dur, pain, moist, infect, diabetic,
+                        prev_tx, med_hist, meds, alls, notes, img_path,
+                        seg_adjust, None  # No manual mask
+                    )
+                    
+                    return {
+                        analysis_output: result_html,
+                        segmentation_preview_group: gr.update(visible=False),
+                        manual_edit_group: gr.update(visible=False)
+                    }
+                    
+                except Exception as e:
+                    logging.error(f"Analysis error: {e}")
+                    return {
+                        analysis_output: f"<div class='status-error'>❌ Analysis failed: {html.escape(str(e))}</div>"
+                    }
+
+            def load_patient_history():
+                try:
+                    uid = int(self.current_user.get("id", 0))
                     if not uid:
                         return "<div class='status-error'>❌ Please login first.</div>"
-                    rows = self.patient_history_manager.get_user_patient_history(uid) or []
-                    # inline images
-                    out = []
-                    for r in rows or []:
-                        r = dict(r)
-                        if r.get("image_url"):
-                            r["image_url"] = _to_data_url_if_local(r["image_url"])
-                        out.append(r)
-                    return self.patient_history_manager.format_history_for_display(out)
+                    
+                    history_data = self.patient_history_manager.get_patient_history(uid)
+                    if not history_data:
+                        return "<div class='status-warning'>⚠️ No patient history found.</div>"
+                    
+                    html_report = self.report_generator.generate_history_report(history_data)
+                    return html_report
                 except Exception as e:
-                    logging.error(f"load_history error: {e}")
+                    logging.error(f"History load error: {e}")
                     return f"<div class='status-error'>❌ Error: {html.escape(str(e))}</div>"
 
-            def do_search(name):
+            def search_patient_by_name(name):
                 try:
-                    uid = int(self.current_user.get("id", 0) or 0)
+                    uid = int(self.current_user.get("id", 0))
                     if not uid:
                         return "<div class='status-error'>❌ Please login first.</div>"
-                    if not (name or "").strip():
-                        return "<div class='status-warning'>⚠️ Enter a name to search.</div>"
-                    rows = self.patient_history_manager.search_patient_by_name(uid, name.strip()) or []
-                    out = []
-                    for r in rows or []:
-                        r = dict(r)
-                        if r.get("image_url"):
-                            r["image_url"] = _to_data_url_if_local(r["image_url"])
-                        out.append(r)
-                    return self.patient_history_manager.format_patient_data_for_display(out)
+                    
+                    if not name or not name.strip():
+                        return "<div class='status-warning'>⚠️ Enter a patient name to search.</div>"
+                    
+                    results = self.patient_history_manager.search_patients_by_name(uid, name.strip())
+                    if not results:
+                        return f"<div class='status-warning'>⚠️ No patients found matching '{html.escape(name)}'.</div>"
+                    
+                    html_report = self.report_generator.generate_search_results(results, name)
+                    return html_report
                 except Exception as e:
-                    logging.error(f"search error: {e}")
+                    logging.error(f"Patient search error: {e}")
                     return f"<div class='status-error'>❌ Error: {html.escape(str(e))}</div>"
 
-            def view_details(existing_label):
+            def view_patient_details(selected_label):
                 try:
-                    uid = int(self.current_user.get("id", 0) or 0)
+                    uid = int(self.current_user.get("id", 0))
                     if not uid:
                         return "<div class='status-error'>❌ Please login first.</div>"
-                    pid = _label_to_id(existing_label)
+                    
+                    pid = _label_to_id(selected_label)
                     if not pid:
-                        return "<div class='status-warning'>⚠️ Select a patient.</div>"
-                    rows = self.patient_history_manager.get_wound_progression_by_id(uid, pid) or []
-                    out = []
-                    for r in rows or []:
-                        r = dict(r)
-                        if r.get("image_url"):
-                            r["image_url"] = _to_data_url_if_local(r["image_url"])
-                        out.append(r)
-                    return self.patient_history_manager.format_patient_progress_for_display(out)
+                        return "<div class='status-warning'>⚠️ Select a patient to view details.</div>"
+                    
+                    details = self.patient_history_manager.get_patient_details(uid, pid)
+                    if not details:
+                        return "<div class='status-warning'>⚠️ No details found for selected patient.</div>"
+                    
+                    html_report = self.report_generator.generate_patient_timeline(details)
+                    return html_report
                 except Exception as e:
-                    logging.error(f"view_details error: {e}")
+                    logging.error(f"Patient details error: {e}")
                     return f"<div class='status-error'>❌ Error: {html.escape(str(e))}</div>"
 
-            # ----------------------- wiring -----------------------
-            signup_role.change(
-                toggle_role_fields,
-                inputs=[signup_role],
-                outputs=[org_fields, prac_fields]
-            )
-
+            # ----------------------- Event bindings -----------------------
+            signup_role.change(toggle_role_fields, [signup_role], [org_fields, prac_fields])
+            
             signup_btn.click(
                 handle_signup,
-                inputs=[signup_username, signup_email, signup_password, signup_name, signup_role,
-                        org_name, phone, country_code, department, location, organization_dropdown],
-                outputs=[signup_status]
+                [signup_username, signup_email, signup_password, signup_name, signup_role,
+                 org_name, phone, country_code, department, location, organization_dropdown],
+                [signup_status]
             )
-
+            
             login_btn.click(
                 handle_login,
-                inputs=[login_username, login_password],
-                outputs=[login_status, auth_panel, practitioner_panel, organization_panel,
-                         user_info, existing_patient_dd, view_details_dd]
+                [login_username, login_password],
+                [login_status, auth_panel, practitioner_panel, organization_panel, user_info,
+                 existing_patient_dd, view_details_dd]
             )
-
-            logout_btn_prac.click(handle_logout, outputs=[auth_panel, practitioner_panel, organization_panel])
-            logout_btn_org.click(handle_logout, outputs=[auth_panel, practitioner_panel, organization_panel])
-
-            patient_mode.change(
-                on_patient_mode_change,
-                inputs=[patient_mode],
-                outputs=[new_patient_group, existing_patient_dd]
+            
+            logout_btn_prac.click(
+                handle_logout,
+                [],
+                [auth_panel, practitioner_panel, organization_panel, login_status,
+                 segmentation_preview_group, manual_edit_group, analysis_output]
             )
-
-            # --- IMPORTANT: call standalone GPU function via lambda to pass instance/ctx ---
+            
+            logout_btn_org.click(
+                handle_logout,
+                [],
+                [auth_panel, practitioner_panel, organization_panel, login_status,
+                 segmentation_preview_group, manual_edit_group, analysis_output]
+            )
+            
+            patient_mode.change(toggle_patient_mode, [patient_mode], [existing_patient_dd, new_patient_group])
+            
+            # Segmentation preview workflow
             analyze_btn.click(
-                fn=lambda mode, ex_lbl, np_n, np_a, np_g, wl, wd, p, m, i, d, pt, mh, med, al, nt,
-                                 img, manual_mask, seg_adj: \
-                    standalone_run_analysis(
-                        self, self.current_user, self.database_manager, self.wound_analyzer,
-                        mode, ex_lbl, np_n, np_a, np_g, wl, wd, p, m, i, d, pt, mh, med, al, nt,
-                        img, seg_adj, manual_mask
-                    ),
-                inputs=[
-                    patient_mode, existing_patient_dd,
-                    new_patient_name, new_patient_age, new_patient_gender,
-                    wound_location, wound_duration, pain_level, moisture_level, infection_signs, diabetic_status,
-                    previous_treatment, medical_history, medications, allergies, additional_notes,
-                    wound_image, manual_mask_input, seg_adjust_slider
-                ],
-                outputs=[analysis_output]
+                process_image_for_segmentation,
+                [patient_mode, existing_patient_dd, new_patient_name, new_patient_age, new_patient_gender,
+                 wound_location, wound_duration, pain_level, moisture_level, infection_signs, diabetic_status,
+                 previous_treatment, medical_history, medications, allergies, additional_notes, wound_image, seg_adjust_slider],
+                [segmentation_preview_group, segmentation_preview, manual_edit_group, analysis_output]
             )
-
-            history_btn.click(load_history, outputs=[patient_history_output])
-            search_patient_btn.click(do_search, inputs=[search_patient_name], outputs=[specific_patient_output])
-            view_details_btn.click(view_details, inputs=[view_details_dd], outputs=[view_details_output])
+            
+            # Accept segmentation and generate full report
+            accept_segmentation_btn.click(
+                run_full_analysis_accept_segmentation,
+                [patient_mode, existing_patient_dd, new_patient_name, new_patient_age, new_patient_gender,
+                 wound_location, wound_duration, pain_level, moisture_level, infection_signs, diabetic_status,
+                 previous_treatment, medical_history, medications, allergies, additional_notes, wound_image, seg_adjust_slider],
+                [analysis_output, segmentation_preview_group, manual_edit_group]
+            )
+            
+            # Show manual edit interface
+            manual_edit_btn.click(
+                show_manual_edit_interface,
+                [wound_image],
+                [manual_edit_group, manual_mask_input, analysis_output]
+            )
+            
+            # Process manual mask and generate report
+            process_manual_btn.click(
+                run_full_analysis_with_manual_mask,
+                [patient_mode, existing_patient_dd, new_patient_name, new_patient_age, new_patient_gender,
+                 wound_location, wound_duration, pain_level, moisture_level, infection_signs, diabetic_status,
+                 previous_treatment, medical_history, medications, allergies, additional_notes, wound_image, seg_adjust_slider, manual_mask_input],
+                [analysis_output, segmentation_preview_group, manual_edit_group]
+            )
+            
+            history_btn.click(load_patient_history, [], [patient_history_output])
+            search_patient_btn.click(search_patient_by_name, [search_patient_name], [specific_patient_output])
+            view_details_btn.click(view_patient_details, [view_details_dd], [view_details_output])
 
         return app
 
-    # ----------------------- formatting & risk logic -----------------------
-    def _format_comprehensive_analysis_results(self, analysis_result, image_url=None, questionnaire_data=None):
-        """Format comprehensive analysis results with all visualization images from AIProcessor."""
+    def _format_comprehensive_analysis_results(self, analysis_result, image_path, questionnaire_data):
+        """Format comprehensive analysis results with enhanced visual presentation"""
         try:
-            success = analysis_result.get('success', False)
-            if not success:
-                error_msg = analysis_result.get('error', 'Unknown error')
-                return f"<div class='status-error'>❌ Analysis failed: {error_msg}</div>"
-
-            visual_analysis = analysis_result.get('visual_analysis', {})
-            report = analysis_result.get('report', '')
-            saved_image_path = analysis_result.get('saved_image_path', '')
-
-            wound_type = visual_analysis.get('wound_type', 'Unknown')
-            # New AI insights
-            skin_tone_label = visual_analysis.get('skin_tone_label', 'Unknown')
-            ita_deg = visual_analysis.get('ita_degrees', None)
-            tissue_type = visual_analysis.get('tissue_type', 'Unknown')
-            length_cm = visual_analysis.get('length_cm', 0)
-            breadth_cm = visual_analysis.get('breadth_cm', 0)
-            area_cm2 = visual_analysis.get('surface_area_cm2', 0)
-            detection_confidence = visual_analysis.get('detection_confidence', 0)
-
-            detection_image_path = visual_analysis.get('detection_image_path', '')
-            segmentation_image_path = visual_analysis.get('segmentation_image_path', '')
-            original_image_path = visual_analysis.get('original_image_path', '')
-
-            original_image_base64 = None
-            detection_image_base64 = None
-            segmentation_image_base64 = None
-
-            if image_url and os.path.exists(image_url):
-                original_image_base64 = self.image_to_base64(image_url)
-            elif original_image_path and os.path.exists(original_image_path):
-                original_image_base64 = self.image_to_base64(original_image_path)
-            elif saved_image_path and os.path.exists(saved_image_path):
-                original_image_base64 = self.image_to_base64(saved_image_path)
-
-            if detection_image_path and os.path.exists(detection_image_path):
-                detection_image_base64 = self.image_to_base64(detection_image_path)
-
-            if segmentation_image_path and os.path.exists(segmentation_image_path):
-                segmentation_image_base64 = self.image_to_base64(segmentation_image_path)
-
+            visual_analysis = analysis_result.get("visual_analysis", {})
+            report = analysis_result.get("report", "")
+
+            # Extract key metrics
+            wound_type = visual_analysis.get("wound_type", "Unknown")
+            length_cm = visual_analysis.get("length_cm", 0)
+            breadth_cm = visual_analysis.get("breadth_cm", 0)
+            area_cm2 = visual_analysis.get("surface_area_cm2", 0)
+            skin_tone_label = visual_analysis.get("skin_tone_label", "Unknown")
+            ita_deg = visual_analysis.get("ita_degrees")
+            tissue_type = visual_analysis.get("tissue_type", "Unknown")
+
+            # Generate risk assessment
             risk_assessment = self._generate_risk_assessment(questionnaire_data)
-            risk_level = risk_assessment['risk_level']
-            risk_score = risk_assessment['risk_score']
-            risk_factors = risk_assessment['risk_factors']
-
-            risk_class = "low"
-            if risk_level.lower() == "moderate":
-                risk_class = "moderate"
-            elif risk_level.lower() in ["high", "very high"]:
-                risk_class = "high"
-
-            risk_factors_html = "<ul>" + "".join(f"<li>{factor}</li>" for factor in risk_factors) + "</ul>" if risk_factors else "<p>No specific risk factors identified.</p>"
-
-            image_gallery_html = ""
-            if original_image_base64 or detection_image_base64 or segmentation_image_base64:
-                image_gallery_html = '<div class="image-gallery">'
-                if original_image_base64:
-                    image_gallery_html += f'''
+            risk_level = risk_assessment.get("risk_level", "Unknown")
+            risk_score = risk_assessment.get("risk_score", 0)
+            risk_factors = risk_assessment.get("risk_factors", [])
+            risk_class = risk_level.lower().replace(" ", "_")
+
+            # Format risk factors
+            if risk_factors:
+                risk_factors_html = "<ul style='margin: 10px 0; padding-left: 20px;'>"
+                for factor in risk_factors:
+                    risk_factors_html += f"<li style='margin: 5px 0; color: #2d3748;'>{html.escape(str(factor))}</li>"
+                risk_factors_html += "</ul>"
+            else:
+                risk_factors_html = "<p style='color: #4a5568; font-style: italic;'>No specific risk factors identified.</p>"
+
+            # Create image gallery
+            image_gallery_html = "<div class='image-gallery'>"
+            
+            # Original image
+            if image_path and os.path.exists(image_path):
+                img_b64 = self.image_to_base64(image_path)
+                if img_b64:
+                    image_gallery_html += f"""
                     <div class="image-item">
-                        <img src="{original_image_base64}" alt="Original Wound Image">
-                        <h4>📸 Original Wound Image</h4>
-                        <p>Uploaded image for analysis</p>
+                        <img src="{img_b64}" alt="Original Wound Image">
+                        <h4>📸 Original Image</h4>
+                        <p>Uploaded wound photograph for analysis</p>
                     </div>
-                    '''
-                if detection_image_base64:
-                    image_gallery_html += f'''
+                    """
+
+            # Detection visualization
+            detection_path = visual_analysis.get("detection_image_path")
+            if detection_path and os.path.exists(detection_path):
+                img_b64 = self.image_to_base64(detection_path)
+                if img_b64:
+                    image_gallery_html += f"""
                     <div class="image-item">
-                        <img src="{detection_image_base64}" alt="Wound Detection">
+                        <img src="{img_b64}" alt="Wound Detection">
                         <h4>🎯 Wound Detection</h4>
-                        <p>AI-detected wound boundaries</p>
+                        <p>AI-powered wound boundary detection with confidence: {visual_analysis.get('detection_confidence', 0):.1%}</p>
+                    </div>
+                    """
+
+            # Segmentation visualization
+            seg_path = visual_analysis.get("segmentation_image_path")
+            if seg_path and os.path.exists(seg_path):
+                img_b64 = self.image_to_base64(seg_path)
+                if img_b64:
+                    image_gallery_html += f"""
+                    <div class="image-item">
+                        <img src="{img_b64}" alt="Wound Segmentation">
+                        <h4>🔍 Wound Segmentation</h4>
+                        <p>Precise wound boundary identification and tissue analysis</p>
                     </div>
-                    '''
-                if segmentation_image_base64:
-                    image_gallery_html += f'''
+                    """
+
+            # Annotated measurements
+            annotated_path = visual_analysis.get("segmentation_annotated_path")
+            if annotated_path and os.path.exists(annotated_path):
+                img_b64 = self.image_to_base64(annotated_path)
+                if img_b64:
+                    image_gallery_html += f"""
                     <div class="image-item">
-                        <img src="{segmentation_image_base64}" alt="Wound Segmentation">
-                        <h4>📏 Wound Segmentation</h4>
-                        <p>Detailed wound area measurement and analysis</p>
+                        <img src="{img_b64}" alt="Annotated Measurements">
+                        <h4>📏 Measurements</h4>
+                        <p>Calibrated dimensional analysis with length and width indicators</p>
                     </div>
-                    '''
-                image_gallery_html += '</div>'
+                    """
+
+            image_gallery_html += "</div>"
 
+            # Convert report markdown to HTML
             report_html = self.markdown_to_html(report) if report else ""
 
             html_output = f"""