V1.1

app.py

@@ -12,74 +12,44 @@ if importlib.util.find_spec("detectron2") is None:
     print("Installation complete!")
 
 # -*- coding: utf-8 -*-
-
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
 import os
 import sys
 import time
+import cv2
+import torch
 import numpy as np
 import gradio as gr
-# OpenCV import - wrapped in try-except to make it optional
-import cv2
-
-from torchvision import transforms
 from PIL import Image
-# Detectron2 imports - wrapped in try-except to make them optional
-
-from detectron2.engine import DefaultPredictor
-from detectron2.config import get_cfg
-from detectron2.utils.visualizer import Visualizer, ColorMode
-from detectron2 import model_zoo
-
-from configs.get_config import load_config
-from models import *
-
-
-# Status flags for optional dependencies
-CV2_AVAILABLE = True
-TORCH_AVAILABLE = True
-DETECTRON2_AVAILABLE = True
-MODELS_IMPORTED = True
+from torchvision import transforms
 
 # 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
+try:
+    from detectron2.engine import DefaultPredictor
+    from detectron2.config import get_cfg
+    from detectron2.utils.visualizer import Visualizer, ColorMode
+    from detectron2 import model_zoo
+    DETECTRON2_AVAILABLE = True
+except ImportError:
+    print("Warning: Detectron2 is not installed. Damage detection will not be available.")
+    DETECTRON2_AVAILABLE = False
 
-
-def check_model_files(damage_model_path, deepfake_model_path, deepfake_cfg_path):
-    """Check if required model files exist and return status"""
-    status = []
-    all_exist = True
-    
-    if damage_model_path:
-        if not os.path.exists(damage_model_path):
-            status.append(f"⚠️ Damage model not found at: {damage_model_path}")
-            all_exist = False
-        else:
-            status.append(f"✅ Damage model found at: {damage_model_path}")
-    
-    if deepfake_model_path:
-        if not os.path.exists(deepfake_model_path):
-            status.append(f"⚠️ Deepfake model not found at: {deepfake_model_path}")
-            all_exist = False
-        else:
-            status.append(f"✅ Deepfake model found at: {deepfake_model_path}")
-    
-    if deepfake_cfg_path:
-        if not os.path.exists(deepfake_cfg_path):
-            status.append(f"⚠️ Deepfake config not found at: {deepfake_cfg_path}")
-            all_exist = False
-        else:
-            status.append(f"✅ Deepfake config found at: {deepfake_cfg_path}")
-            
-    return all_exist, status
+# Check for custom path for models
+try:
+    from configs.get_config import load_config
+    from models import *
+    MODELS_IMPORTED = True
+except ImportError:
+    print("Warning: Custom models couldn't be imported. Only damage detection will work.")
+    MODELS_IMPORTED = False
 
 def setup_device(device_str):
     """Set up the computation device based on user input and availability"""
-    if not TORCH_AVAILABLE:
-        print("PyTorch not available. Cannot set up device.")
-        return None
-        
     if device_str == 'auto':
         if torch.cuda.is_available():
             return torch.device('cuda:0')
@@ -95,73 +65,336 @@ def setup_device(device_str):
         print(f"Warning: Device {device_str} not available, using CPU instead.")
         return torch.device('cpu')
 
-# Simplified process function for demo mode (when models aren't available)
-def demo_mode_process(input_image):
-    """Simplified processing for demo mode when models aren't available"""
-    if not CV2_AVAILABLE:
-        # If even CV2 is not available, return a message
-        return input_image, "Error: OpenCV (cv2) is not installed. Cannot process image even in demo mode."
-    
-    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):
-        img = input_image.copy()
-        if len(img.shape) == 3 and img.shape[2] == 3:
-            img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
-    else:
-        return None, "Error: Unsupported image format"
-    
-    if img is None:
-        return None, "Error: Could not read the image"
-    
-    # Add some demo visualization
-    h, w = img.shape[:2]
-    
-    # Add a fake damage region
-    x1, y1 = int(w * 0.2), int(h * 0.2)
-    x2, y2 = int(w * 0.8), int(h * 0.8)
-    
-    # Draw demo box
-    cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), 2)
-    cv2.putText(img, "DEMO: Region 0 (REAL) (95.5%)", (x1, y1-10), 
-                cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2)
+def setup_damage_detector(model_path, threshold=0.7):
+    """Set up the damage detection model using Detectron2"""
+    if not DETECTRON2_AVAILABLE:
+        print("Detectron2 is not installed. Cannot set up damage detector.")
+        return None, None
+        
+    if model_path is None or not os.path.exists(model_path):
+        print("No damage model specified or file not found. Skipping damage detection.")
+        return None, None
+        
+    cfg = get_cfg()
+    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
     
