V1

app.py

@@ -2,14 +2,7 @@
 import importlib.util
 import os
 import sys
-import cv2
-import time
-import torch
-import numpy as np
-import gradio as gr
-from PIL import Image
-from torchvision import transforms
-import traceback
+
 
 # Check if detectron2 is installed
 if importlib.util.find_spec("detectron2") is None:
@@ -18,11 +11,23 @@ if importlib.util.find_spec("detectron2") is None:
     os.system("pip install git+https://github.com/facebookresearch/detectron2.git")
     print("Installation complete!")
 
+#!/usr/bin/env python3
+import os
+import sys
+import time
+import cv2
+import torch
+import numpy as np
+import gradio as gr
+from PIL import Image
+from torchvision import transforms
+import traceback
+
 # Add current directory to path
 if not os.getcwd() in sys.path:
     sys.path.append(os.getcwd())
 
-# Detectron2 imports - wrapped in try-except to make them optional
+# Check for detectron2
 try:
     from detectron2.engine import DefaultPredictor
     from detectron2.config import get_cfg
@@ -33,7 +38,7 @@ except ImportError:
     print("Warning: Detectron2 is not installed. Damage detection will not be available.")
     DETECTRON2_AVAILABLE = False
 
-# Check for custom path for models
+# Check for custom models
 try:
     from configs.get_config import load_config
     from models import *
@@ -42,16 +47,20 @@ except ImportError:
     print("Warning: Custom models couldn't be imported. Only damage detection will work.")
     MODELS_IMPORTED = False
 
-# Define the model paths at the beginning of your script
-DEFAULT_DAMAGE_MODEL_PATH = "./model_final.pth"  # Replace with your actual path
-DEFAULT_DEEPFAKE_MODEL_PATH = "./PoseEfficientNet_custom_laanet_model_final.pth"  # Replace with your actual path  
-DEFAULT_DEEPFAKE_CFG_PATH = "./configs/detector2.yaml"  # Replace with your actual path
+# Define model paths
+DEFAULT_DAMAGE_MODEL_PATH = "./model_final.pth"
+DEFAULT_DEEPFAKE_MODEL_PATH = "./PoseEfficientNet_custom_laanet_model_final.pth"
+DEFAULT_DEEPFAKE_CFG_PATH = "./configs/detector2.yaml"
+
+# Sample images for demo (add your own paths)
+SAMPLE_IMAGES = [
+    "./test3.png",
+    "./test5.png",
+
+]
 
 def verify_detectron2_installation():
-    """Verify that Detectron2 is properly installed and can access model zoo"""
-    import sys
-    import importlib.util
-    
+    """Verify that Detectron2 is properly installed"""
     results = {
         "detectron2_installed": False,
         "model_zoo_accessible": False,
@@ -59,88 +68,36 @@ def verify_detectron2_installation():
         "error_messages": []
     }
     
-    # Check if detectron2 is installed
     try:
+        import importlib.util
         if importlib.util.find_spec("detectron2") is not None:
             results["detectron2_installed"] = True
-            print("✅ Detectron2 is installed")
             
-            # Try importing detectron2
             try:
                 import detectron2
-                print(f"✅ Detectron2 version: {detectron2.__version__}")
-                
-                # Try accessing model zoo
-                try:
-                    from detectron2 import model_zoo
-                    # Try accessing a config file
-                    config_file = "COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"
-                    config_path = model_zoo.get_config_file(config_file)
-                    if os.path.exists(config_path):
-                        results["model_zoo_accessible"] = True
-                        print(f"✅ Model zoo is accessible, found config: {config_path}")
-                    else:
-                        results["error_messages"].append(f"Config file exists but cannot be accessed: {config_path}")
-                        print(f"❌ Config file exists but cannot be accessed: {config_path}")
-                except Exception as e:
-                    results["error_messages"].append(f"Error accessing model zoo: {str(e)}")
-                    print(f"❌ Error accessing model zoo: {str(e)}")
-                    traceback.print_exc()
-                
-                # Try creating a config
-                try:
-                    from detectron2.config import get_cfg
-                    cfg = get_cfg()
-                    results["can_create_cfg"] = True
-                    print("✅ Can create Detectron2 config")
-                    
-                    # Try setting up a model configuration
-                    try:
-                        cfg.merge_from_file(model_zoo.get_config_file(config_file))
-                        print("✅ Can load model configuration from model zoo")
-                        
-                        # Check if we can set up a default predictor (without actually creating it)
-                        try:
-                            from detectron2.engine import DefaultPredictor
-                            print("✅ DefaultPredictor class is available")
-                        except Exception as e:
-                            results["error_messages"].append(f"Error importing DefaultPredictor: {str(e)}")
-                            print(f"❌ Error importing DefaultPredictor: {str(e)}")
-                    except Exception as e:
-                        results["error_messages"].append(f"Error setting up model configuration: {str(e)}")
-                        print(f"❌ Error setting up model configuration: {str(e)}")
-                except Exception as e:
-                    results["error_messages"].append(f"Error creating Detectron2 config: {str(e)}")
-                    print(f"❌ Error creating Detectron2 config: {str(e)}")
+                from detectron2 import model_zoo
+                config_file = "COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"
+                config_path = model_zoo.get_config_file(config_file)
+                if os.path.exists(config_path):
+                    results["model_zoo_accessible"] = True
+            except Exception as e:
+                results["error_messages"].append(f"Error accessing model zoo: {str(e)}")
+            
+            try:
+                from detectron2.config import get_cfg
+                cfg = get_cfg()
+                results["can_create_cfg"] = True
             except Exception as e:
-                results["error_messages"].append(f"Error importing detectron2: {str(e)}")
-                print(f"❌ Error importing detectron2: {str(e)}")
+                results["error_messages"].append(f"Error creating Detectron2 config: {str(e)}")
         else:
             results["error_messages"].append("Detectron2 is not installed")
-            print("❌ Detectron2 is not installed")
     except Exception as e:
         results["error_messages"].append(f"Error checking Detectron2 installation: {str(e)}")
-        print(f"❌ Error checking Detectron2 installation: {str(e)}")
-    
-    # Print Python version and platform info
-    print(f"Python version: {sys.version}")
-    print(f"Platform: {sys.platform}")
-    
-    # Print PyTorch version if available
-    try:
-        import torch
-        print(f"PyTorch version: {torch.__version__}")
-        print(f"CUDA available: {torch.cuda.is_available()}")
-        if torch.cuda.is_available():
-            print(f"CUDA version: {torch.version.cuda}")
-            print(f"GPU: {torch.cuda.get_device_name(0)}")
-    except ImportError:
-        print("PyTorch is not installed")
     
     return results
 
 def setup_device(device_str):
-    """Set up the computation device based on user input and availability"""
+    """Set up the computation device"""
     if device_str == 'auto':
         if torch.cuda.is_available():
             return torch.device('cuda:0')
