# src/ui_components_original.py
import gradio as gr
import os
import re
import logging
import base64
from datetime import datetime
from PIL import Image
import html
from typing import Optional, Dict, Any
import numpy as np
import cv2
import tempfile
# ---- Safe imports for local vs package execution ----
try:
from .patient_history import PatientHistoryManager, ReportGenerator
except Exception:
from patient_history import PatientHistoryManager, ReportGenerator # local dev
# ---- Optional spaces.GPU fallback (local dev) ----
try:
import spaces
def _SPACES_GPU(*args, **kwargs):
return spaces.GPU(*args, **kwargs)
except Exception:
def _SPACES_GPU(*_args, **_kwargs):
def deco(f):
return f
return deco
logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
def pil_to_base64(pil_image: Image.Image) -> Optional[str]:
"""Convert PIL Image to base64 data URL"""
import io
if pil_image is None:
return None
try:
if pil_image.mode != 'RGB':
pil_image = pil_image.convert('RGB')
buffer = io.BytesIO()
pil_image.save(buffer, format='PNG')
img_str = base64.b64encode(buffer.getvalue()).decode()
return f"data:image/png;base64,{img_str}"
except Exception as e:
logging.error(f"Error converting PIL image to base64: {e}")
return None
# =============================================================================
# GPU-DECORATED FUNCTION (STANDALONE)
# =============================================================================
@_SPACES_GPU(enable_queue=True)
def standalone_run_analysis(
# instance/context
ui_instance,
current_user: Dict[str, Any],
database_manager,
wound_analyzer,
# UI inputs
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=0.0, manual_mask=None
):
"""Runs in the ZeroGPU worker; returns HTML for the UI."""
def _label_to_id(label: str):
if not label:
return None
try:
return int(str(label).split("•", 1)[0].strip())
except Exception:
return None
def _fetch_patient_core(pid: int):
row = database_manager.execute_query_one(
"SELECT id, name, age, gender FROM patients WHERE id=%s LIMIT 1", (pid,)
)
return row or {}
def _response_to_patient_id(resp_ref):
if isinstance(resp_ref, dict):
pid = resp_ref.get("patient_id")
if pid is not None:
try:
return int(pid)
except Exception:
pass
resp_id = resp_ref.get("response_id") or resp_ref.get("id")
else:
resp_id = resp_ref
if not resp_id:
return None
row = database_manager.execute_query_one(
"SELECT patient_id FROM questionnaire_responses WHERE id=%s LIMIT 1",
(int(resp_id),)
)
try:
return int(row["patient_id"]) if row and "patient_id" in row else None
except Exception:
return None
try:
if not img_path:
return "❌ Please upload a wound image.
"
user_id = int(current_user.get("id", 0) or 0)
if not user_id:
return "❌ Please login first.
"
# Resolve patient
if mode == "Existing patient":
pid = _label_to_id(existing_label)
if not pid:
return "⚠️ Select an existing patient.
"
pcore = _fetch_patient_core(pid)
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
# Save questionnaire
q_payload = {
'user_id': user_id,
'patient_name': patient_name_v,
'patient_age': patient_age_v,
'patient_gender': patient_gender_v,
'wound_location': w_loc,
'wound_duration': w_dur,
'pain_level': pain,
'moisture_level': moist,
'infection_signs': infect,
'diabetic_status': diabetic,
'previous_treatment': prev_tx,
'medical_history': med_hist,
'medications': meds,
'allergies': alls,
'additional_notes': notes
}
response_id = database_manager.save_questionnaire(q_payload)
# normalize
response_id = (response_id.get("response_id") if isinstance(response_id, dict) else response_id)
try:
response_id = int(response_id)
except Exception:
return "❌ Could not resolve response ID.
"
patient_id = _response_to_patient_id(response_id)
if not patient_id:
return "❌ Could not resolve patient ID.
"
# Save wound image binary
try:
with Image.open(img_path) as pil:
pil = pil.convert("RGB")
img_meta = database_manager.save_wound_image(patient_id, pil)
image_db_id = img_meta["id"] if img_meta else None
except Exception as e:
logging.error(f"save_wound_image error: {e}")
image_db_id = None
# Prepare AI inputs
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 AI with optional segmentation adjustment and manual mask
analysis_result = wound_analyzer.analyze_wound(
img_path,
q_for_ai,
seg_adjust=seg_adjust or 0.0,
manual_mask_path=manual_mask if manual_mask else None
)
if not analysis_result or not analysis_result.get("success"):
err = (analysis_result or {}).get("error", "Unknown analysis error")
return f"❌ AI Analysis failed: {html.escape(str(err))}
"
# Persist AI analysis
try:
database_manager.save_analysis(response_id, image_db_id, analysis_result)
except Exception as e:
logging.error(f"save_analysis error: {e}")
# Format via instance method to keep UI consistent
return ui_instance._format_comprehensive_analysis_results(
analysis_result, img_path, q_for_ai
)
except Exception as e:
logging.exception("standalone_run_analysis exception")
return f"❌ System error in GPU worker: {html.escape(str(e))}
"
# =============================================================================
# UI CLASS DEFINITION
# =============================================================================
class UIComponents:
def __init__(self, auth_manager, database_manager, wound_analyzer):
self.auth_manager = auth_manager
self.database_manager = database_manager
self.wound_analyzer = wound_analyzer
self.current_user = {}
self.patient_history_manager = PatientHistoryManager(database_manager)
self.report_generator = ReportGenerator()
# Ensure uploads directory exists
if not os.path.exists("uploads"):
os.makedirs("uploads", exist_ok=True)
def image_to_base64(self, image_path):
"""Convert image to base64 data URL for embedding in HTML"""
if not image_path or not os.path.exists(image_path):
return None
try:
with open(image_path, "rb") as image_file:
encoded_string = base64.b64encode(image_file.read()).decode()
image_ext = os.path.splitext(image_path)[1].lower()
if image_ext in [".jpg", ".jpeg"]:
mime_type = "image/jpeg"
elif image_ext == ".png":
mime_type = "image/png"
elif image_ext == ".gif":
mime_type = "image/gif"
else:
mime_type = "image/png"
return f"data:{mime_type};base64,{encoded_string}"
except Exception as e:
logging.error(f"Error converting image to base64: {e}")
return None
def markdown_to_html(self, markdown_text):
"""Convert markdown text to proper HTML format with enhanced support"""
if not markdown_text:
return ""
# Escape HTML entities
html_text = html.escape(markdown_text)
# Headers
html_text = re.sub(r"^### (.*?)$", r"\1 ", html_text, flags=re.MULTILINE)
html_text = re.sub(r"^## (.*?)$", r"\1 ", html_text, flags=re.MULTILINE)
html_text = re.sub(r"^# (.*?)$", r"\1 ", html_text, flags=re.MULTILINE)
# Bold, italic
html_text = re.sub(r"\*\*(.*?)\*\*", r"\1 ", html_text)
html_text = re.sub(r"\*(.*?)\*", r"\1 ", html_text)
# Code blocks
html_text = re.sub(r"```(.*?)```", r"\1\1", html_text)
# Blockquotes
html_text = re.sub(r"^> (.*?)$", r"\1 ", html_text, flags=re.MULTILINE)
# Links
html_text = re.sub(r"\[(.*?)\]\((.*?)\)", r"\1 ", html_text)
# Horizontal rules
html_text = re.sub(r"^\s*[-*_]{3,}\s*$", r"
lines = html_text.split("\n")
in_list = False
result_lines = []
for line in lines:
stripped = line.strip()
if stripped.startswith("- "):
if not in_list:
result_lines.append("")
in_list = True
result_lines.append(f"{stripped[2:]} ")
else:
if in_list:
result_lines.append(" ")
in_list = False
if stripped:
result_lines.append(f"{stripped}
")
else:
result_lines.append(" ")
return "\n".join(result_lines)
def get_organizations_dropdown(self):
"""Get list of organizations for dropdown"""
try:
organizations = self.database_manager.get_organizations()
return [f"{org['org_name']} - {org['location']}" for org in organizations]
except Exception as e:
logging.error(f"Error getting organizations: {e}")
return ["Default Hospital - Location"]
def get_custom_css(self):
return """
/* =================== SMARTHEAL-INSPIRED CSS =================== */
/* Global Styling */
body, html {
margin: 0 !important;
padding: 0 !important;
font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', sans-serif !important;
background: linear-gradient(135deg, #f8fafc 0%, #e2e8f0 100%) !important;
color: #1e293b !important;
line-height: 1.6 !important;
}
/* SmartHeal-inspired Header */
.medical-header {
background: linear-gradient(135deg, #6366f1 0%, #8b5cf6 100%) !important;
color: white !important;
padding: 40px !important;
border-radius: 0 0 24px 24px !important;
display: flex !important;
align-items: center !important;
justify-content: center !important;
margin-bottom: 0 !important;
box-shadow: 0 20px 60px rgba(99, 102, 241, 0.3) !important;
border: none !important;
position: relative !important;
overflow: hidden !important;
}
.medical-header::before {
content: '' !important;
position: absolute !important;
top: 0 !important;
left: 0 !important;
right: 0 !important;
bottom: 0 !important;
background: url('data:image/svg+xml,
⚠️ IMPORTANT DISCLAIMER
This system is for testing/education and not a substitute for clinical judgment.
""")
# Panels: auth vs practitioner vs organization
with gr.Row():
with gr.Column(visible=True) as auth_panel:
with gr.Tabs():
with gr.Tab("🔐 Professional Login"):
login_username = gr.Textbox(label="👤 Username")
login_password = gr.Textbox(label="🔒 Password", type="password")
login_btn = gr.Button("🚀 Sign In", variant="primary")
login_status = gr.HTML("Please sign in.
")
with gr.Tab("📝 New Registration"):
signup_username = gr.Textbox(label="👤 Username")
signup_email = gr.Textbox(label="📧 Email")
signup_password = gr.Textbox(label="🔒 Password", type="password")
signup_name = gr.Textbox(label="👨⚕️ Full Name")
signup_role = gr.Radio(["practitioner", "organization"], label="Account Type", value="practitioner")
with gr.Group(visible=False) as org_fields:
org_name = gr.Textbox(label="Organization Name")
phone = gr.Textbox(label="Phone")
country_code = gr.Textbox(label="Country Code")
department = gr.Textbox(label="Department")
location = gr.Textbox(label="Location")
with gr.Group(visible=True) as prac_fields:
organization_dropdown = gr.Dropdown(choices=self.get_organizations_dropdown(), label="Select Organization")
signup_btn = gr.Button("✨ Create Account", variant="primary")
signup_status = gr.HTML()
with gr.Column(visible=False) as practitioner_panel:
user_info = gr.HTML("")
logout_btn_prac = gr.Button("🚪 Logout", variant="secondary")
with gr.Tabs():
# ------------------- WOUND ANALYSIS -------------------
with gr.Tab("🔬 Wound Analysis"):
with gr.Row():
with gr.Column(scale=1):
gr.HTML("📋 Patient Selection ")
patient_mode = gr.Radio(
["Existing patient", "New patient"],
label="Patient mode",
value="Existing patient"
)
existing_patient_dd = gr.Dropdown(
choices=[],
label="Select existing patient (ID • Name)",
interactive=True
)
with gr.Group(visible=False) as new_patient_group:
new_patient_name = gr.Textbox(label="Patient Name")
new_patient_age = gr.Number(label="Age", value=30, minimum=0, maximum=120)
new_patient_gender = gr.Dropdown(choices=["Male", "Female", "Other"], value="Male", label="Gender")
gr.HTML("🩹 Wound Information ")
wound_location = gr.Textbox(label="Wound Location", placeholder="e.g., Left ankle")
wound_duration = gr.Textbox(label="Wound Duration", placeholder="e.g., 2 weeks")
pain_level = gr.Slider(0, 10, value=5, step=1, label="Pain Level (0-10)")
gr.HTML("⚕️ Clinical Assessment ")
moisture_level = gr.Dropdown(["Dry", "Moist", "Wet", "Saturated"], value="Moist", label="Moisture Level")
infection_signs = gr.Dropdown(["None", "Mild", "Moderate", "Severe"], value="None", label="Signs of Infection")
diabetic_status = gr.Dropdown(["Non-diabetic", "Type 1", "Type 2", "Gestational"], value="Non-diabetic", label="Diabetic Status")
with gr.Column(scale=1):
gr.HTML("📸 Wound Image ")
wound_image = gr.Image(label="Upload Wound Image", type="filepath")
# 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.
seg_adjust_slider = gr.Slider(
minimum=-20,
maximum=20,
value=0,
step=1,
label="Segmentation Adjustment",
info="Adjust the automatic segmentation (negative shrinks, positive expands)"
)
gr.HTML("📝 Medical History ")
previous_treatment = gr.Textbox(label="Previous Treatment", lines=3)
medical_history = gr.Textbox(label="Medical History", lines=3)
medications = gr.Textbox(label="Current Medications", lines=2)
allergies = gr.Textbox(label="Known Allergies", lines=2)
additional_notes = gr.Textbox(label="Additional Notes", lines=3)
# 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("🎯 Segmentation Preview ")
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")
segmentation_only_btn = gr.Button("🎯 Get Segmentation Only", variant="secondary")
# Manual editing section (initially hidden)
with gr.Group(visible=False) as manual_edit_group:
gr.HTML("""
📝 Manual Segmentation Instructions
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.
""")
# 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
)
with gr.Row():
process_manual_btn = gr.Button("🔬 Generate Report with Manual Mask", variant="primary")
manual_segmentation_only_btn = gr.Button("🎯 Get Manual Segmentation Only", variant="secondary")
analysis_output = gr.HTML("")
# ------------------- PATIENT HISTORY -------------------
with gr.Tab("📋 Patient History"):
with gr.Row():
with gr.Column(scale=2):
history_btn = gr.Button("📄 Load Patient History", variant="primary")
patient_history_output = gr.HTML("")
with gr.Column(scale=1):
search_patient_name = gr.Textbox(label="Search patient by name")
search_patient_btn = gr.Button("🔍 Search", variant="secondary")
specific_patient_output = gr.HTML("")
gr.HTML("Organization dashboard coming soon.
")
logout_btn_org = gr.Button("🚪 Logout", variant="secondary")
# ----------------------- handlers -----------------------
def toggle_role_fields(role):
return {
org_fields: gr.update(visible=(role == "organization")),
prac_fields: gr.update(visible=(role != "organization"))
}
def handle_signup(username, email, password, name, role, org_name_v, phone_v, cc_v, dept_v, loc_v, org_dropdown):
try:
organization_id = None
if role == "practitioner":
organization_id = _resolve_org_id_from_dropdown(org_dropdown)
ok = self.auth_manager.create_user(
username=username,
email=email,
password=password,
name=name,
role=role,
org_name=(org_name_v or name) if role == "organization" else "",
phone=phone_v if role == "organization" else "",
country_code=cc_v if role == "organization" else "",
department=dept_v if role == "organization" else "",
location=loc_v if role == "organization" else "",
organization_id=organization_id
)
if ok:
return "✅ Account created. Please log in.
"
return "❌ Could not create account. Username/email may exist.
"
except Exception as e:
return f"❌ Error: {html.escape(str(e))}
"
def handle_login(username, password):
user = self.auth_manager.authenticate_user(username, password)
if not user:
return {
login_status: "❌ Invalid credentials.
"
}
self.current_user = user
uid = int(user.get("id"))
role = user.get("role")
if role == "practitioner":
_refresh_patient_dropdown(uid)
info = f"Welcome, {html.escape(user.get('name','User'))} — {html.escape(role)}
"
updates = {login_status: info}
if role == "practitioner":
updates.update({
auth_panel: gr.update(visible=False),
practitioner_panel: gr.update(visible=True),
user_info: info,
existing_patient_dd: gr.update(choices=self._patient_choices),
view_details_dd: gr.update(choices=self._patient_choices),
})
else:
updates.update({
auth_panel: gr.update(visible=False),
organization_panel: gr.update(visible=True),
})
return updates
def handle_logout():
self.current_user = {}
return {
auth_panel: gr.update(visible=True),
practitioner_panel: gr.update(visible=False),
organization_panel: gr.update(visible=False),
login_status: "Please sign in.
",
segmentation_preview_group: gr.update(visible=False),
manual_edit_group: gr.update(visible=False),
analysis_output: ""
}
def toggle_patient_mode(mode):
return {
existing_patient_dd: gr.update(visible=(mode == "Existing patient")),
new_patient_group: gr.update(visible=(mode == "New patient"))
}
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: "❌ Please upload a wound image.
"
}
try:
# 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: "❌ Please login first.
"
}
# 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: "⚠️ Select an existing patient.
"
}
# 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: "❌ Failed to analyze image.
"
}
# 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: "❌ Segmentation failed.
"
}
return {
segmentation_preview_group: gr.update(visible=True),
segmentation_preview: seg_path,
manual_edit_group: gr.update(visible=False),
analysis_output: "✅ Segmentation preview ready. Review and choose to accept or manually edit.
"
}
except Exception as e:
logging.error(f"Segmentation preview error: {e}")
return {
segmentation_preview_group: gr.update(visible=False),
analysis_output: f"❌ Error: {html.escape(str(e))}
"
}
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: "❌ Original image not available for editing.
"
}
return {
manual_edit_group: gr.update(visible=True),
manual_mask_input: img_path, # Load the original image for manual editing
analysis_output: "⚠️ Use the drawing tool to manually mark the wound area, then click your desired action.
"
}
def process_manual_mask(mask_data):
"""Process the manual mask from ImageMask component"""
if not mask_data:
return None
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):
# Check if composite exists (newer format)
if "composite" in mask_data:
composite_img = mask_data["composite"]
# Convert to grayscale and extract the drawn areas
gray = cv2.cvtColor(composite_img, cv2.COLOR_RGB2GRAY)
# Create mask where drawn areas are white (255) and background is black (0)
_, mask = cv2.threshold(gray, 1, 255, cv2.THRESH_BINARY)
# Check if layers exist (older format)
elif "layers" in mask_data and len(mask_data["layers"]) > 0:
# Get the alpha channel from the first layer (the drawn mask)
alpha_channel = mask_data["layers"][0][:, :, 3]
# Convert to binary mask - drawn areas have alpha > 0
mask = np.where(alpha_channel > 0, 255, 0).astype(np.uint8)
else:
return None
# Save the mask temporarily
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 get_segmentation_only(img_path, manual_mask_path=None):
"""Get only the segmentation mask without full analysis"""
try:
if not img_path:
return "❌ No image provided.
"
# Run visual analysis to get segmentation
image_pil = Image.open(img_path)
if manual_mask_path:
# Use manual mask
visual_results = self.wound_analyzer.analyze_wound(
img_path, {}, seg_adjust=0.0, manual_mask_path=manual_mask_path
)
mask_type = "Manual"
else:
# Use automatic segmentation
visual_results = self.wound_analyzer.perform_visual_analysis(image_pil)
mask_type = "Automatic"
if not visual_results:
return "❌ Failed to generate segmentation.
"
# Get the segmentation mask path
roi_mask_path = visual_results.get("roi_mask_path")
seg_path = visual_results.get("segmentation_image_path")
if not roi_mask_path or not os.path.exists(roi_mask_path):
return "❌ Segmentation mask not found.
"
# Convert mask to base64 for display
mask_b64 = self.image_to_base64(roi_mask_path)
seg_b64 = self.image_to_base64(seg_path) if seg_path and os.path.exists(seg_path) else None
html_output = f"""
🎯 {mask_type} Wound Segmentation
Binary mask showing wound boundaries
✅ Segmentation Status: {mask_type} segmentation completed successfully
Binary Mask
{f'
' if mask_b64 else '
Mask not available
'}
White = Wound, Black = Background
Overlay Visualization
{f'
' if seg_b64 else '
Overlay not available
'}
Red overlay shows detected wound area
📥 Download Instructions
Right-click on the binary mask image above and select "Save image as..." to download the segmentation mask for your use.
"""
# Clean up temporary file if it exists
if manual_mask_path and os.path.exists(manual_mask_path):
try:
os.unlink(manual_mask_path)
except:
pass
return html_output
except Exception as e:
logging.error(f"Segmentation only error: {e}")
return f"❌ Error: {html.escape(str(e))}
"
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"❌ Analysis failed: {html.escape(str(e))}
"
}
def get_manual_segmentation_only(mask_data, img_path):
"""Get only the manual segmentation mask"""
try:
manual_mask_path = process_manual_mask(mask_data)
if not manual_mask_path:
return "❌ Failed to process manual mask.
"
result = get_segmentation_only(img_path, manual_mask_path)
return {
analysis_output: result,
segmentation_preview_group: gr.update(visible=False),
manual_edit_group: gr.update(visible=False)
}
except Exception as e:
logging.error(f"Manual segmentation only error: {e}")
return {
analysis_output: f"❌ Error: {html.escape(str(e))}
"
}
def get_auto_segmentation_only(img_path):
"""Get only the automatic segmentation mask"""
try:
result = get_segmentation_only(img_path, None)
return {
analysis_output: result,
segmentation_preview_group: gr.update(visible=False),
manual_edit_group: gr.update(visible=False)
}
except Exception as e:
logging.error(f"Auto segmentation only error: {e}")
return {
analysis_output: f"❌ Error: {html.escape(str(e))}
"
}
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"❌ Analysis failed: {html.escape(str(e))}
"
}
def load_patient_history():
try:
uid = int(self.current_user.get("id", 0))
if not uid:
return "❌ Please login first.
"
history_data = self.patient_history_manager.get_patient_history(uid)
if not history_data:
return "⚠️ No patient history found.
"
html_report = self.report_generator.generate_history_report(history_data)
return html_report
except Exception as e:
logging.error(f"History load error: {e}")
return f"❌ Error: {html.escape(str(e))}
"
def search_patient_by_name(name):
try:
uid = int(self.current_user.get("id", 0))
if not uid:
return "❌ Please login first.
"
if not name or not name.strip():
return "⚠️ Enter a patient name to search.
"
results = self.patient_history_manager.search_patients_by_name(uid, name.strip())
if not results:
return f"⚠️ No patients found matching '{html.escape(name)}'.
"
html_report = self.report_generator.generate_search_results(results, name)
return html_report
except Exception as e:
logging.error(f"Patient search error: {e}")
return f"❌ Error: {html.escape(str(e))}
"
def view_patient_details(selected_label):
try:
uid = int(self.current_user.get("id", 0))
if not uid:
return "❌ Please login first.
"
pid = _label_to_id(selected_label)
if not pid:
return "⚠️ Select a patient to view details.
"
details = self.patient_history_manager.get_patient_details(uid, pid)
if not details:
return "⚠️ No details found for selected patient.
"
html_report = self.report_generator.generate_patient_timeline(details)
return html_report
except Exception as e:
logging.error(f"Patient details error: {e}")
return f"❌ Error: {html.escape(str(e))}
"
# ----------------------- Event bindings -----------------------
signup_role.change(toggle_role_fields, [signup_role], [org_fields, prac_fields])
signup_btn.click(
handle_signup,
[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,
[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,
[],
[auth_panel, practitioner_panel, organization_panel, login_status,
segmentation_preview_group, manual_edit_group, analysis_output]
)
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(
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]
)
# 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]
)
# Get segmentation only (automatic)
segmentation_only_btn.click(
get_auto_segmentation_only,
[wound_image],
[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]
)
# Get manual segmentation only
manual_segmentation_only_btn.click(
get_manual_segmentation_only,
[manual_mask_input, wound_image],
[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
def _format_comprehensive_analysis_results(self, analysis_result, image_path, questionnaire_data):
"""Format comprehensive analysis results with enhanced visual presentation
- Shows 'Manual Segmentation' card if a manual mask/overlay was used
- Removes the Measurements card from the Visual Analysis Gallery
"""
import os
try:
visual_analysis = analysis_result.get("visual_analysis", {}) or {}
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")
# Detect if manual mask was used (look across common keys/flags)
manual_used = bool(
analysis_result.get("manual_mask_used")
or visual_analysis.get("manual_mask_used")
)
# Try to discover manual overlay/binary mask paths (handle multiple possible keys)
manual_overlay_path = None
for k in [
"manual_segmentation_image_path",
"manual_overlay_path",
"manual_segmentation_overlay_path",
]:
p = visual_analysis.get(k)
if p and os.path.exists(p):
manual_overlay_path = p
manual_used = True
break
manual_binary_path = None
for k in [
"manual_roi_mask_path",
"manual_mask_binary_path",
"manual_mask_path",
]:
p = visual_analysis.get(k)
if p and os.path.exists(p):
manual_binary_path = p
manual_used = True
break
# Generate risk assessment
risk_assessment = self._generate_risk_assessment(questionnaire_data)
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 = ""
for factor in risk_factors:
risk_factors_html += f"{html.escape(str(factor))} "
risk_factors_html += " "
else:
risk_factors_html = "No specific risk factors identified.
"
# ---------------------- Image Gallery ----------------------
image_gallery_html = ""
# 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"""
📸 Original Image
Uploaded wound photograph for analysis
"""
# 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:
conf = visual_analysis.get('detection_confidence', 0.0)
try:
conf_str = f"{float(conf):.1%}"
except Exception:
conf_str = str(conf)
image_gallery_html += f"""
🎯 Wound Detection
AI-powered wound boundary detection with confidence: {conf_str}
"""
# Show MANUAL segmentation card if available/used
if manual_overlay_path or manual_binary_path:
if manual_overlay_path and os.path.exists(manual_overlay_path):
img_b64 = self.image_to_base64(manual_overlay_path)
elif manual_binary_path and os.path.exists(manual_binary_path):
img_b64 = self.image_to_base64(manual_binary_path)
else:
img_b64 = None
if img_b64:
image_gallery_html += f"""
✏️ Manual Segmentation
Clinician-adjusted wound boundary used for this report
"""
# Automatic segmentation (still show if present)
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"""
🔍 Wound Segmentation
Precise wound boundary identification and tissue analysis
"""
# NOTE: Measurements card intentionally REMOVED from gallery as requested
# (Do NOT add segmentation_annotated_path card)
image_gallery_html += "
manual segmentation"
if manual_used else
"Analysis completed successfully with comprehensive wound assessment"
)
html_output = f"""
🔬 SmartHeal AI Comprehensive Analysis
Advanced Computer Vision & Medical AI Assessment
Patient: {html.escape(str(questionnaire_data.get('patient_name', 'Unknown')))} | Analysis Date: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
✅ Analysis Status: {status_line}
🖼️ Visual Analysis Gallery
{image_gallery_html}
🔍 Wound Detection & Classification
Wound Type
{html.escape(str(wound_type))}
Location
{html.escape(str(questionnaire_data.get('wound_location', 'Not specified')))}
Skin Tone
{html.escape(str(skin_tone_label))}{f" ({ita_deg:.1f}°)" if ita_deg is not None else ""}
Tissue Type
{html.escape(str(tissue_type))}
📏 Wound Measurements
Length
{length_cm:.2f} cm
Width
{breadth_cm:.2f} cm
Surface Area
{area_cm2:.2f} cm²
👤 Patient Information Summary
Age: {html.escape(str(questionnaire_data.get('age', 'Not specified')))} years
Gender: {html.escape(str(questionnaire_data.get('patient_gender', 'Not specified')))}
Diabetic Status: {html.escape(str(questionnaire_data.get('diabetic', 'Unknown')))}
Pain Level: {html.escape(str(questionnaire_data.get('pain_level', 'Not assessed')))} / 10
Wound Duration: {html.escape(str(questionnaire_data.get('wound_duration', 'Not specified')))}
Moisture Level: {html.escape(str(questionnaire_data.get('moisture', 'Not assessed')))}
{f"
Medical History: {html.escape(str(questionnaire_data.get('medical_history', 'None provided')))}
" if questionnaire_data.get('medical_history') else ""}
{f"
Current Medications: {html.escape(str(questionnaire_data.get('medications', 'None listed')))}
" if questionnaire_data.get('medications') else ""}
{f"
Known Allergies: {html.escape(str(questionnaire_data.get('allergies', 'None listed')))}
" if questionnaire_data.get('allergies') else ""}
{f'
🤖 AI-Generated Clinical Report {report_html}
' if report_html else ''}
⚠️ Important Medical Disclaimers
Not a Medical Diagnosis: This AI analysis is for informational purposes only and does not constitute medical advice, diagnosis, or treatment.Professional Consultation Required: Always consult with qualified healthcare professionals for proper clinical assessment and treatment decisions.Measurement Accuracy: All measurements are estimates based on computer vision algorithms and should be verified with clinical tools.Risk Assessment Limitations: Risk factors are based on provided information and may not reflect the complete clinical picture.
🏥 Analysis completed by SmartHeal AI - Advanced Wound Care AssistantReport generated on {datetime.now().strftime('%B %d, %Y at %I:%M %p')}
"""
return html_output
except Exception as e:
logging.error(f"Error formatting comprehensive results: {e}")
return f"❌ Error displaying results: {str(e)}
"
def _generate_risk_assessment(self, questionnaire_data):
"""Generate risk assessment based on questionnaire data"""
if not questionnaire_data:
return {'risk_level': 'Unknown', 'risk_score': 0, 'risk_factors': []}
risk_factors = []
risk_score = 0
try:
# Age
age = questionnaire_data.get('age', 0)
if isinstance(age, str):
try:
age = int(age)
except ValueError:
age = 0
if age > 65:
risk_factors.append("Advanced age (>65 years)")
risk_score += 2
elif age > 50:
risk_factors.append("Older adult (50-65 years)")
risk_score += 1
# Diabetes
diabetic_status = str(questionnaire_data.get('diabetic', '')).lower()
if 'yes' in diabetic_status:
risk_factors.append("Diabetes mellitus")
risk_score += 3
# Infection
infection = str(questionnaire_data.get('infection', '')).lower()
if 'yes' in infection:
risk_factors.append("Signs of infection present")
risk_score += 3
# Pain
pain_level = questionnaire_data.get('pain_level', 0)
if isinstance(pain_level, str):
try:
pain_level = float(pain_level)
except ValueError:
pain_level = 0
if pain_level >= 7:
risk_factors.append("High pain level (≥7/10)")
risk_score += 2
elif pain_level >= 5:
risk_factors.append("Moderate pain level (5-6/10)")
risk_score += 1
# Duration
duration = str(questionnaire_data.get('wound_duration', '')).lower()
if any(term in duration for term in ['month', 'months', 'year', 'years']):
risk_factors.append("Chronic wound (>4 weeks)")
risk_score += 3
# Moisture
moisture = str(questionnaire_data.get('moisture', '')).lower()
if any(term in moisture for term in ['wet', 'saturated']):
risk_factors.append("Excessive wound exudate")
risk_score += 1
# Medical history
medical_history = str(questionnaire_data.get('medical_history', '')).lower()
if any(term in medical_history for term in ['vascular', 'circulation', 'heart']):
risk_factors.append("Cardiovascular disease")
risk_score += 2
if any(term in medical_history for term in ['immune', 'cancer', 'steroid']):
risk_factors.append("Immune system compromise")
risk_score += 2
if any(term in medical_history for term in ['smoking', 'tobacco']):
risk_factors.append("Smoking history")
risk_score += 2
# Risk level
if risk_score >= 8:
risk_level = "Very High"
elif risk_score >= 6:
risk_level = "High"
elif risk_score >= 3:
risk_level = "Moderate"
else:
risk_level = "Low"
return {
'risk_score': risk_score,
'risk_level': risk_level,
'risk_factors': risk_factors
}
except Exception as e:
logging.error(f"Risk assessment error: {e}")
return {
'risk_score': 0,
'risk_level': 'Unknown',
'risk_factors': ['Unable to assess risk due to data processing error']
}