-    # Add demo text on top
-    cv2.putText(img, "DEMO MODE - No actual detection", (10, 30), 
-                cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+    # Explicitly set to use CPU if on Mac (MPS)
+    if torch.backends.mps.is_available():
+        cfg.MODEL.DEVICE = "cpu"
+        print("Mac MPS detected - forcing Detectron2 to use CPU")
     
-    # Convert back to RGB for Gradio
-    result_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    try:
+        predictor = DefaultPredictor(cfg)
+        return predictor, cfg
+    except Exception as e:
+        print(f"Error setting up damage detector: {e}")
+        return None, cfg
+
+def load_deepfake_model(model_path, cfg_path, device):
+    """Load the deepfake detection model"""
+    if not MODELS_IMPORTED:
+        print("Custom models module not imported. Cannot load deepfake model.")
+        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.")
+        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.")
+        return None, None
+        
+    try:
+        # Load config
+        cfg = load_config(cfg_path)
+        
+        # Build model
+        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:
+            model.load_state_dict(checkpoint['state_dict'])
+        else:
+            model.load_state_dict(checkpoint)
+            
+        # Move model to device and set to evaluation mode
+        model = model.to(device)
+        if hasattr(cfg.MODEL, 'precision') and cfg.MODEL.precision == 'fp64':
+            model = model.to(torch.float64)
+        model.eval()
+        
+        return model, cfg
+    except Exception as e:
+        print(f"Error loading deepfake model: {e}")
+        import traceback
+        traceback.print_exc()
+        return None, None
+
+def preprocess_for_deepfake(image, cfg, device):
+    """Preprocess an image for deepfake detection"""
+    try:
+        # Convert to RGB if needed
+        if len(image.shape) == 3 and image.shape[2] == 3:
+            if image.dtype != np.uint8:
+                image = (image * 255).astype(np.uint8)
+            rgb_img = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        else:
+            rgb_img = image
+            
+        # Resize
+        img_resized = cv2.resize(rgb_img, (cfg.DATASET.IMAGE_SIZE[0], cfg.DATASET.IMAGE_SIZE[1]))
+        
+        # Convert to PIL and apply transforms
+        transform = transforms.Compose([
+            transforms.ToTensor(),
+            transforms.Normalize(
+                mean=cfg.DATASET.TRANSFORM.normalize.mean,
+                std=cfg.DATASET.TRANSFORM.normalize.std
+            )
+        ])
+        
+        img_tensor = transform(Image.fromarray(img_resized)).unsqueeze(0)  # Add batch dimension
+        img_tensor = img_tensor.to(device)
+        
+        # Convert to correct precision
+        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}")
+        import traceback
+        traceback.print_exc()
+        return None
+
+def detect_damage(img, damage_detector):
+    """Detect damage in an image"""
+    try:
+        if img is None:
+            raise ValueError("Invalid image")
+            
+        # If no damage detector available, return the whole image as region
+        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),
+                "score": 1.0,
+                "mask": None
+            }]
+            return img, None, damage_regions
+            
+        # Run inference
+        outputs = damage_detector(img)
+        
+        # Get damage 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 []
+        masks = instances.pred_masks.numpy() if instances.has("pred_masks") else []
+        
+        damage_regions = []
+        for i in range(len(boxes)):
+            x1, y1, x2, y2 = map(int, boxes[i])
+            damage_regions.append({
+                "box": (x1, y1, x2, y2),
+                "score": float(scores[i]),
+                "mask": masks[i] if len(masks) > i else None
+            })
+        
+        if not damage_regions:
+            print("No damage detected. Using whole image.")
+            h, w = img.shape[:2]
+            damage_regions = [{
+                "box": (0, 0, w, h),
+                "score": 1.0,
+                "mask": None
+            }]
+            
+        return img, outputs, damage_regions
+    except Exception as e:
+        print(f"Error detecting damage: {e}")
+        # If error occurs, return the whole image as region
+        if 'img' in locals() and img is not None:
+            h, w = img.shape[:2]
+            damage_regions = [{
+                "box": (0, 0, w, h),
+                "score": 1.0,
+                "mask": None
+            }]
+            return img, None, damage_regions
+        return None, None, []
+
+def check_deepfake(image, damage_regions, deepfake_model, deepfake_cfg, device, threshold=0.5):
+    """Check if damage regions are deepfakes"""
+    results = []
     
