Update app.py

app.py

@@ -1,189 +1,486 @@
-# =============================================
-# Diabetic Foot Ulcer Diagnosis App (Unified)
-# Ready for HuggingFace Spaces
-# =============================================
-import os
-import io
-import cv2
-import json
+import tensorflow as tf
+from tensorflow.keras.models import load_model
 import torch
+import torch.nn as nn
 import numpy as np
 import gradio as gr
-import torch.nn as nn
-import torchvision.transforms as transforms
-from torchvision import models
 from PIL import Image
-import segmentation_models_pytorch as smp
+import cv2
+from torchvision import transforms
+import gdown  
+import os
 import albumentations as A
-from albumentations.pytorch import ToTensorV2
-import tensorflow as tf
-from tensorflow.keras.models import load_model
-from tensorflow.keras.applications import EfficientNetB3
-from tensorflow.keras.preprocessing.image import ImageDataGenerator
-from tensorflow.keras import layers, models as tf_models
-from sklearn.model_selection import train_test_split
-from torch.utils.data import DataLoader, Dataset
-from tqdm import tqdm
-
-# =============================================
-# Load pretrained models from Google Drive (unchanged section)
-# =============================================
-
-def load_models():
-    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-
-    # Load Segmentation Model (PyTorch)
-    seg_model_path = '/content/drive/MyDrive/models/best_model.pth'
-    seg_model = smp.Unet('efficientnet-b7', encoder_weights='imagenet', in_channels=3, classes=1)
-    seg_model.load_state_dict(torch.load(seg_model_path, map_location=device))
-    seg_model.eval()
-
-    # Load Classification Model (TensorFlow)
-    clf_model_path = '/content/drive/MyDrive/models/efficientnetb3_dfu_model.keras'
-    clf_model = load_model(clf_model_path)
-
-    return seg_model, clf_model, device
-
-
-# =============================================
-# Model Definitions (for optional retraining)
-# =============================================
-
-class FuSegNet(nn.Module):
-    def __init__(self):
-        super().__init__()
-        self.model = smp.Unet('efficientnet-b7', encoder_weights='imagenet', in_channels=3, classes=1)
-
+import segmentation_models_pytorch as smp
+import requests
+from io import BytesIO
+
+# تعريفات عالمية
+classifier = None
+segmenter = None
+class_names = ["Abnormal(Ulcer)", "Normal(Healthy skin)"]
+IMG_SIZE = 224
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+class FUSegNet(nn.Module):
+    """FUSegNet نموذج مخصص لمطابقة هيكل"""
+    def __init__(self, encoder_name='efficientnet-b7', classes=1, activation='sigmoid'):
+        super(FUSegNet, self).__init__()
+        
+        self.unet = smp.Unet(
+            encoder_name=encoder_name,
+            encoder_weights=None,
+            classes=classes,
+            activation=activation,
+            decoder_attention_type='pscse',  # إضافة نوع الانتباه المخصص
+        )
+    
     def forward(self, x):