@@ -157,60 +114,30 @@ def setup_device(device_str):
         return torch.device('cpu')
 
 def setup_damage_detector(model_path, threshold=0.7):
-    """Set up the damage detection model using Detectron2 with enhanced error logging"""
+    """Set up the damage detection model"""
     if not DETECTRON2_AVAILABLE:
         print("Detectron2 is not installed. Cannot set up damage detector.")
         return None, None
     
-    try:    
-        print(f"Checking if damage model exists at path: {model_path}")
-        if model_path is None:
-            print("Error: No damage model path specified")
-            return None, None
-            
-        if not os.path.exists(model_path):
+    try:
+        if model_path is None or not os.path.exists(model_path):
             print(f"Error: Damage model file not found at {model_path}")
             return None, None
         
-        print("Model file exists, setting up configuration...")
         cfg = get_cfg()
-        print("Loading base config from model zoo...")
-        try:
-            cfg.merge_from_file(model_zoo.get_config_file("COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"))
-            print("Base config loaded successfully")
-        except Exception as e:
-            print(f"Error loading base config: {e}")
-            traceback.print_exc()
-            return None, None
-        
-        print(f"Setting model weights to: {model_path}")
+        cfg.merge_from_file(model_zoo.get_config_file("COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"))
         cfg.MODEL.WEIGHTS = model_path
         cfg.MODEL.ROI_HEADS.NUM_CLASSES = 1  # Only one class (damage)
         cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = threshold
         
-        # Explicitly set to use CPU if on Mac (MPS)
+        # Use CPU if on Mac (MPS)
         if hasattr(torch, 'backends') and hasattr(torch.backends, 'mps') and torch.backends.mps.is_available():
             cfg.MODEL.DEVICE = "cpu"
-            print("Mac MPS detected - forcing Detectron2 to use CPU")
-        
-        # Print configuration for debugging
-        print("Detectron2 configuration:")
-        print(f"- Model weights: {cfg.MODEL.WEIGHTS}")
-        print(f"- Number of classes: {cfg.MODEL.ROI_HEADS.NUM_CLASSES}")
-        print(f"- Score threshold: {cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST}")
-        print(f"- Device: {cfg.MODEL.DEVICE}")
-        
-        print("Creating predictor...")
-        try:
-            predictor = DefaultPredictor(cfg)
-            print("Predictor created successfully!")
-            return predictor, cfg
-        except Exception as e:
-            print(f"Error creating predictor: {e}")
-            traceback.print_exc()
-            return None, cfg
+        
+        predictor = DefaultPredictor(cfg)
+        return predictor, cfg
     except Exception as e:
-        print(f"Unexpected error in damage detector setup: {e}")
+        print(f"Error setting up damage detector: {e}")
         traceback.print_exc()
         return None, None
 
@@ -221,11 +148,11 @@ def load_deepfake_model(model_path, cfg_path, device):
         return None, None
         
     if model_path is None or not os.path.exists(model_path):
-        print("No deepfake model specified or file not found. Skipping deepfake detection.")
+        print(f"Error: Deepfake model file not found at {model_path}")
         return None, None
         
     if cfg_path is None or not os.path.exists(cfg_path):
-        print("No deepfake config specified or file not found. Skipping deepfake detection.")
+        print(f"Error: Deepfake config file not found at {cfg_path}")
         return None, None
         
     try:
@@ -236,7 +163,6 @@ def load_deepfake_model(model_path, cfg_path, device):
         model = build_model(cfg.MODEL, MODELS)
         
         # Load weights
-        print(f"Loading deepfake model from: {model_path}")
         checkpoint = torch.load(model_path, map_location='cpu')
         
         if isinstance(checkpoint, dict) and 'state_dict' in checkpoint:
@@ -259,7 +185,7 @@ def load_deepfake_model(model_path, cfg_path, device):
 def preprocess_for_deepfake(image, cfg, device):
     """Preprocess an image for deepfake detection"""
     try:
-        # Convert to RGB if needed
+        # Ensure image is RGB
         if len(image.shape) == 3 and image.shape[2] == 3:
             if image.dtype != np.uint8:
                 image = (image * 255).astype(np.uint8)
@@ -267,10 +193,10 @@ def preprocess_for_deepfake(image, cfg, device):
         else:
             rgb_img = image
             
-        # Resize
+        # Resize to match model input size
         img_resized = cv2.resize(rgb_img, (cfg.DATASET.IMAGE_SIZE[0], cfg.DATASET.IMAGE_SIZE[1]))
         
-        # Convert to PIL and apply transforms
+        # Apply transforms
         transform = transforms.Compose([
             transforms.ToTensor(),
             transforms.Normalize(
@@ -279,16 +205,16 @@ def preprocess_for_deepfake(image, cfg, device):
             )
         ])
         
-        img_tensor = transform(Image.fromarray(img_resized)).unsqueeze(0)  # Add batch dimension
+        img_tensor = transform(Image.fromarray(img_resized)).unsqueeze(0)
         img_tensor = img_tensor.to(device)
         
-        # Convert to correct precision
+        # Convert precision if needed
         if hasattr(cfg.MODEL, 'precision') and cfg.MODEL.precision == 'fp64':
             img_tensor = img_tensor.to(torch.float64)
             
         return img_tensor
     except Exception as e:
-        print(f"Error preprocessing image for deepfake detection: {e}")
+        print(f"Error preprocessing image: {e}")
         traceback.print_exc()
         return None
 
@@ -298,9 +224,8 @@ def detect_damage(img, damage_detector):
         if img is None:
             raise ValueError("Invalid image")
             
-        # If no damage detector available, return the whole image as region
+        # If no detector, use whole image
         if damage_detector is None:
-            print("No damage detector available. Using whole image as region.")
             h, w = img.shape[:2]
             damage_regions = [{
                 "box": (0, 0, w, h),
@@ -312,7 +237,7 @@ def detect_damage(img, damage_detector):
         # Run inference
         outputs = damage_detector(img)
         
-        # Get damage regions
+        # Get regions
         instances = outputs["instances"].to("cpu")
         boxes = instances.pred_boxes.tensor.numpy() if instances.has("pred_boxes") else []
         scores = instances.scores.numpy() if instances.has("scores") else []
@@ -327,8 +252,8 @@ def detect_damage(img, damage_detector):
                 "mask": masks[i] if len(masks) > i else None
             })
         
+        # If no regions found, use whole image
         if not damage_regions:
-            print("No damage detected. Using whole image.")
             h, w = img.shape[:2]
             damage_regions = [{
                 "box": (0, 0, w, h),
@@ -340,7 +265,8 @@ def detect_damage(img, damage_detector):
     except Exception as e:
         print(f"Error detecting damage: {e}")
         traceback.print_exc()
-        # If error occurs, return the whole image as region
+        
+        # Return whole image if error
         if 'img' in locals() and img is not None:
             h, w = img.shape[:2]
             damage_regions = [{
@@ -356,11 +282,10 @@ def check_deepfake(image, damage_regions, deepfake_model, deepfake_cfg, device,
     results = []
     
     if deepfake_model is None:
-        print("No deepfake model available. Skipping deepfake detection.")
         return []
     
     try:
-        # If no damage regions, check the entire image
+        # If no damage regions, check entire image
         if not damage_regions:
             img_tensor = preprocess_for_deepfake(image, deepfake_cfg, device)
             if img_tensor is None:
@@ -378,7 +303,6 @@ def check_deepfake(image, damage_regions, deepfake_model, deepfake_cfg, device,
                     cls_outputs = outputs['cls']
                     cls_prob = cls_outputs.sigmoid().cpu().numpy()
                 else:
-                    # Assuming the output is directly the classification probability
                     cls_prob = outputs.sigmoid().cpu().numpy() if hasattr(outputs, 'sigmoid') else outputs.cpu().numpy()
                 
                 if cls_prob.size > 0:
@@ -396,13 +320,12 @@ def check_deepfake(image, damage_regions, deepfake_model, deepfake_cfg, device,
         # Process each damage region
         for i, region in enumerate(damage_regions):
             x1, y1, x2, y2 = region["box"]
-            # Ensure coordinates are within image bounds
             x1, y1 = max(0, x1), max(0, y1)
             x2, y2 = min(image.shape[1], x2), min(image.shape[0], y2)
             
-            # Extract region and check if it's a deepfake
+            # Only process valid regions
             if x2 > x1 and y2 > y1:
-                # Get ROI
+                # Extract region
                 roi = image[y1:y2, x1:x2]
                 
                 # Preprocess
@@ -410,11 +333,10 @@ def check_deepfake(image, damage_regions, deepfake_model, deepfake_cfg, device,
                 if img_tensor is None:
                     continue
                 
-                # Run inference
+                # Inference
                 with torch.no_grad():
                     outputs = deepfake_model(img_tensor)
                     
-                    # Extract outputs
                     if isinstance(outputs, list):
                         outputs = outputs[0]
                     
@@ -422,7 +344,6 @@ def check_deepfake(image, damage_regions, deepfake_model, deepfake_cfg, device,
                         cls_outputs = outputs['cls']
                         cls_prob = cls_outputs.sigmoid().cpu().numpy()
                     else:
-                        # Assuming the output is directly the classification probability
                         cls_prob = outputs.sigmoid().cpu().numpy() if hasattr(outputs, 'sigmoid') else outputs.cpu().numpy()
                     
                     if cls_prob.size > 0:
@@ -443,42 +364,39 @@ def check_deepfake(image, damage_regions, deepfake_model, deepfake_cfg, device,
         return []
 
 def visualize_results(image, damage_outputs, deepfake_results, damage_threshold):
-    """Create visualization of damage detection and deepfake verification"""
+    """Create visualization of results"""
     try:
-        # Create a copy for visualization
         img_copy = image.copy()
         
-        # Draw damage detection results
+        # Draw damage detection
         if damage_outputs is not None and DETECTRON2_AVAILABLE:
             try:
                 v = Visualizer(img_copy[:, :, ::-1], scale=1.0, instance_mode=ColorMode.IMAGE_BW)
                 v = v.draw_instance_predictions(damage_outputs["instances"].to("cpu"))
                 result_img = v.get_image()[:, :, ::-1]
-                
-                # Convert to a standard numpy array to ensure compatibility with OpenCV
                 result_img = np.array(result_img, dtype=np.uint8)
             except Exception as e:
-                print(f"Error visualizing damage detection: {e}")
+                print(f"Error visualizing damage: {e}")
                 result_img = img_copy
         else:
             result_img = img_copy
         
-        # Add deepfake detection results
+        # Add deepfake results
         for result in deepfake_results:
             try:
                 if "box" in result:
                     x1, y1, x2, y2 = result["box"]
-                    fake_prob = result["deepfake_prob"] 
+                    fake_prob = result["deepfake_prob"]
                     is_fake = result["is_fake"]
                     region_id = result.get("region_id", 0)
                     
-                    # Text for the region
+                    # Status text
                     text = f"R{region_id}: {'FAKE' if is_fake else 'REAL'} ({fake_prob*100:.1f}%)"
                     
-                    # Different colors for fake/real
-                    color = (0, 0, 255) if is_fake else (0, 255, 0)  # Red for fake, green for real
+                    # Red for fake, green for real
+                    color = (0, 0, 255) if is_fake else (0, 255, 0)
                     
-                    # Ensure we have a standard numpy array
+                    # Ensure standard numpy array
                     if not isinstance(result_img, np.ndarray):
                         result_img = np.array(result_img, dtype=np.uint8)
                     
@@ -489,71 +407,53 @@ def visualize_results(image, damage_outputs, deepfake_results, damage_threshold)
                     fake_prob = result["deepfake_prob"]
                     is_fake = result["is_fake"]
                     
-                    # Text for the whole image
                     text = f"Image: {'FAKE' if is_fake else 'REAL'} ({fake_prob*100:.1f}%)"
+                    color = (0, 0, 255) if is_fake else (0, 255, 0)
                     
-                    # Different colors for fake/real
-                    color = (0, 0, 255) if is_fake else (0, 255, 0)  # Red for fake, green for real
-                    
-                    # Ensure we have a standard numpy array
                     if not isinstance(result_img, np.ndarray):
                         result_img = np.array(result_img, dtype=np.uint8)
                     
-                    # Draw text
                     cv2.putText(result_img, text, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, color, 2)
             except Exception as e:
-                print(f"Error drawing result {result}: {e}")
+                print(f"Error drawing result: {e}")
         
         return result_img
     except Exception as e:
-        print(f"Error visualizing results: {e}")
+        print(f"Error in visualization: {e}")
         traceback.print_exc()
-        return np.array(image, dtype=np.uint8)  # Return the original image as a numpy array
+        return np.array(image, dtype=np.uint8)
 
 def process_image(input_image, damage_model_path, deepfake_model_path, deepfake_cfg_path, 
                  damage_threshold, deepfake_threshold, skip_damage, device_str):
-    """Process an image through the car damage and deepfake detection pipeline with enhanced error handling"""
+    """Process an image through the detection pipeline"""
     progress_info = []
     
-    # Print all input paths for debugging
-    progress_info.append(f"Input parameters:")
-    progress_info.append(f"- Damage model path: {damage_model_path}")
-    progress_info.append(f"- Deepfake model path: {deepfake_model_path}")
-    progress_info.append(f"- Deepfake config path: {deepfake_cfg_path}")
-    progress_info.append(f"- Damage threshold: {damage_threshold}")
-    progress_info.append(f"- Deepfake threshold: {deepfake_threshold}")
-    progress_info.append(f"- Skip damage detection: {skip_damage}")
-    progress_info.append(f"- Device: {device_str}")
+    # Debug: log input parameters
+    progress_info.append(f"Processing with:")
+    progress_info.append(f"- Damage model: {damage_model_path}")
+    progress_info.append(f"- Deepfake model: {deepfake_model_path}")
+    progress_info.append(f"- Config: {deepfake_cfg_path}")
+    progress_info.append(f"- Thresholds: Damage={damage_threshold}, Deepfake={deepfake_threshold}")
     
-    # Check if model files exist
+    # Check model files
     if not skip_damage and damage_model_path:
-        if os.path.exists(damage_model_path):
-            progress_info.append(f"Damage model file exists at: {damage_model_path}")
-        else:
-            progress_info.append(f"ERROR: Damage model file NOT FOUND at: {damage_model_path}")
+        if not os.path.exists(damage_model_path):
+            progress_info.append(f"ERROR: Damage model not found at {damage_model_path}")
     
-    if deepfake_model_path:
-        if os.path.exists(deepfake_model_path):
-            progress_info.append(f"Deepfake model file exists at: {deepfake_model_path}")
-        else:
-            progress_info.append(f"ERROR: Deepfake model file NOT FOUND at: {deepfake_model_path}")
+    if deepfake_model_path and not os.path.exists(deepfake_model_path):
+        progress_info.append(f"ERROR: Deepfake model not found at {deepfake_model_path}")
     
-    if deepfake_cfg_path:
-        if os.path.exists(deepfake_cfg_path):
-            progress_info.append(f"Deepfake config file exists at: {deepfake_cfg_path}")
-        else:
-            progress_info.append(f"ERROR: Deepfake config file NOT FOUND at: {deepfake_cfg_path}")
+    if deepfake_cfg_path and not os.path.exists(deepfake_cfg_path):
+        progress_info.append(f"ERROR: Config not found at {deepfake_cfg_path}")
     
-    # Convert Gradio image to numpy array
+    # Convert image to proper format
     try:
         if isinstance(input_image, dict) and "path" in input_image:
             img = cv2.imread(input_image["path"])
         elif isinstance(input_image, str):
             img = cv2.imread(input_image)
         elif isinstance(input_image, np.ndarray):
-            # Make a copy to avoid modifying the original
             img = input_image.copy()
-            # Convert from RGB to BGR (OpenCV format)
             if len(img.shape) == 3 and img.shape[2] == 3:
                 img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
         else:
@@ -562,324 +462,422 @@ def process_image(input_image, damage_model_path, deepfake_model_path, deepfake_
         if img is None:
             return None, "Error: Could not read the image"
     except Exception as e:
-        error_trace = traceback.format_exc()
-        return None, f"Error loading image: {str(e)}\n{error_trace}"
+        return None, f"Error loading image: {str(e)}"
     
-    # Progress update
     progress_info.append("Image loaded successfully")
     
     # Setup device
-    try:
-        device = setup_device(device_str)
-        progress_info.append(f"Using device: {device}")
-    except Exception as e:
-        error_trace = traceback.format_exc()
-        progress_info.append(f"Error setting up device: {str(e)}\n{error_trace}")
-        device = torch.device('cpu')
-        progress_info.append(f"Falling back to CPU")
+    device = setup_device(device_str)
+    progress_info.append(f"Using device: {device}")
     
     # Initialize models
     damage_detector = None
     deepfake_model = None
     deepfake_cfg = None
     
-    # Check Detectron2 availability
-    if not skip_damage:
-        progress_info.append(f"Detectron2 available: {DETECTRON2_AVAILABLE}")
-        
-        if not DETECTRON2_AVAILABLE:
-            progress_info.append("Warning: Detectron2 is not available. Install with:")
-            progress_info.append("pip install torch torchvision --extra-index-url https://download.pytorch.org/whl/cpu")
-            progress_info.append("pip install git+https://github.com/facebookresearch/detectron2.git")
-    
-    # Setup damage detector if not skipped
+    # Setup damage detector
     if not skip_damage and damage_model_path:
         progress_info.append("Setting up damage detector...")
-        try:
-            damage_detector, detector_cfg = setup_damage_detector(damage_model_path, float(damage_threshold))
-            if damage_detector is None and DETECTRON2_AVAILABLE:
-                progress_info.append("Failed to initialize damage detector")
-            else:
-                progress_info.append("Damage detector initialized successfully")
-        except Exception as e:
-            error_trace = traceback.format_exc()
-            progress_info.append(f"Error in damage detector setup: {str(e)}\n{error_trace}")
+        damage_detector, _ = setup_damage_detector(damage_model_path, float(damage_threshold))
+        if damage_detector is None:
+            progress_info.append("Warning: Failed to initialize damage detector")
+        else:
+            progress_info.append("Damage detector ready")
     
     # Setup deepfake detector
     if deepfake_model_path and deepfake_cfg_path:
         progress_info.append("Setting up deepfake detector...")
-        try:
-            deepfake_model, deepfake_cfg = load_deepfake_model(deepfake_model_path, deepfake_cfg_path, device)
-            if deepfake_model is None:
-                progress_info.append("Failed to initialize deepfake detector")
-            else:
-                progress_info.append("Deepfake detector initialized successfully")
-        except Exception as e:
-            error_trace = traceback.format_exc()
-            progress_info.append(f"Error in deepfake detector setup: {str(e)}\n{error_trace}")
+        deepfake_model, deepfake_cfg = load_deepfake_model(deepfake_model_path, deepfake_cfg_path, device)
+        if deepfake_model is None:
+            progress_info.append("Warning: Failed to initialize deepfake detector")
+        else:
+            progress_info.append("Deepfake detector ready")
     
-    # Ensure at least one detector is working
+    # Check if we have at least one working detector
     if damage_detector is None and deepfake_model is None:
-        return None, "\n".join(progress_info) + "\nError: Neither damage nor deepfake detector is available"
+        return None, "\n".join(progress_info) + "\nError: No working detectors available"
     
-    # Step 1: Detect damage or use whole image
+    # Step 1: Detect damage
     progress_info.append("Detecting damage regions...")
     start_time = time.time()
-    try:
-        img, damage_outputs, damage_regions = detect_damage(img, damage_detector)
-        damage_time = time.time() - start_time
-    except Exception as e:
-        error_trace = traceback.format_exc()
-        progress_info.append(f"Error in damage detection: {str(e)}\n{error_trace}")
-        h, w = img.shape[:2]
-        damage_regions = [{
-            "box": (0, 0, w, h),
-            "score": 1.0,
-            "mask": None
-        }]
-        damage_outputs = None
-        damage_time = time.time() - start_time
-    
-    if img is None:
-        return None, "\n".join(progress_info) + "\nError: Failed to process image"
+    img, damage_outputs, damage_regions = detect_damage(img, damage_detector)
+    damage_time = time.time() - start_time
     
-    # Print damage detection results
-    if damage_detector is not None and damage_regions:
-        progress_info.append(f"Detected {len(damage_regions)} damage regions in {damage_time:.3f} seconds")
+    if damage_regions:
+        progress_info.append(f"Found {len(damage_regions)} damage regions in {damage_time:.2f}s")
     else:
-        progress_info.append("Using the whole image for analysis")
+        progress_info.append("No damage regions found, analyzing whole image")
     
-    # Step 2: Check if damage is deepfake
+    # Step 2: Check for deepfakes
     deepfake_results = []
     if deepfake_model is not None:
-        progress_info.append("Performing deepfake detection...")
+        progress_info.append("Checking for deepfakes...")
         start_time = time.time()
-        try:
-            deepfake_results = check_deepfake(
-                img, damage_regions, deepfake_model, deepfake_cfg, device, float(deepfake_threshold)
-            )
-            deepfake_time = time.time() - start_time
+        deepfake_results = check_deepfake(
+            img, damage_regions, deepfake_model, deepfake_cfg, device, float(deepfake_threshold)
+        )
+        deepfake_time = time.time() - start_time
+        
+        if deepfake_results:
+            progress_info.append(f"Deepfake analysis completed in {deepfake_time:.2f}s")
             
-            if deepfake_results:
-                progress_info.append(f"Deepfake detection completed in {deepfake_time:.3f} seconds")
-                
-                # Generate report
-                for result in deepfake_results:
-                    if "region_id" in result:
-                        region_id = result["region_id"]
-                        fake_prob = result["deepfake_prob"]
-                        is_fake = result["is_fake"]
-                        progress_info.append(f"Region {region_id}: {'FAKE' if is_fake else 'REAL'} (Probability: {fake_prob*100:.2f}%)")
-                    elif "region" in result and result["region"] == "full_image":
-                        fake_prob = result["deepfake_prob"]
-                        is_fake = result["is_fake"]
-                        progress_info.append(f"Whole image: {'FAKE' if is_fake else 'REAL'} (Probability: {fake_prob*100:.2f}%)")
-            else:
-                progress_info.append("No deepfake detection results")
-        except Exception as e:
-            error_trace = traceback.format_exc()
-            progress_info.append(f"Error in deepfake detection: {str(e)}\n{error_trace}")
+            # Generate report
+            for result in deepfake_results:
+                if "region_id" in result:
+                    region_id = result["region_id"]
+                    fake_prob = result["deepfake_prob"]
+                    is_fake = result["is_fake"]
+                    progress_info.append(f"Region {region_id}: {'⚠️ FAKE' if is_fake else '✅ REAL'} ({fake_prob*100:.2f}%)")
+                elif "region" in result and result["region"] == "full_image":
+                    fake_prob = result["deepfake_prob"]
+                    is_fake = result["is_fake"]
+                    progress_info.append(f"Whole image: {'⚠️ FAKE' if is_fake else '✅ REAL'} ({fake_prob*100:.2f}%)")
+        else:
+            progress_info.append("No deepfake detection results")
     
-    # Step 3: Visualize final results
+    # Step 3: Visualize results
     progress_info.append("Generating visualization...")
-    try:
-        result_img = visualize_results(img, damage_outputs, deepfake_results, float(damage_threshold))
-        
-        # Convert back to RGB for Gradio
-        if len(result_img.shape) == 3 and result_img.shape[2] == 3:
-            result_img = cv2.cvtColor(result_img, cv2.COLOR_BGR2RGB)
-    except Exception as e:
-        error_trace = traceback.format_exc()
-        progress_info.append(f"Error in visualization: {str(e)}\n{error_trace}")
-        # Return original image if visualization fails
-        result_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) if len(img.shape) == 3 and img.shape[2] == 3 else img
+    result_img = visualize_results(img, damage_outputs, deepfake_results, float(damage_threshold))
     
-    progress_info.append("Processing complete!")
+    # Convert back to RGB for Gradio
+    if len(result_img.shape) == 3 and result_img.shape[2] == 3:
+        result_img = cv2.cvtColor(result_img, cv2.COLOR_BGR2RGB)
+    
+    progress_info.append("✅ Analysis complete!")
     
     return result_img, "\n".join(progress_info)
 
+def auto_install_dependencies():
+    """Attempt to install dependencies if needed"""
+    try:
+        import importlib.util
+        
+        # Check for PyTorch
+        if importlib.util.find_spec("torch") is None:
+            print("Installing PyTorch...")
+            os.system("pip install torch torchvision --extra-index-url https://download.pytorch.org/whl/cpu")
+        
+        # Check for Detectron2
+        if importlib.util.find_spec("detectron2") is None:
+            print("Installing Detectron2...")
+            os.system("pip install git+https://github.com/facebookresearch/detectron2.git")
+        
+        # Check for Gradio
+        if importlib.util.find_spec("gradio") is None:
+            print("Installing Gradio...")
+            os.system("pip install gradio")
+        
+        print("Dependencies installation complete!")
+        return True
+    except Exception as e:
+        print(f"Error installing dependencies: {e}")
+        return False
+
 def create_gradio_interface():
-    with gr.Blocks(title="Car Damage & Deepfake Detection") as app:
-        gr.Markdown("# Car Damage Detection & Deepfake Verification")
-        gr.Markdown("Upload an image to detect car damage and check if it's a deepfake")
+    # Define a theme
+    theme = gr.themes.Soft(
+        primary_hue="blue",
+        secondary_hue="orange",
+    )
+    
+    with gr.Blocks(title="Car Damage & Deepfake Detector", theme=theme) as app:
+        gr.Markdown("""
+        # 🚗 Car Damage & Deepfake Detector
+        
+        Upload a car image to:
+        1. Detect damaged areas
+        2. Verify if the damage is real or artificially generated (deepfake)
+        
+        *This app requires both damage detection and deepfake models to be installed.*
+        """)
+        
+        # System status indicator
+        with gr.Row():
+            damage_model_status = gr.Label(label="Damage Model", value="Checking...", elem_id="damage-status")
+            deepfake_model_status = gr.Label(label="Deepfake Model", value="Checking...", elem_id="deepfake-status")
+            detectron2_status = gr.Label(label="Detectron2", value="Checking...", elem_id="detectron2-status")
         
-        # Add a diagnostic tab
-        with gr.Tab("Diagnostics"):
+        # Update system status
+        def update_system_status():
+            status = {
+                "damage_model": "Not Found",
+                "deepfake_model": "Not Found",
+                "deepfake_cfg": "Not Found",
+                "detectron2": "Not Installed"
+            }
+            
+            # Check model files
+            if os.path.exists(DEFAULT_DAMAGE_MODEL_PATH):
+                status["damage_model"] = "Available ✅"
+            else:
+                status["damage_model"] = "Not Found ❌"
+            
+            if os.path.exists(DEFAULT_DEEPFAKE_MODEL_PATH):
+                status["deepfake_model"] = "Available ✅"
+            else:
+                status["deepfake_model"] = "Not Found ❌"
+                
+            if os.path.exists(DEFAULT_DEEPFAKE_CFG_PATH):
+                status["deepfake_cfg"] = "Available ✅"
+            else:
+                status["deepfake_cfg"] = "Not Found ❌"
+            
+            # Check Detectron2
+            if DETECTRON2_AVAILABLE:
+                status["detectron2"] = "Installed ✅"
+            else:
+                status["detectron2"] = "Not Installed ❌"
+                
+            return status["damage_model"], status["deepfake_model"], status["detectron2"]
+        
+        # Main Interface Tab
+        with gr.Tab("Analyze Image"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    input_image = gr.Image(type="numpy", label="Upload Car Image")
+                    
+                    with gr.Row():
+                        process_btn = gr.Button("Analyze Image", variant="primary")
+                        clear_btn = gr.Button("Clear", variant="secondary")
+                    
+                    with gr.Accordion("Advanced Settings", open=False):
+                        skip_damage = gr.Checkbox(label="Skip Damage Detection", value=False)
+                        damage_threshold = gr.Slider(minimum=0.1, maximum=1.0, value=0.7, step=0.05,
+                                                   label="Damage Detection Threshold")
+                        deepfake_threshold = gr.Slider(minimum=0.1, maximum=1.0, value=0.5, step=0.05,
+                                                     label="Deepfake Detection Threshold")
+                        device = gr.Dropdown(choices=["auto", "cuda", "cpu", "mps"], value="auto",
+                                            label="Computation Device")
+                        
+                with gr.Column(scale=1):
+                    output_image = gr.Image(type="numpy", label="Analysis Result")
+                    
+                    # Analysis info with nice formatting
+                    with gr.Accordion("Analysis Details", open=True):
+                        output_text = gr.Markdown(label="Detection Results")
+        
+        # Diagnostics Tab
+        with gr.Tab("System Diagnostics"):
             with gr.Row():
-                run_diagnostic_btn = gr.Button("Run Detectron2 Diagnostics", variant="primary")
-                diagnostic_output = gr.Textbox(label="Diagnostic Results", lines=20)
+                run_diagnostic_btn = gr.Button("Run Diagnostics", variant="primary")
+                install_deps_btn = gr.Button("Install Dependencies", variant="secondary")
+                
+            diagnostic_output = gr.Markdown(label="Diagnostic Results")
             
-            # Function to run diagnostics
+            # Function to run system diagnostics
             def run_diagnostics():
-                results = verify_detectron2_installation()
+                detectron2_results = verify_detectron2_installation()
                 
-                # Check model paths
-                output_lines = ["# System Diagnostics", ""]
+                output = ["## System Diagnostics\n"]
                 
-                # Check damage model
+                # Python & PyTorch versions
+                import sys
+                output.append(f"**Python:** {sys.version.split()[0]}")
+                
+                try:
+                    import torch
+                    output.append(f"**PyTorch:** {torch.__version__}")
+                    output.append(f"**CUDA Available:** {'Yes ✅' if torch.cuda.is_available() else 'No ❌'}")
+                    if torch.cuda.is_available():
+                        output.append(f"**GPU:** {torch.cuda.get_device_name(0)}")
+                except ImportError:
+                    output.append("**PyTorch:** Not installed ❌")
+                
+                output.append("\n## Model Files")
+                
+                # Check model files
                 if os.path.exists(DEFAULT_DAMAGE_MODEL_PATH):
                     file_size = os.path.getsize(DEFAULT_DAMAGE_MODEL_PATH) / (1024 * 1024)  # Size in MB
-                    output_lines.append(f"✅ Damage model exists: {DEFAULT_DAMAGE_MODEL_PATH} ({file_size:.2f} MB)")
+                    output.append(f"**Damage Model:** Available ✅ ({file_size:.2f} MB)")
                 else:
-                    output_lines.append(f"❌ Damage model NOT found: {DEFAULT_DAMAGE_MODEL_PATH}")
+                    output.append(f"**Damage Model:** Not found ❌ at {DEFAULT_DAMAGE_MODEL_PATH}")
                 
-                # Check deepfake model
                 if os.path.exists(DEFAULT_DEEPFAKE_MODEL_PATH):
                     file_size = os.path.getsize(DEFAULT_DEEPFAKE_MODEL_PATH) / (1024 * 1024)  # Size in MB
-                    output_lines.append(f"✅ Deepfake model exists: {DEFAULT_DEEPFAKE_MODEL_PATH} ({file_size:.2f} MB)")
+                    output.append(f"**Deepfake Model:** Available ✅ ({file_size:.2f} MB)")
                 else:
-                    output_lines.append(f"❌ Deepfake model NOT found: {DEFAULT_DEEPFAKE_MODEL_PATH}")
+                    output.append(f"**Deepfake Model:** Not found ❌ at {DEFAULT_DEEPFAKE_MODEL_PATH}")
                 
-                # Check deepfake config
                 if os.path.exists(DEFAULT_DEEPFAKE_CFG_PATH):
-                    output_lines.append(f"✅ Deepfake config exists: {DEFAULT_DEEPFAKE_CFG_PATH}")
+                    output.append(f"**Deepfake Config:** Available ✅")
                 else:
-                    output_lines.append(f"❌ Deepfake config NOT found: {DEFAULT_DEEPFAKE_CFG_PATH}")
-                
-                # Add Detectron2 status
-                output_lines.append("")
-                output_lines.append("# Detectron2 Status")
-                output_lines.append(f"Detectron2 installed: {'✅' if results['detectron2_installed'] else '❌'}")
-                output_lines.append(f"Model zoo accessible: {'✅' if results['model_zoo_accessible'] else '❌'}")
-                output_lines.append(f"Can create config: {'✅' if results['can_create_cfg'] else '❌'}")
-                
-                if results['error_messages']:
-                    output_lines.append("")
-                    output_lines.append("# Error Messages")
-                    for error in results['error_messages']:
-                        output_lines.append(f"- {error}")
-                
-                # Try to load a small sample model from model zoo
-                output_lines.append("")
-                output_lines.append("# Test Loading Detectron2 Model")
-                try:
-                    from detectron2 import model_zoo
-                    from detectron2.config import get_cfg
-                    from detectron2.engine import DefaultPredictor
-                    
-                    cfg = get_cfg()
-                    cfg.merge_from_file(model_zoo.get_config_file("COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"))
-                    
-                    # Try to access a pre-trained model (without downloading it)
-                    model_url = model_zoo.get_checkpoint_url("COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml")
-                    output_lines.append(f"✅ Can access pre-trained model URL: {model_url}")
-                    
-                    # Check if we can see the damage model contents
-                    if os.path.exists(DEFAULT_DAMAGE_MODEL_PATH):
-                        try:
-                            import torch
-                            # Try to load just the metadata without loading the whole model
-                            checkpoint = torch.load(DEFAULT_DAMAGE_MODEL_PATH, map_location='cpu')
-                            if isinstance(checkpoint, dict):
-                                output_lines.append("✅ Successfully loaded damage model metadata")
-                                # Check some basic keys in the checkpoint
-                                keys = list(checkpoint.keys())
-                                output_lines.append(f"Model keys: {keys[:5]}...")
-                            else:
-                                output_lines.append("⚠️ Damage model loaded but has unexpected format")
-                        except Exception as e:
-                            output_lines.append(f"❌ Failed to load damage model: {str(e)}")
-                except Exception as e:
-                    output_lines.append(f"❌ Error in test loading: {str(e)}")
+                    output.append(f"**Deepfake Config:** Not found ❌ at {DEFAULT_DEEPFAKE_CFG_PATH}")
+                
+                output.append("\n## Detectron2 Status")
+                output.append(f"**Installed:** {'Yes ✅' if detectron2_results['detectron2_installed'] else 'No ❌'}")
+                output.append(f"**Model Zoo Access:** {'Yes ✅' if detectron2_results['model_zoo_accessible'] else 'No ❌'}")
+                output.append(f"**Config Creation:** {'Yes ✅' if detectron2_results['can_create_cfg'] else 'No ❌'}")
                 
-                # Recommendation section
-                output_lines.append("")
-                output_lines.append("# Recommendations")
+                if detectron2_results['error_messages']:
+                    output.append("\n## Error Messages")
+                    for error in detectron2_results['error_messages']:
+                        output.append(f"- {error}")
                 
-                if not results['detectron2_installed']:
-                    output_lines.append("- Install Detectron2: `pip install torch torchvision --extra-index-url https://download.pytorch.org/whl/cpu`")
-                    output_lines.append("- Then: `pip install git+https://github.com/facebookresearch/detectron2.git`")
+                output.append("\n## Recommendations")
+                recommendations = []
+                
+                if not detectron2_results['detectron2_installed']:
+                    recommendations.append("Install Detectron2: `pip install torch torchvision --extra-index-url https://download.pytorch.org/whl/cpu`")
+                    recommendations.append("Then: `pip install git+https://github.com/facebookresearch/detectron2.git`")
                 
                 if not os.path.exists(DEFAULT_DAMAGE_MODEL_PATH):
-                    output_lines.append(f"- Place the damage model file at: {DEFAULT_DAMAGE_MODEL_PATH}")
+                    recommendations.append(f"Place the damage model file at: {DEFAULT_DAMAGE_MODEL_PATH}")
+                
+                if not os.path.exists(DEFAULT_DEEPFAKE_MODEL_PATH):
+                    recommendations.append(f"Place the deepfake model file at: {DEFAULT_DEEPFAKE_MODEL_PATH}")
+                
+                if not os.path.exists(DEFAULT_DEEPFAKE_CFG_PATH):
+                    recommendations.append(f"Place the deepfake config file at: {DEFAULT_DEEPFAKE_CFG_PATH}")
                 
-                if results['detectron2_installed'] and not results['model_zoo_accessible']:
-                    output_lines.append("- Detectron2 is installed but model zoo is not accessible. Check your internet connection.")
-                    output_lines.append("- Try reinstalling Detectron2")
+                if recommendations:
+                    for rec in recommendations:
+                        output.append(f"- {rec}")
+                else:
+                    output.append("- All systems are ready! 🎉")
                 
-                return "\n".join(output_lines)
+                return "\n".join(output)
             
-            # Connect the diagnostic button
-            run_diagnostic_btn.click(fn=run_diagnostics, inputs=[], outputs=diagnostic_output)
-        
-        with gr.Tab("Basic Interface"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    input_image = gr.Image(type="numpy", label="Input Image")
-                    
-                    # Simple controls
-                    skip_damage = gr.Checkbox(label="Skip Damage Detection", value=False)
-                    damage_threshold = gr.Slider(minimum=0.1, maximum=1.0, value=0.7, step=0.05, 
-                                               label="Damage Detection Threshold")
-                    deepfake_threshold = gr.Slider(minimum=0.1, maximum=1.0, value=0.5, step=0.05,
-                                                 label="Deepfake Detection Threshold")
-                    device = gr.Dropdown(choices=["auto", "cuda", "cpu", "mps"], value="auto", 
-                                        label="Computation Device")
-                    
-                    process_btn = gr.Button("Process Image", variant="primary")
-                    
-                with gr.Column(scale=1):
-                    output_image = gr.Image(type="numpy", label="Result")
-                    output_text = gr.Textbox(label="Detection Results", lines=10)
+            # Function to install dependencies
+            def install_dependencies():
+                output = ["## Installing Dependencies\n"]
+                
+                # Try to install PyTorch
+                output.append("Installing PyTorch...")
+                try:
+                    import importlib.util
+                    if importlib.util.find_spec("torch") is None:
+                        os.system("pip install torch torchvision --extra-index-url https://download.pytorch.org/whl/cpu")
+                        output.append("✅ PyTorch installed")
+                    else:
+                        output.append("✅ PyTorch already installed")
+                except Exception as e:
+                    output.append(f"❌ Error installing PyTorch: {str(e)}")
+                
+                # Try to install Detectron2
+                output.append("\nInstalling Detectron2...")
+                try:
+                    if importlib.util.find_spec("detectron2") is None:
+                        os.system("pip install git+https://github.com/facebookresearch/detectron2.git")
+                        output.append("✅ Detectron2 installed")
+                    else:
+                        output.append("✅ Detectron2 already installed")
+                except Exception as e:
+                    output.append(f"❌ Error installing Detectron2: {str(e)}")
+                
+                output.append("\n**Note:** You may need to restart the application for changes to take effect.")
+                
+                return "\n".join(output)
+                
+        # Settings Tab
+        with gr.Tab("Settings"):
+            gr.Markdown("## Model Settings")
             
-        with gr.Tab("Advanced Settings"):
             with gr.Row():
                 with gr.Column():
-                    damage_model_path = gr.Textbox(label="Damage Model Path", 
-                                                 value=DEFAULT_DAMAGE_MODEL_PATH,
-                                                 placeholder="Path to damage detection model (.pth)")
-                    deepfake_model_path = gr.Textbox(label="Deepfake Model Path", 
-                                                   value=DEFAULT_DEEPFAKE_MODEL_PATH,
-                                                   placeholder="Path to deepfake detection model (.pth)")
-                    deepfake_cfg_path = gr.Textbox(label="Deepfake Config Path", 
-                                                 value=DEFAULT_DEEPFAKE_CFG_PATH,
-                                                 placeholder="Path to deepfake model config (.yaml)")
-                    
-                    # Add a check model paths button
-                    check_paths_btn = gr.Button("Check Model Paths")
-                    paths_result = gr.Textbox(label="Path Check Results", lines=5)
+                    custom_damage_model = gr.Textbox(
+                        label="Custom Damage Model Path",
+                        value=DEFAULT_DAMAGE_MODEL_PATH,
+                        placeholder="Path to damage detection model (.pth)"
+                    )
                     
-                    # Function to check if model paths exist
-                    def check_model_paths(damage_path, deepfake_path, cfg_path):
-                        results = []
-                        
-                        # Check damage model
-                        if os.path.exists(damage_path):
-                            file_size = os.path.getsize(damage_path) / (1024 * 1024)  # Size in MB
-                            results.append(f"✅ Damage model exists: {damage_path} ({file_size:.2f} MB)")
-                        else:
-                            results.append(f"❌ Damage model NOT found: {damage_path}")
-                        
-                        # Check deepfake model
-                        if os.path.exists(deepfake_path):
-                            file_size = os.path.getsize(deepfake_path) / (1024 * 1024)  # Size in MB
-                            results.append(f"✅ Deepfake model exists: {deepfake_path} ({file_size:.2f} MB)")
-                        else:
-                            results.append(f"❌ Deepfake model NOT found: {deepfake_path}")
-                        
-                        # Check deepfake config
-                        if os.path.exists(cfg_path):
-                            results.append(f"✅ Deepfake config exists: {cfg_path}")
-                        else:
-                            results.append(f"❌ Deepfake config NOT found: {cfg_path}")
-                        
-                        return "\n".join(results)
+                    custom_deepfake_model = gr.Textbox(
+                        label="Custom Deepfake Model Path",
+                        value=DEFAULT_DEEPFAKE_MODEL_PATH,
+                        placeholder="Path to deepfake detection model (.pth)"
+                    )
                     
-                    # Connect the check paths button
-                    check_paths_btn.click(
-                        fn=check_model_paths, 
-                        inputs=[damage_model_path, deepfake_model_path, deepfake_cfg_path],
-                        outputs=paths_result
+                    custom_deepfake_cfg = gr.Textbox(
+                        label="Custom Deepfake Config Path",
+                        value=DEFAULT_DEEPFAKE_CFG_PATH,
+                        placeholder="Path to deepfake model config (.yaml)"
                     )
+                    
+                    check_paths_btn = gr.Button("Verify Paths", variant="primary")
+                
+                with gr.Column():
+                    paths_result = gr.Markdown(label="Path Verification Results")
+            
+            # Function to check model paths
+            def check_model_paths(damage_path, deepfake_path, cfg_path):
+                output = ["## Path Verification Results\n"]
+                
+                # Check damage model
+                if os.path.exists(damage_path):
+                    file_size = os.path.getsize(damage_path) / (1024 * 1024)  # Size in MB
+                    output.append(f"✅ **Damage model:** Found at {damage_path} ({file_size:.2f} MB)")
+                else:
+                    output.append(f"❌ **Damage model:** NOT found at {damage_path}")
+                
+                # Check deepfake model
+                if os.path.exists(deepfake_path):
+                    file_size = os.path.getsize(deepfake_path) / (1024 * 1024)  # Size in MB
+                    output.append(f"✅ **Deepfake model:** Found at {deepfake_path} ({file_size:.2f} MB)")
+                else:
+                    output.append(f"❌ **Deepfake model:** NOT found at {deepfake_path}")
+                
+                # Check deepfake config
+                if os.path.exists(cfg_path):
+                    output.append(f"✅ **Deepfake config:** Found at {cfg_path}")
+                else:
+                    output.append(f"❌ **Deepfake config:** NOT found at {cfg_path}")
+                
+                return "\n".join(output)
         
-        # Connect the process function
+        # Help Tab
+        with gr.Tab("Help"):
+            gr.Markdown("""
+            ## 📋 How to Use This Tool
+            
+            ### Basic Usage
+            1. Upload a car image in the "Analyze Image" tab
+            2. Click "Analyze Image" to process it
+            3. View the results - damaged areas will be highlighted and classified as real or fake
+            
+            ### Understanding Results
+            - **Green boxes/text:** Real damage
+            - **Red boxes/text:** Potential deepfake damage
+            - Percentage values show the confidence score
+            
+            ### Requirements
+            - Damage detection model file (Detectron2 Mask R-CNN)
+            - Deepfake detection model file
+            - Deepfake model configuration file
+            
+            ### Troubleshooting
+            - If models aren't loading, check the "System Diagnostics" tab
+            - Ensure all model files are in the expected locations
+            - Try installing dependencies from the Diagnostics tab
+            
+            ### Advanced Settings
+            - **Damage Threshold:** Higher values mean only high-confidence damage regions are shown
+            - **Deepfake Threshold:** Higher values make the system more selective in flagging fakes
+            - **Skip Damage Detection:** Analyze the entire image for deepfakes without damage detection
+            """)
+        
+        # Examples
+        if any(os.path.exists(img) for img in SAMPLE_IMAGES):
+            gr.Markdown("## Example Images")
+            with gr.Row():
+                example_inputs = [img for img in SAMPLE_IMAGES if os.path.exists(img)]
+                gr.Examples(
+                    examples=example_inputs,
+                    inputs=input_image,
+                    outputs=[output_image, output_text],
+                    fn=lambda x: process_image(
+                        x, DEFAULT_DAMAGE_MODEL_PATH, DEFAULT_DEEPFAKE_MODEL_PATH, 
+                        DEFAULT_DEEPFAKE_CFG_PATH, 0.7, 0.5, False, "auto"
+                    ),
+                    cache_examples=True
+                )
+        
+        # Connect functions to the UI
         process_btn.click(
             fn=process_image,
             inputs=[
                 input_image, 
-                damage_model_path,
-                deepfake_model_path,
-                deepfake_cfg_path,
+                custom_damage_model,
+                custom_deepfake_model,
+                custom_deepfake_cfg,
                 damage_threshold,
                 deepfake_threshold,
                 skip_damage,
@@ -888,13 +886,46 @@ def create_gradio_interface():
             outputs=[output_image, output_text]
         )
         
-        # Examples
-        gr.Markdown("## Examples")
-        gr.Markdown("Note: Examples will only work if you have the appropriate models installed.")
-            
+        # Clear button functionality
+        clear_btn.click(
+            fn=lambda: [None, ""],
+            inputs=[],
+            outputs=[output_image, output_text]
+        )
+        
+        # System diagnostic buttons
+        run_diagnostic_btn.click(
+            fn=run_diagnostics,
+            inputs=[],
+            outputs=diagnostic_output
+        )
+        
+        install_deps_btn.click(
+            fn=install_dependencies,
+            inputs=[],
+            outputs=diagnostic_output
+        )
+        
+        # Settings tab
+        check_paths_btn.click(
+            fn=check_model_paths,
+            inputs=[custom_damage_model, custom_deepfake_model, custom_deepfake_cfg],
+            outputs=paths_result
+        )
+        
+        # Update system status on load
+        app.load(
+            fn=update_system_status,
+            inputs=[],
+            outputs=[damage_model_status, deepfake_model_status, detectron2_status]
+        )
+        
     return app
 
-# For local testing and Hugging Face Spaces, with debugging enabled
 if __name__ == "__main__":
+    # Try to auto-install dependencies on startup
+    auto_install_dependencies()
+    
+    # Create and launch the Gradio app
     app = create_gradio_interface()
-    app.launch(debug=True)  # Enable debug mode to see detailed error messages
+    app.launch(share=False)  # Set share=True to create a public link