-    info_text = "DEMO MODE ACTIVE\n\n"
-    info_text += "This is running in demo mode because the required models or dependencies are not available.\n"
-    info_text += "In a real deployment, you would need to:\n"
-    info_text += "1. Install all required dependencies (OpenCV, PyTorch, Detectron2)\n"
-    info_text += "2. Include your trained models in the correct paths\n\n"
-    info_text += "The visualization shown is just a placeholder."
+    if deepfake_model is None:
+        print("No deepfake model available. Skipping deepfake detection.")
+        return []
     
-    return result_img, info_text
+    try:
+        # If no damage regions, check the entire image
+        if not damage_regions:
+            img_tensor = preprocess_for_deepfake(image, deepfake_cfg, device)
+            if img_tensor is None:
+                return []
+                
+            # Run inference
+            with torch.no_grad():
+                outputs = deepfake_model(img_tensor)
+                
+                # Extract outputs
+                if isinstance(outputs, list):
+                    outputs = outputs[0]
+                
+                if isinstance(outputs, dict) and 'cls' in outputs:
+                    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:
+                    is_fake = cls_prob[0][0] > threshold if cls_prob.ndim > 1 else cls_prob[0] > threshold
+                    confidence = cls_prob[0][0] if cls_prob.ndim > 1 else cls_prob[0]
+                    
+                    results.append({
+                        "region": "full_image",
+                        "deepfake_prob": float(confidence),
+                        "is_fake": bool(is_fake)
+                    })
+            
+            return results
+        
+        # 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
+            if x2 > x1 and y2 > y1:
+                # Get ROI
+                roi = image[y1:y2, x1:x2]
+                
+                # Preprocess
+                img_tensor = preprocess_for_deepfake(roi, deepfake_cfg, device)
+                if img_tensor is None:
+                    continue
+                
+                # Run inference
+                with torch.no_grad():
+                    outputs = deepfake_model(img_tensor)
+                    
+                    # Extract outputs
+                    if isinstance(outputs, list):
+                        outputs = outputs[0]
+                    
+                    if isinstance(outputs, dict) and 'cls' in outputs:
+                        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:
+                        is_fake = cls_prob[0][0] > threshold if cls_prob.ndim > 1 else cls_prob[0] > threshold
+                        confidence = cls_prob[0][0] if cls_prob.ndim > 1 else cls_prob[0]
+                        
+                        results.append({
+                            "region_id": i,
+                            "box": (x1, y1, x2, y2),
+                            "deepfake_prob": float(confidence),
+                            "is_fake": bool(is_fake)
+                        })
+        
+        return results
+    except Exception as e:
+        print(f"Error in deepfake detection: {e}")
+        import traceback
+        traceback.print_exc()
+        return []
+
+def visualize_results(image, damage_outputs, deepfake_results, damage_threshold):
+    """Create visualization of damage detection and deepfake verification"""
+    try:
+        # Create a copy for visualization
+        img_copy = image.copy()
+        
+        # Draw damage detection results
+        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}")
+                result_img = img_copy
+        else:
+            result_img = img_copy
+        
+        # Add deepfake detection results
+        for result in deepfake_results:
+            try:
+                if "box" in result:
+                    x1, y1, x2, y2 = result["box"]
+                    fake_prob = result["deepfake_prob"] 
+                    is_fake = result["is_fake"]
+                    region_id = result.get("region_id", 0)
+                    
+                    # Text for the region
+                    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
+                    
+                    # Ensure we have a standard numpy array
+                    if not isinstance(result_img, np.ndarray):
+                        result_img = np.array(result_img, dtype=np.uint8)
+                    
+                    # Draw rectangle and text
+                    cv2.rectangle(result_img, (x1, y1), (x2, y2), color, 2)
+                    cv2.putText(result_img, text, (x1, y1-10), cv2.FONT_HERSHEY_SIMPLEX, 0.8, color, 2)
+                elif "region" in result and result["region"] == "full_image":
+                    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}%)"
+                    
+                    # 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}")
+        
+        return result_img
+    except Exception as e:
+        print(f"Error visualizing results: {e}")
+        import traceback
+        traceback.print_exc()
+        return np.array(image, dtype=np.uint8)  # Return the original image as a numpy array
 
 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"""
-    # Check dependencies first
-    if not all([CV2_AVAILABLE, TORCH_AVAILABLE]):
-        return demo_mode_process(input_image)
-    
-    # Default model paths if not provided
-    damage_model_path = damage_model_path or "./model_final.pth"
-    deepfake_model_path = deepfake_model_path or "./PoseEfficientNet_custom_laanet_model_final.pth"
-    deepfake_cfg_path = deepfake_cfg_path or "./configs/detector2.yaml"
-    
-    # Check if we're running in demo mode (no real models available)
-    models_exist, model_status = check_model_files(damage_model_path, deepfake_model_path, deepfake_cfg_path)
-    if (not models_exist) or (not DETECTRON2_AVAILABLE and not MODELS_IMPORTED):
-        print("Missing required models or dependencies. Running in demo mode.")
-        return demo_mode_process(input_image)
-    
     progress_info = []
     
     # Convert Gradio image to numpy array
@@ -181,74 +414,99 @@ def process_image(input_image, damage_model_path, deepfake_model_path, deepfake_
     if img is None:
         return None, "Error: Could not read the image"
     
-    # For this simplified version, just use demo mode 
-    # This ensures the app will run even without the specialized detection functions
-    return demo_mode_process(input_image)
-
-def create_gradio_interface():
-    """Create the Gradio interface with appropriate status messages"""
+    # Progress update
+    progress_info.append("Image loaded successfully")
     
-    # Build status message about available dependencies
-    status_message = "# Car Damage Detection & Deepfake Verification\n\n"
-    status_message += "## System Status\n"
+    # Setup device
+    device = setup_device(device_str)
+    progress_info.append(f"Using device: {device}")
     
-    if CV2_AVAILABLE:
-        status_message += "✅ OpenCV (cv2) is available\n"
-    else:
-        status_message += "❌ OpenCV (cv2) is NOT available - install with `pip install opencv-python`\n"
-        
-    if TORCH_AVAILABLE:
-        status_message += "✅ PyTorch and related libraries are available\n"
-    else:
-        status_message += "❌ PyTorch is NOT available - install with `pip install torch torchvision pillow`\n"
-        
-    if DETECTRON2_AVAILABLE:
-        status_message += "✅ Detectron2 is available\n"
-    else:
-        status_message += "❌ Detectron2 is NOT available - follow installation instructions at https://detectron2.readthedocs.io/\n"
-        
-    if MODELS_IMPORTED:
-        status_message += "✅ Custom models module imported successfully\n"
-    else:
-        status_message += "❌ Custom models module import failed - check your installation\n"
-        
-    # Check default model paths
-    default_damage_path = "./model_final.pth"
-    default_deepfake_path = "./PoseEfficientNet_custom_laanet_model_final.pth"
-    default_config_path = "./configs/detector2.yaml"
+    # Initialize models
+    damage_detector = None
+    deepfake_model = None
+    deepfake_cfg = None
     
-    # Make sure we have a safe version of check_model_files
-    try:
-        models_exist, model_status = check_model_files(default_damage_path, default_deepfake_path, default_config_path)
-        status_message += "\n## Default Model Files\n" + "\n".join(model_status)
-    except:
-        # Fallback if the function fails
-        status_message += "\n## Default Model Files\n"
-        status_message += "❌ Error checking model files\n"
-        model_status = []
+    # Setup damage detector if not skipped
+    if not skip_damage and damage_model_path:
+        progress_info.append("Setting up damage detector...")
+        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")
+    
+    # Setup deepfake detector
+    if deepfake_model_path and deepfake_cfg_path:
+        progress_info.append("Setting up deepfake detector...")
+        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")
+    
+    # Ensure at least one detector is working
+    if damage_detector is None and deepfake_model is None:
+        return None, "Error: Neither damage nor deepfake detector is available"
     
-    # Check if example images exist
-    example_images = ["./test5.png", "./test3.png"]
-    valid_examples = []
-    example_status = []
+    # Step 1: Detect damage or use whole image
+    progress_info.append("Detecting damage regions...")
+    start_time = time.time()
+    img, damage_outputs, damage_regions = detect_damage(img, damage_detector)
+    damage_time = time.time() - start_time
     
-    for img_path in example_images:
-        if os.path.exists(img_path):
-            valid_examples.append([img_path])
-            example_status.append(f"✅ Example image found: {img_path}")
+    if img is None:
+        return None, "Error: Failed to process image"
+    
+    # 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")
+    else:
+        progress_info.append("Using the whole image for analysis")
+    
+    # Step 2: Check if damage is deepfake
+    deepfake_results = []
+    if deepfake_model is not None:
+        progress_info.append("Performing deepfake detection...")
+        start_time = time.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 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:
-            example_status.append(f"❌ Example image NOT found: {img_path}")
+            progress_info.append("No deepfake detection results")
+    
+    # Step 3: Visualize final results
+    progress_info.append("Generating visualization...")
+    result_img = visualize_results(img, damage_outputs, deepfake_results, float(damage_threshold))
     
-    status_message += "\n## Example Images\n" + "\n".join(example_status)
+    # 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("Processing complete!")
     
-    # Create Gradio interface
+    return result_img, "\n".join(progress_info)
+
+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")
         
-        with gr.Accordion("System Status", open=True):
-            gr.Markdown(status_message)
-        
         with gr.Tab("Basic Interface"):
             with gr.Row():
                 with gr.Column(scale=1):
@@ -273,13 +531,10 @@ def create_gradio_interface():
             with gr.Row():
                 with gr.Column():
                     damage_model_path = gr.Textbox(label="Damage Model Path", 
-                                                 value=default_damage_path,
                                                  placeholder="Path to damage detection model (.pth)")
                     deepfake_model_path = gr.Textbox(label="Deepfake Model Path", 
-                                                   value=default_deepfake_path,
                                                    placeholder="Path to deepfake detection model (.pth)")
                     deepfake_cfg_path = gr.Textbox(label="Deepfake Config Path", 
-                                                 value=default_config_path,
                                                  placeholder="Path to deepfake model config (.yaml)")
         
         # Connect the process function
@@ -298,31 +553,14 @@ def create_gradio_interface():
             outputs=[output_image, output_text]
         )
         
-        # Add examples only if they exist
-        if valid_examples:
-            gr.Markdown("## Examples")
-            gr.Markdown("Click on an example image to load it into the app")
-            
-            gr.Examples(
-                examples=valid_examples,
-                inputs=input_image,
-                outputs=[output_image, output_text],
-                fn=lambda x: process_image(x, 
-                                         default_damage_path,
-                                         default_deepfake_path,
-                                         default_config_path,
-                                         0.7, 0.5, False, "auto"),
-                cache_examples=True
-            )
-        else:
-            gr.Markdown("## Examples")
-            gr.Markdown("⚠️ No example images found. Please upload your own images.")
+        # Examples
+        gr.Markdown("## Examples")
+        gr.Markdown("Note: Examples will only work if you have the appropriate models installed.")
             
     return app
+    app = create_gradio_interface()
 
-# Create and launch the app
-app = create_gradio_interface()
 
-# For local testing and Hugging Face Spaces, with debugging enabled
 if __name__ == "__main__":
-    app.launch(debug=True)  # Enable debug mode to see detailed error messages
+    # Create and launch the Gradio interface
+    app.launch(share=True)  # Set share=False in production