-        return self.model(x)
-
-
-# =============================================
-# Smart Ulcer Detection (fallback)
-# =============================================
-
-def smart_ulcer_detection(image_path):
-    image = cv2.imread(image_path)
-    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
-    hsv = cv2.cvtColor(image_rgb, cv2.COLOR_RGB2HSV)
-
-    lower_red1 = np.array([0, 30, 60])
+        return self.unet(x)
+
+def check_and_download(url, path, min_size_mb=50):
+    """التحقق من وجود الملفات وتحميلها إذا كانت مفقودة"""
+    if not os.path.exists(path) or os.path.getsize(path) < min_size_mb * 1024 * 1024:
+        print(f"📥 تحميل النموذج من Google Drive: {url}")
+        try:
+            gdown.download(url, path, quiet=False, fuzzy=True)
+            if os.path.exists(path):
+                size = os.path.getsize(path) / (1024 * 1024)
+                print(f"✅ تم التحميل بنجاح: {os.path.basename(path)} ({size:.2f} MB)")
+            else:
+                print(f"❌ فشل التحميل: {path}")
+        except Exception as e:
+            print(f"❌ خطأ في التحميل: {e}")
+    else:
+        size = os.path.getsize(path) / (1024 * 1024)
+        print(f"✅ الملف موجود: {os.path.basename(path)} ({size:.2f} MB)")
+
+def initialize_models():
+    """تهيئة النماذج"""
+    global classifier, segmenter
+    
+    # روابط ومسارات النماذج
+    EFF_MODEL_URL = "https://drive.google.com/uc?id=1vVmA_-D3pZPbKHrPFEbDJd2nexF1H9Ni"
+    SEG_MODEL_URL = "https://drive.google.com/uc?id=13jMlcH9yTSejL_IfMDXqdAiVy6Z_SpE1"
+    
+    EFF_MODEL_PATH = "efficientnetb3_dfu_model.keras"
+    SEG_MODEL_PATH = "best_model.pth"
+    
+    # تحميل النماذج
+    check_and_download(EFF_MODEL_URL, EFF_MODEL_PATH, min_size_mb=50)
+    check_and_download(SEG_MODEL_URL, SEG_MODEL_PATH, min_size_mb=100)
+    
+    # ------ نموذج التصنيف (Keras)
+    try:
+        print("🔄 ��اري تحميل نموذج التصنيف...")
+        classifier = tf.keras.models.load_model(EFF_MODEL_PATH, compile=False)
+        print("✅ تم تحميل نموذج التصنيف بنجاح!")
+    except Exception as e:
+        print(f"❌ خطأ أثناء تحميل نموذج التصنيف: {e}")
+        classifier = None
+    
+    # ------ نموذج التجزئة (FUSegNet)
+    try:
+        print("🔄 جاري تحميل نموذج FUSegNet...")
+        
+        # بناء النموذج بنفس مواصفات التدريب
+        segmenter = FUSegNet(
+            encoder_name='efficientnet-b7',
+            classes=1,
+            activation='sigmoid'
+        )
+        
+        # تحميل الأوزان
+        checkpoint = torch.load(SEG_MODEL_PATH, map_location=DEVICE)
+        
+        # معالجة مرنة للأوزان
+        if 'state_dict' in checkpoint:
+            state_dict = checkpoint['state_dict']
+        else:
+            state_dict = checkpoint
+        
+        # تنظيف مفاتيح state_dict
+        new_state_dict = {}
+        for k, v in state_dict.items():
+            # إزالة البادئات المختلفة
+            new_key = k.replace('module.', '').replace('model.', '').replace('unet.', '')
+            new_state_dict[new_key] = v
+        
+        # تحميل الأوزان مع التعامل مع المفاتيح المفقودة
+        model_dict = segmenter.state_dict()
+        
+        # 1. محاولة التحميل المباشر أولاً
+        try:
+            segmenter.load_state_dict(new_state_dict, strict=True)
+            print("✅ تم تحميل الأوزان بنجاح (وضع صارم)")
+        except:
+            # 2. إذا فشل، حاول التحميل المرن
+            matched_keys = []
+            missing_keys = []
+            unexpected_keys = []
+            
+            for name, param in model_dict.items():
+                if name in new_state_dict:
+                    if param.shape == new_state_dict[name].shape:
+                        param.data.copy_(new_state_dict[name])
+                        matched_keys.append(name)
+                    else:
+                        missing_keys.append(name)
+                else:
+                    missing_keys.append(name)
+            
+            for key in new_state_dict:
+                if key not in model_dict:
+                    unexpected_keys.append(key)
+            
+            print(f"📊 إحصائيات التحميل:")
+            print(f"   - المفاتيح المتطابقة: {len(matched_keys)}")
+            print(f"   - المفاتيح المفقودة: {len(missing_keys)}")
+            print(f"   - المفاتيح غير المتوقعة: {len(unexpected_keys)}")
+            
+            if len(matched_keys) > 0:
+                print("✅ تم تحميل بعض الأوزان بنجاح")
+            else:
+                print("❌ فشل تحميل الأوزان، استخدام النموذج بدون أوزان")
+        
+        segmenter.to(DEVICE)
+        segmenter.eval()
+        
+        # اختبار سريع للنموذج
+        with torch.no_grad():
+            test_input = torch.randn(1, 3, IMG_SIZE, IMG_SIZE).to(DEVICE)
+            test_output = segmenter(test_input)
+            print(f"🧪 اختبار النموذج: [{test_output.min().item():.6f}, {test_output.max().item():.6f}]")
+        
+    except Exception as e:
+        print(f"❌ خطأ في تحميل نموذج التجزئة: {e}")
+        segmenter = None
+
+def get_preprocessing_fn():
+    """دالة المعالجة المسبقة المتوافقة مع EfficientNet-B7"""
+    from segmentation_models_pytorch.encoders import get_preprocessing_fn
+    return get_preprocessing_fn('efficientnet-b7', pretrained='imagenet')
+
+def smart_ulcer_detection(img: Image.Image):
+    """كشف القرحة باستخدام معالجة الصور المتقدمة"""
+    print("🔍 استخدام الخوارزمية الذكية للكشف عن القرحة...")
+    
+    img_np = np.array(img)
+    height, width = img_np.shape[:2]
+    
+    # 1. تحويل إلى مساحات لون مختلفة
+    hsv = cv2.cvtColor(img_np, cv2.COLOR_RGB2HSV)
+    lab = cv2.cvtColor(img_np, cv2.COLOR_RGB2LAB)
+    
+    # 2. كشف الألوان المرتبطة بالقرحة
+    # الأحمر النشط
+    lower_red1 = np.array([0, 60, 60])
     upper_red1 = np.array([10, 255, 255])
-    lower_red2 = np.array([160, 30, 60])
-    upper_red2 = np.array([179, 255, 255])
-
-    mask1 = cv2.inRange(hsv, lower_red1, upper_red1)
-    mask2 = cv2.inRange(hsv, lower_red2, upper_red2)
-    mask = cv2.bitwise_or(mask1, mask2)
-
-    mask = cv2.medianBlur(mask, 5)
-    mask = cv2.dilate(mask, np.ones((3, 3), np.uint8), iterations=2)
-
-    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    if not contours:
-        return image_rgb, 0, 'No Ulcer Detected'
-
-    total_area = image.shape[0] * image.shape[1]
-    ulcer_area = sum(cv2.contourArea(c) for c in contours)
-    area_ratio = ulcer_area / total_area
-
-    if area_ratio < 0.01:
-        severity = 'Low Risk'
-    elif area_ratio < 0.05:
-        severity = 'Medium Risk'
+    lower_red2 = np.array([160, 60, 60])
+    upper_red2 = np.array([180, 255, 255])
+    red_mask = cv2.inRange(hsv, lower_red1, upper_red1) + cv2.inRange(hsv, lower_red2, upper_red2)
+    
+    # البني/الأسود (أنسجة ميتة)
+    lower_brown = np.array([0, 40, 20])
+    upper_brown = np.array([20, 200, 150])
+    brown_mask = cv2.inRange(hsv, lower_brown, upper_brown)
+    
+    # 3. كشف التغيرات في الإضاءة
+    l_channel = lab[:,:,0]
+    _, dark_areas = cv2.threshold(l_channel, 80, 255, cv2.THRESH_BINARY_INV)
+    
+    # 4. دمج جميع الأقنعة
+    combined_mask = cv2.bitwise_or(red_mask, brown_mask)
+    combined_mask = cv2.bitwise_or(combined_mask, dark_areas)
+    
+    # 5. تنظيف متقدم للقناع
+    kernel = np.ones((5,5), np.uint8)
+    combined_mask = cv2.morphologyEx(combined_mask, cv2.MORPH_OPEN, kernel)
+    combined_mask = cv2.morphologyEx(combined_mask, cv2.MORPH_CLOSE, kernel)
+    
+    # 6. الاحتفاظ فقط بالمناطق الكبيرة
+    contours, _ = cv2.findContours(combined_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    final_mask = np.zeros_like(combined_mask)
+    
+    min_area = height * width * 0.002  # 0.2% من مساحة الصورة
+    
+    for contour in contours:
+        area = cv2.contourArea(contour)
+        if area > min_area:
+            perimeter = cv2.arcLength(contour, True)
+            if perimeter > 0:
+                circularity = 4 * np.pi * area / (perimeter * perimeter)
+                if circularity < 0.7:  # استبعاد الأشكال الدائرية الكاملة
+                    cv2.fillPoly(final_mask, [contour], 255)
+    
+    ulcer_pixels = np.sum(final_mask > 0)
+    print(f"📊 الخوارزمية الذكية اكتشفت {ulcer_pixels} بيكسل قرحة")
+    
+    return (final_mask > 0).astype(np.uint8)
+
+def classify_image(img: Image.Image):
+    """تصنيف الصورة"""
+    if classifier is None:
+        # استخدام كشف بسيط للون الأحمر للتصنيف الافتراضي
+        img_np = np.array(img)
+        hsv = cv2.cvtColor(img_np, cv2.COLOR_RGB2HSV)
+        red_mask = cv2.inRange(hsv, np.array([0,50,50]), np.array([10,255,255])) + \
+                  cv2.inRange(hsv, np.array([160,50,50]), np.array([180,255,255]))
+        red_ratio = np.sum(red_mask > 0) / red_mask.size
+        result = "Abnormal(Ulcer)" if red_ratio > 0.005 else "Normal(Healthy skin)"
+        print(f"🎯 التصنيف الافتراضي: {result} (نسبة الأحمر: {red_ratio:.4f})")
+        return result
+    
+    try:
+        # معالجة الصورة للتصنيف
+        img_processed = img.resize((IMG_SIZE, IMG_SIZE))
+        img_array = tf.keras.preprocessing.image.img_to_array(img_processed)
+        img_array = np.expand_dims(img_array, axis=0)
+        img_array = tf.keras.applications.efficientnet.preprocess_input(img_array)
+        
+        # التوقع
+        preds = classifier.predict(img_array, verbose=0)
+        pred_class = np.argmax(preds, axis=1)[0]
+        confidence = np.max(preds)
+        
+        result = class_names[pred_class]
+        print(f"🎯 تصنيف النموذج: {result} (ثقة: {confidence:.3f})")
+        return result
+        
+    except Exception as e:
+        print(f"❌ خطأ في التصنيف: {e}")
+        return "Abnormal(Ulcer)"
+
+def segment_image(img: Image.Image):
+    """تجزئة الصورة باستخدام FUSegNet"""
+    if segmenter is not None:
+        try:
+            print("🔄 جاري تجزئة الصورة باستخدام FUSegNet...")
+            
+            # معالجة الصورة بنفس طريقة التدريب
+            preprocessing_fn = get_preprocessing_fn()
+            
+            img_np = np.array(img)
+            img_resized = cv2.resize(img_np, (IMG_SIZE, IMG_SIZE))
+            
+            # تطبيق المعالجة المسبقة
+            processed_img = preprocessing_fn(img_resized)
+            
+            # تحويل إلى tensor
+            img_tensor = torch.from_numpy(processed_img).permute(2, 0, 1).unsqueeze(0).float().to(DEVICE)
+            
+            # التوقع
+            with torch.no_grad():
+                output = segmenter(img_tensor)
+                pred = output.squeeze().cpu().numpy()
+            
+            print(f"📊 إخراج النموذج: [{pred.min():.6f}, {pred.max():.6f}]")
+            
+            # تجربة عتبات مختلفة
+            best_threshold = 0.3
+            best_pixels = 0
+            
+            for threshold in [0.2, 0.3, 0.4, 0.5]:
+                mask_bin = (pred >= threshold).astype(np.uint8)
+                mask_resized = cv2.resize(mask_bin, (img.width, img.height))
+                ulcer_pixels = np.sum(mask_resized)
+                
+                if ulcer_pixels > best_pixels:
+                    best_pixels = ulcer_pixels
+                    best_threshold = threshold
+            
+            if best_pixels > 0:
+                mask_bin = (pred >= best_threshold).astype(np.uint8)
+                mask_resized = cv2.resize(mask_bin, (img.width, img.height))
+                print(f"✅ FUSegNet اكتشف {best_pixels} بيكسل (threshold: {best_threshold})")
+                return mask_resized
+            else:
+                print("⚠️ FUSegNet لم يعط نتائج، استخدام الخوارزمية الذكية")
+                
+        except Exception as e:
+            print(f"❌ خطأ في نموذج التجزئة: {e}")
+    
+    # استخدام الخوارزمية الذكية كبديل
+    return smart_ulcer_detection(img)
+
+def calculate_risk(mask):
+    """حساب مستوى الخطورة"""
+    ulcer_pixels = np.sum(mask == 1)
+    total_pixels = mask.size
+    percent = (ulcer_pixels / total_pixels) * 100
+
+    print(f"📏 مساحة القرحة: {ulcer_pixels}/{total_pixels} بيكسل ({percent:.4f}%)")
+
+    if ulcer_pixels == 0:
+        return 0.0, "No Risk", 0
+    elif percent <= 1:
+        return percent, "Low Risk", 1
+    elif percent <= 5:
+        return percent, "Medium Risk", 3
     else:
-        severity = 'High Risk'
-
-    mask_colored = cv2.applyColorMap(mask, cv2.COLORMAP_JET)
-    overlay = cv2.addWeighted(image_rgb, 0.7, mask_colored, 0.3, 0)
-    return overlay, area_ratio * 100, severity
-
-
-# =============================================
-# Gradio Interface Logic
-# =============================================
-
-def predict_ulcer(img1, img2):
-    seg_model, clf_model, device = load_models()
+        return percent, "High Risk", 5
+
+def apply_mask_to_image(img: Image.Image, mask):
+    """تطبيق القناع على الصورة"""
+    img_np = np.array(img)
+    
+    ulcer_pixels = np.sum(mask == 1)
+    if ulcer_pixels == 0:
+        print("✅ لا توجد قرحة مكتشفة")
+        return img
+    
+    print(f"🎨 تطبيق القناع على {ulcer_pixels} بيكسل")
+    
+    # إنشاء قناع ملون
+    colored_mask = np.zeros_like(img_np)
+    colored_mask[mask == 1] = [255, 0, 0]  # أحمر
+    
+    # دمج مع الشفافية
+    result = cv2.addWeighted(img_np, 0.6, colored_mask, 0.4, 0)
+    
+    # إضافة حدود حمراء
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    for contour in contours:
+        area = cv2.contourArea(contour)
+        if area > 20:
+            cv2.drawContours(result, [contour], -1, (255, 0, 0), 3)
+    
+    return Image.fromarray(result)
+
+def analyze_images(img1, img2):
+    """تحليل صورتين فقط لتحسين الأداء"""
     images = [img1, img2]
-    results = []
+    gallery_output = []
+    json_output = {}
 
-    for img in images:
+    for idx, img in enumerate(images):
+        image_key = f"image_{idx+1}"
+        
         if img is None:
+            gallery_output.append(None)
+            json_output[image_key] = {
+                "status": "No image uploaded",
+                "classification": "None", 
+                "ulcer_percentage": 0.0,
+                "risk_level": "None",
+                "risk_score": 0
+            }
             continue
-        temp_path = '/tmp/temp_img.jpg'
-        img.save(temp_path)
-
-        # Classification (TensorFlow)
-        img_tf = img.resize((300, 300))
-        img_arr = np.array(img_tf) / 255.0
-        pred = clf_model.predict(np.expand_dims(img_arr, axis=0))[0][0]
-        classification = 'Abnormal (Ulcer)' if pred > 0.5 else 'Normal (Healthy)'
-
-        # Segmentation (PyTorch)
-        transform = A.Compose([
-            A.Resize(512, 512),
-            A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
-            ToTensorV2()
-        ])
-
-        image_np = np.array(img.convert('RGB'))
-        image_tensor = transform(image=image_np)['image'].unsqueeze(0).to(device)
-
-        with torch.no_grad():
-            mask_pred = torch.sigmoid(seg_model(image_tensor)).cpu().numpy()[0, 0]
 
-        mask_resized = cv2.resize(mask_pred, (image_np.shape[1], image_np.shape[0]))
-        threshold = 0.3
-        binary_mask = (mask_resized > threshold).astype(np.uint8)
-        mask_color = cv2.applyColorMap((binary_mask * 255).astype(np.uint8), cv2.COLORMAP_JET)
-        overlay = cv2.addWeighted(image_np, 0.7, mask_color, 0.3, 0)
-
-        ulcer_ratio = (binary_mask.sum() / binary_mask.size) * 100
-
-        if ulcer_ratio < 1:
-            fallback_img, fallback_ratio, severity = smart_ulcer_detection(temp_path)
-            overlay = fallback_img
-            ulcer_ratio = fallback_ratio
-        else:
-            severity = (
-                'Low Risk' if ulcer_ratio < 5 else
-                'Medium Risk' if ulcer_ratio < 15 else
-                'High Risk'
+        try:
+            print(f"\n{'='*40}")
+            print(f"🖼️ معالجة الصورة {idx+1}...")
+            print(f"📐 حجم الصورة: {img.size}")
+            
+            # التصنيف
+            classification = classify_image(img)
+            print(f"🎯 التصنيف: {classification}")
+            
+            # التجزئة
+            mask = segment_image(img)
+            masked_img = apply_mask_to_image(img, mask)
+            ulcer_percent, risk_level, risk_score = calculate_risk(mask)
+            
+            gallery_output.append(masked_img)
+            json_output[image_key] = {
+                "status": "Analyzed",
+                "classification": classification,
+                "ulcer_percentage": round(ulcer_percent, 4),
+                "risk_level": risk_level,
+                "risk_score": risk_score,
+                "ulcer_pixels": int(np.sum(mask == 1)),
+                "total_pixels": mask.size
+            }
+                
+        except Exception as e:
+            print(f"❌ خطأ في الصورة {idx+1}: {e}")
+            gallery_output.append(img)
+            json_output[image_key] = {
+                "status": f"Error: {str(e)}",
+                "classification": "Error",
+                "ulcer_percentage": 0.0,
+                "risk_level": "Error", 
+                "risk_score": 0
+            }
+    
+    print(f"\n✅ تم معالجة {len([x for x in gallery_output if x is not None])} صور")
+    return gallery_output, json_output
+
+# تهيئة النماذج
+print("🚀 جاري تهيئة النماذج...")
+initialize_models()
+
+# واجهة Gradio
+with gr.Blocks(title="Diabetic Foot Ulcer Analysis", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🦶 Diabetic Foot Ulcer Detection & Risk Analysis
+    
+    **تحليل قرحة القدم السكري باستخدام الذكاء الاصطناعي المتقدم**
+    
+    ⚡ **مميزات النظام:**
+    - تحليل صورتين فقط لتسريع الأداء
+    - كشف ذكي للقرحة باستخدام نموذج FUSegNet المدرب
+    - خوارزمية بديلة ذكية إذا فشلت النماذج
+    - تقييم دقيق لمستوى الخطورة
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 📤 رفع الصور")
+            with gr.Row():
+                img1 = gr.Image(type="pil", label="صورة القدم الأولى", height=250)
+                img2 = gr.Image(type="pil", label="صورة القدم الثانية", height=250)
+            
+            analyze_btn = gr.Button(
+                "🔍 بدء التحليل", 
+                variant="primary", 
+                size="lg"
             )
-
-        results.append((Image.fromarray(overlay), {
-            'Classification': classification,
-            'Ulcer Area %': round(ulcer_ratio, 2),
-            'Severity': severity
-        }))
-
-    return results[0][0], json.dumps(results[0][1], indent=2), results[1][0], json.dumps(results[1][1], indent=2)
-
-
-# =============================================
-# Gradio App Setup
-# =============================================
-
-title = "🦶 Diabetic Foot Ulcer Diagnosis System (Unified)"
-description = "Upload two images to analyze ulcer severity using AI segmentation and classification."
-
-iface = gr.Interface(
-    fn=predict_ulcer,
-    inputs=[
-        gr.Image(label="Upload Image 1"),
-        gr.Image(label="Upload Image 2")
-    ],
-    outputs=[
-        gr.Image(label="Result 1"),
-        gr.JSON(label="Analysis 1"),
-        gr.Image(label="Result 2"),
-        gr.JSON(label="Analysis 2")
-    ],
-    title=title,
-    description=description,
-    allow_flagging='never'
-)
-
-if __name__ == '__main__':
-    iface.launch(server_name='0.0.0.0', server_port=7860)
+            
+            gr.Markdown("""
+            **💡 نصائح للاستخدام:**
+            - اختر صور واضحة للقدم
+            - تجنب الصور المضغوطة كثيراً
+            - الصور الملونة تعطي نتائج أفضل
+            - تأكد من إضاءة جيدة للصورة
+            """)
+        
+        with gr.Column(scale=1):
+            gr.Markdown("### 📊 النتائج")
+            gallery = gr.Gallery(
+                label="الصور المحللة",
+                columns=2,
+                height="auto",
+                object_fit="contain"
+            )
+            
+            json_output = gr.JSON(
+                label="النتائج التفصيلية",
+                show_label=True
+            )
+    
+    # تعليمات إضافية
+    gr.Markdown("""
+    ---
+    **📋 تفسير النتائج:**
+    - **No Risk**: لا توجد قرحة مكتشفة
+    - **Low Risk**: مساحة القرحة ≤ 1%
+    - **Medium Risk**: مساحة القرحة ≤ 5% 
+    - **High Risk**: مساحة القرحة > 5%
+    
+    **🔴 المناطق الحمراء**: تشير إلى ��واقع القرحة المكتشفة
+    """)
+    
+    analyze_btn.click(
+        fn=analyze_images,
+        inputs=[img1, img2],
+        outputs=[gallery, json_output]
+    )
+
+if __name__ == "__main__":
+    print("🌐 Starting Gradio server...")
+    print("✅ النظام جاهز لتحليل صورتين")
+    demo.launch(
+        server_name="0.0.0.0", 
+        server_port=7860,
+        share=True
+    )