Update app.py

app.py

@@ -1,372 +1,259 @@
-import torch 
-import torchvision 
-from torchvision.models.detection import FasterRCNN_ResNet50_FPN_Weights, MaskRCNN_ResNet50_FPN_Weights
-from torchvision.transforms import functional as F
-from PIL import Image 
-import numpy as np 
-import matplotlib.pyplot as plt 
-import matplotlib.patches as patches
-import gradio as gr 
-import os 
+import torch
+import torchvision
+from torchvision.models.detection import FasterRCNN_ResNet50_FPN_Weights
+from PIL import Image, ImageDraw, ImageFont
+import numpy as np
+import gradio as gr
+import os
 import sys
-import random
-from typing import Tuple, List, Dict, Any, Optional
+import uuid # For unique filenames
+import traceback # For detailed error logging
 
+# --- Model Loading ---
+# Model A
+model_A = torchvision.models.detection.fasterrcnn_resnet50_fpn(weights=FasterRCNN_ResNet50_FPN_Weights.DEFAULT)
+model_A.eval()
 
-# Load models only once
-def load_models():
-    print("Loading detection models...", file=sys.stderr)
-    # Model 1: Faster R-CNN
-    model1 = torchvision.models.detection.fasterrcnn_resnet50_fpn(weights=FasterRCNN_ResNet50_FPN_Weights.DEFAULT)
-    model1.eval()
-    
-    # Model 2: RetinaNet 
-    model2 = torchvision.models.detection.retinanet_resnet50_fpn_v2(weights=torchvision.models.detection.RetinaNet_ResNet50_FPN_V2_Weights.DEFAULT)
-    model2.eval()
-    
-    # Segmentation model
-    seg_model = torchvision.models.detection.maskrcnn_resnet50_fpn(weights=MaskRCNN_ResNet50_FPN_Weights.DEFAULT)
-    seg_model.eval()
-    
-    return model1, model2, seg_model
+# Model B (same architecture, will use a different threshold in practice)
+model_B = torchvision.models.detection.fasterrcnn_resnet50_fpn(weights=FasterRCNN_ResNet50_FPN_Weights.DEFAULT)
+model_B.eval()
 
-# Global models
-MODEL1, MODEL2, SEG_MODEL = load_models()
-
-# COCO class names 
-COCO_INSTANCE_CATEGORY_NAMES = [ 
-    '__background__', 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 
-    'train', 'truck', 'boat', 'traffic light', 'fire hydrant', 'N/A', 'stop sign', 
-    'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow', 
-    'elephant', 'bear', 'zebra', 'giraffe', 'N/A', 'backpack', 'umbrella', 'N/A', 'N/A', 
-    'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard', 'sports ball', 
-    'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard', 'tennis racket', 
-    'bottle', 'N/A', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', 
-    'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 
-    'donut', 'cake', 'chair', 'couch', 'potted plant', 'bed', 'N/A', 'dining table', 
-    'N/A', 'N/A', 'toilet', 'N/A', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 
-    'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'N/A', 'book', 
-    'clock', 'vase', 'scissors', 'teddy bear', 'hair drier', 'toothbrush' 
+# --- COCO Class Names ---
+COCO_INSTANCE_CATEGORY_NAMES = [
+    '__background__', 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus',
+    'train', 'truck', 'boat', 'traffic light', 'fire hydrant', 'N/A', 'stop sign',
+    'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow',
+    'elephant', 'bear', 'zebra', 'giraffe', 'N/A', 'backpack', 'umbrella', 'N/A', 'N/A',
+    'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard', 'sports ball',
+    'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard', 'tennis racket',
+    'bottle', 'N/A', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl',
+    'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza',
+    'donut', 'cake', 'chair', 'couch', 'potted plant', 'bed', 'N/A', 'dining table',
+    'N/A', 'N/A', 'toilet', 'N/A', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone',
+    'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'N/A', 'book',
+    'clock', 'vase', 'scissors', 'teddy bear', 'hair drier', 'toothbrush'
 ]
 
-def get_prediction(model, image, threshold=0.5):
-    """Get prediction from model"""
-    transform = FasterRCNN_ResNet50_FPN_Weights.DEFAULT.transforms()
-    image_tensor = transform(image).unsqueeze(0)
-    
-    with torch.no_grad():
-        prediction = model(image_tensor)[0]
-    
-    boxes = prediction['boxes'].cpu().numpy()
-    labels = prediction['labels'].cpu().numpy()
-    scores = prediction['scores'].cpu().numpy()
-    
-    # Filter by threshold
-    keep = scores >= threshold
-    boxes = boxes[keep]
-    labels = labels[keep]
-    scores = scores[keep]
-    
-    return boxes, labels, scores
-
-def get_segmentation_prediction(model, image, threshold=0.5):
-    """Get segmentation prediction"""
-    transform = MaskRCNN_ResNet50_FPN_Weights.DEFAULT.transforms()
-    image_tensor = transform(image).unsqueeze(0)
-    
-    with torch.no_grad():
-        prediction = model(image_tensor)[0]
-    
-    boxes = prediction['boxes'].cpu().numpy()
-    labels = prediction['labels'].cpu().numpy()
-    scores = prediction['scores'].cpu().numpy()
-    masks = prediction['masks'].cpu().numpy()
-    
-    # Filter by threshold
-    keep = scores >= threshold
-    boxes = boxes[keep]
-    labels = labels[keep]
-    scores = scores[keep]
-    masks = masks[keep]
-    
-    return boxes, labels, scores, masks
+# --- Helper Functions ---
+def get_font(size=15):
+    """Attempts to load Arial font, falls back to PIL default."""
+    try:
+        return ImageFont.truetype("arial.ttf", size)
+    except IOError:
+        return ImageFont.load_default()
 
-def visualize_detection(image, boxes, labels, scores, title="Detection Results"):
-    """Visualize detection results"""
-    image_np = np.array(image)
-    plt.figure(figsize=(10, 10))
-    plt.imshow(image_np)
-    ax = plt.gca()
-    
-    for box, label, score in zip(boxes, labels, scores):
-        x1, y1, x2, y2 = box
-        ax.add_patch(plt.Rectangle((x1, y1), x2 - x1, y2 - y1, 
-                    fill=False, color='red', linewidth=2))
-        class_name = COCO_INSTANCE_CATEGORY_NAMES[label]
-        ax.text(x1, y1, f'{class_name}: {score:.2f}', 
-                bbox=dict(facecolor='yellow', alpha=0.5),
-                fontsize=12, color='black')
-    
-    plt.title(title)
-    plt.axis('off')
-    plt.tight_layout()
-    
-    # Save the figure
-    output_path = f"{title.replace(' ', '_').lower()}.png"
-    plt.savefig(output_path)
-    plt.close()
-    return output_path
+def run_detection_on_image(image_pil, threshold, model_instance, model_name_str="Model"):
+    """
+    Runs object detection on a PIL image and returns the path to the annotated image.
+    Uses PIL for all drawing operations.
+    """
+    if image_pil is None:
+        print(f"{model_name_str}: Image is None, returning placeholder.", file=sys.stderr)
+        placeholder_img = Image.new('RGB', (400, 300), color='lightgray')
+        draw = ImageDraw.Draw(placeholder_img)
+        font = get_font(15)
+        text = f"{model_name_str}:\nNo image provided."
+        try:
+            bbox = draw.textbbox((0,0), text, font=font, align="center")
+            text_width, text_height = bbox[2] - bbox[0], bbox[3] - bbox[1]
+        except AttributeError: # Fallback for older Pillow
+            text_width = draw.textlength(text.split('\n')[0], font=font)
+            text_height = (font.getmetrics()[0] + font.getmetrics()[1]) * text.count('\n') + font.getmetrics()[0]
+        draw.text(((400 - text_width) / 2, (300 - text_height) / 2), text, fill="black", font=font, align="center")
+        output_filename = f"placeholder_{model_name_str.lower().replace(' ', '_')}_{uuid.uuid4()}.png"
+        placeholder_img.save(output_filename)
+        return output_filename
 
-def visualize_segmentation(image, boxes, labels, scores, masks, title="Segmentation Results"):
-    """Visualize segmentation results"""
-    image_np = np.array(image)
-    plt.figure(figsize=(10, 10))
-    plt.imshow(image_np)
-    ax = plt.gca()
-    
-    # Random colors for masks
-    colors = plt.cm.rainbow(np.linspace(0, 1, len(masks)))
-    
-    for box, label, score, mask, color in zip(boxes, labels, scores, masks, colors):
-        # Draw bounding box
-        x1, y1, x2, y2 = box
-        rect = patches.Rectangle((x1, y1), x2 - x1, y2 - y1,
-                                 linewidth=2, edgecolor='r', facecolor='none')
-        ax.add_patch(rect)
-        
-        # Add text
-        class_name = COCO_INSTANCE_CATEGORY_NAMES[label]
-        ax.text(x1, y1-10, f'{class_name}: {score:.2f}', 
-                bbox=dict(facecolor='yellow', alpha=0.5),
-                fontsize=12, color='black')
-        
-        # Draw mask
-        mask_image = mask[0, :, :]  # First channel
-        mask_overlay = np.zeros_like(image_np, dtype=np.uint8)
-        for c in range(3):
-            mask_overlay[:, :, c] = np.where(mask_image > 0.5,
-                                             int(color[c] * 255), 0)
+    try:
+        print(f"{model_name_str}: Processing with threshold {threshold:.2f}", file=sys.stderr)
+        image_rgb = image_pil.convert("RGB") # Ensure 3-channel RGB
         
-        # Add mask with transparency
-        alpha = 0.5
-        mask_bool = mask_image > 0.5
-        for c in range(3):
-            image_np[:, :, c] = np.where(
-                mask_bool,
-                image_np[:, :, c] * (1-alpha) + mask_overlay[:, :, c] * alpha,
-                image_np[:, :, c]
-            )
-    
-    plt.imshow(image_np)
-    plt.title(title)
-    plt.axis('off')
-    plt.tight_layout()
-    
-    # Save the figure
-    output_path = f"{title.replace(' ', '_').lower()}.png"
-    plt.savefig(output_path)
-    plt.close()
-    return output_path
+        transform = FasterRCNN_ResNet50_FPN_Weights.DEFAULT.transforms()
+        image_tensor = transform(image_rgb).unsqueeze(0)
 
-def calculate_metrics(boxes, labels, scores):
-    """Calculate simple metrics for model comparison"""
-    # In a real app, you'd use proper metrics like mAP
-    # For simplicity, we'll use:
-    # 1. Number of detections
-    # 2. Average confidence score
-    # 3. Number of unique classes detected
-    
-    num_detections = len(boxes)
-    avg_confidence = np.mean(scores) if len(scores) > 0 else 0
-    unique_classes = len(set(labels))
-    
-    return {
-        "num_detections": num_detections,
-        "avg_confidence": avg_confidence,
-        "unique_classes": unique_classes,
-        "total_score": num_detections * avg_confidence + unique_classes  # Simple combined metric
-    }
+        with torch.no_grad():
+            prediction = model_instance(image_tensor)[0]
 
-def process_game(image, task_type, user_prediction, confidence_threshold=0.5):
-    """Main game function that processes the image based on selected task type"""
-    if image is None:
-        return {
-            "status": "error",
-            "message": "Please upload an image to continue."
-        }, None, None, None, None
-    
-    try:
-        if task_type == "Object Detection":
-            # Model 1: Faster R-CNN
-            boxes1, labels1, scores1 = get_prediction(MODEL1, image, confidence_threshold)
-            result1 = visualize_detection(image, boxes1, labels1, scores1, "Faster R-CNN Results")
-            metrics1 = calculate_metrics(boxes1, labels1, scores1)
-            
-            # Model 2: RetinaNet
-            boxes2, labels2, scores2 = get_prediction(MODEL2, image, confidence_threshold)
-            result2 = visualize_detection(image, boxes2, labels2, scores2, "RetinaNet Results")
-            metrics2 = calculate_metrics(boxes2, labels2, scores2)
-            
-            # Determine winner
-            score1 = metrics1["total_score"]
-            score2 = metrics2["total_score"]
-            
-            if score1 > score2:
-                winner = "Model 1 (Faster R-CNN)"
-                winning_score = score1
-                losing_score = score2
-            elif score2 > score1:
-                winner = "Model 2 (RetinaNet)"
-                winning_score = score2
-                losing_score = score1
-            else:
-                winner = "Tie"
-                winning_score = score1
-                losing_score = score2
-            
-            user_correct = (user_prediction == "Model 1" and winner == "Model 1 (Faster R-CNN)") or \
-                          (user_prediction == "Model 2" and winner == "Model 2 (RetinaNet)") or \
-                          (user_prediction == "Tie" and winner == "Tie")
-            
-            result_message = f"Winner: {winner} (Score: {winning_score:.2f} vs {losing_score:.2f})\n"
-            result_message += f"Your prediction: {user_prediction} - {'Correct!' if user_correct else 'Incorrect!'}\n\n"
-            result_message += f"Model 1 detected {metrics1['num_detections']} objects with {metrics1['unique_classes']} unique classes.\n"
-            result_message += f"Model 2 detected {metrics2['num_detections']} objects with {metrics2['unique_classes']} unique classes."
-            
-            return {"status": "success", "message": result_message}, result1, result2, None, None
-        
-        elif task_type == "Instance Segmentation":
-            # Only using one model for segmentation for now
-            boxes, labels, scores, masks = get_segmentation_prediction(SEG_MODEL, image, confidence_threshold)
-            seg_result = visualize_segmentation(image, boxes, labels, scores, masks, "Mask R-CNN Results")
-            
-            # Also get detection results for comparison
-            boxes1, labels1, scores1 = get_prediction(MODEL1, image, confidence_threshold)
-            det_result = visualize_detection(image, boxes1, labels1, scores1, "Detection Results")
-            
-            metrics_seg = calculate_metrics(boxes, labels, scores)
-            metrics_det = calculate_metrics(boxes1, labels1, scores1)
-            
-            result_message = f"Segmentation detected {metrics_seg['num_detections']} objects with {metrics_seg['unique_classes']} unique classes.\n"
-            result_message += f"The segmentation model provides pixel-level masks for each detected object."
-            
-            return {"status": "success", "message": result_message}, None, None, det_result, seg_result
+        boxes, labels, scores = prediction['boxes'].cpu().numpy(), prediction['labels'].cpu().numpy(), prediction['scores'].cpu().numpy()
+
+        annotated_image = image_rgb.copy()
+        draw = ImageDraw.Draw(annotated_image)
+        label_font = get_font(12)
+        detections_made = False
+
+        for box, label_id, score in zip(boxes, labels, scores):
+            if score >= threshold:
+                detections_made = True
+                x1, y1, x2, y2 = box
+                draw.rectangle([(x1, y1), (x2, y2)], outline='red', width=3)
+                class_name = COCO_INSTANCE_CATEGORY_NAMES[label_id]
+                text_label = f'{class_name}: {score:.2f}'
+                
+                try: tb_box = draw.textbbox((0,0), text_label, font=label_font) # Get text size
+                except AttributeError: tb_box = (0,0, draw.textlength(text_label, font=label_font), label_font.getmetrics()[0])
+
+                text_w, text_h = tb_box[2] - tb_box[0], tb_box[3] - tb_box[1]
+                bg_y1 = y1 - text_h - 4 if y1 - text_h - 4 > 0 else y1 + 2
+                draw.rectangle([x1, bg_y1, x1 + text_w + 4, bg_y1 + text_h + 4], fill='yellow')
+                draw.text((x1 + 2, bg_y1 + 2), text_label, fill='black', font=label_font)
         
-        else:
-            return {"status": "error", "message": "Invalid task type selected."}, None, None, None, None
-            
+        if not detections_made:
+            no_detection_font = get_font(max(15, min(annotated_image.width, annotated_image.height) // 20)) # Scaled font
+            no_detection_text = f"{model_name_str}:\nNo objects detected\n(Threshold: {threshold:.2f})"
+            try: bbox_nd = draw.textbbox((0,0), no_detection_text, font=no_detection_font, align="center")
+            except AttributeError: bbox_nd = (0,0, draw.textlength(no_detection_text.split('\n')[0], font=no_detection_font), (no_detection_font.getmetrics()[0] + no_detection_font.getmetrics()[1]) * no_detection_text.count('\n') + no_detection_font.getmetrics()[0])
+            text_w_nd, text_h_nd = bbox_nd[2]-bbox_nd[0], bbox_nd[3]-bbox_nd[1]
+            draw.text(((annotated_image.width - text_w_nd) / 2, (annotated_image.height - text_h_nd) / 2), 
+                      no_detection_text, fill="blue", font=no_detection_font, align="center", stroke_width=1, stroke_fill="white")
+
+        output_filename = f"detection_{model_name_str.lower().replace(' ', '_')}_{uuid.uuid4()}.png"
+        annotated_image.save(output_filename)
+        return output_filename
+
     except Exception as e:
-        print(f"Error in process_game: {e}", file=sys.stderr)
-        import traceback
+        print(f"ERROR in {model_name_str} run_detection_on_image: {e}", file=sys.stderr)
         traceback.print_exc(file=sys.stderr)
-        return {"status": "error", "message": f"Error processing image: {str(e)}"}, None, None, None, None
+        error_img = Image.new('RGB', (400, 300), color='lightpink')
+        draw = ImageDraw.Draw(error_img)
+        font = get_font(15)
+        text = f"{model_name_str} Error:\n{str(e)[:100]}" # Limit error message length
+        try: bbox_err = draw.textbbox((0,0), text, font=font, align="center")
+        except AttributeError: bbox_err = (0,0, draw.textlength(text.split('\n')[0], font=font), (font.getmetrics()[0] + font.getmetrics()[1]) * text.count('\n') + font.getmetrics()[0])
+        text_w_err, text_h_err = bbox_err[2]-bbox_err[0], bbox_err[3]-bbox_err[1]
+        draw.text(((400 - text_w_err) / 2, (300 - text_h_err) / 2), text, fill="black", font=font, align="center")
+        error_filename = f"error_{model_name_str.lower().replace(' ', '_')}_{uuid.uuid4()}.png"
+        error_img.save(error_filename)
+        return error_filename
+
+# --- Prepare Example Images ---
+example_files_src = ["TEST_IMG_1.jpg", "TEST_IMG_2.JPG", "TEST_IMG_3.jpg", "TEST_IMG_4.jpg"]
+app_root = os.getcwd() # Assumes script runs from app root
+example_paths_final = [os.path.join(app_root, f) for f in example_files_src]
+valid_examples_list = [p for p in example_paths_final if os.path.exists(p)]
+
+if not valid_examples_list:
+    print("Warning: No example images found at app root. Creating dummy examples.", file=sys.stderr)
+    try:
+        for i in range(1, 3):
+            dummy_fname = f"dummy_example_{i}.png"
+            if not os.path.exists(os.path.join(app_root, dummy_fname)):
+                img = Image.new('RGB', (300, 200), color=('darkred' if i == 1 else 'darkgreen'))
+                draw = ImageDraw.Draw(img)
+                font = get_font(25)
+                draw.text((10, 10), f"Dummy Example {i}", font=font, fill="white")
+                img.save(os.path.join(app_root, dummy_fname))
+        valid_examples_list = [os.path.join(app_root, f"dummy_example_{i}.png") for i in range(1, 3) if os.path.exists(os.path.join(app_root, f"dummy_example_{i}.png"))]
+        print(f"Created/using dummy examples: {valid_examples_list}", file=sys.stderr)
+    except Exception as e:
+        print(f"Failed to create dummy examples: {e}", file=sys.stderr)
+        valid_examples_list = []
+
+print(f"Final list of examples to use: {valid_examples_list}", file=sys.stderr)
+
+# --- Gradio UI Definition ---
+with gr.Blocks(theme=gr.themes.Soft(primary_hue=gr.themes.colors.blue, secondary_hue=gr.themes.colors.sky)) as demo:
+    gr.Markdown("# 🖼️ Object Detection Game: Model vs. Model 🏆")
+    gr.Markdown("Can you guess which model configuration will perform better on your image?")
 
-def create_ui():
-    """Create the Gradio UI for the game"""
-    with gr.Blocks(title="Object Detection Game") as app:
-        gr.Markdown("# 🎮 Computer Vision Model Comparison Game")
-        gr.Markdown("Upload an image, choose a task, and predict which model will perform better!")
+    # --- Output Display Area (initially hidden) ---
+    with gr.Row(visible=False) as results_feedback_row:
+        user_guess_feedback_display = gr.Markdown("") 
+    with gr.Row(visible=False) as results_images_row:
+        output_img_model_A = gr.Image(label="Model A Output", type="filepath", interactive=False)
+        output_img_model_B = gr.Image(label="Model B Output", type="filepath", interactive=False)
+
+    # --- Input and Controls Area ---
+    with gr.Row():
+        image_uploader = gr.Image(type="pil", label="🖼️ Upload Your Image Here")
         
-        with gr.Row():
-            with gr.Column(scale=1):
-                # Input components
-                input_image = gr.Image(type="pil", label="Upload Image")
-                task_type = gr.Radio(
-                    ["Object Detection", "Instance Segmentation"], 
-                    label="Select Task", 
-                    value="Object Detection"
-                )
-                
-                with gr.Row():
-                    with gr.Column(scale=1, visible=True) as detection_options:
-                        user_prediction = gr.Radio(
-                            ["Model 1", "Model 2", "Tie"], 
-                            label="Which model will perform better?",
-                            value="Model 1"
-                        )
-                    
-                confidence = gr.Slider(
-                    minimum=0.0, maximum=1.0, value=0.5, step=0.05,
-                    label="Confidence Threshold"
-                )
-                
-                submit_btn = gr.Button("Run Comparison", variant="primary")
+        with gr.Column(scale=1): # Control panel
+            task_type_selector = gr.Radio(
+                ["Detect Objects", "Segment Objects (Coming Soon!)"], 
+                label="🎯 1. Select Task:",
+                value="Detect Objects"
+            )
             
-            with gr.Column(scale=1):
-                # Output components
-                result_msg = gr.JSON(label="Results")
+            with gr.Group(visible=True) as detection_controls_group:
+                gr.Markdown("--- \n ### ⚔️ Detection Challenge Details:")
+                gr.Markdown("ทั้ง **Model A** และ **Model B** คือ Faster R-CNN (ResNet50 FPN).") # Thai for fun
+                gr.Markdown("- **Model A**: You control its confidence threshold.")
+                gr.Markdown("- **Model B**: Its threshold is `Model A Threshold - 0.15` (minimum 0.05).")
                 
-                # Detection results
-                with gr.Row(visible=True) as detection_results:
-                    model1_output = gr.Image(type="filepath", label="Model 1 (Faster R-CNN)")
-                    model2_output = gr.Image(type="filepath", label="Model 2 (RetinaNet)")
-                
-                # Segmentation results
-                with gr.Row(visible=False) as segmentation_results:
-                    detection_output = gr.Image(type="filepath", label="Detection")
-                    segmentation_output = gr.Image(type="filepath", label="Segmentation")
-        
-        # Example images
-        examples = [
-            os.path.join("/home/user/app", "TEST_IMG_1.jpg"),
-            os.path.join("/home/user/app", "TEST_IMG_2.JPG"),
-            os.path.join("/home/user/app", "TEST_IMG_3.jpg"),
-            os.path.join("/home/user/app", "TEST_IMG_4.jpg")
-        ]
-        
-        # Filter to valid examples
-        example_list = [ex for ex in examples if os.path.exists(ex)]
-        
-        if example_list:
-            gr.Examples(
-                examples=example_list,
-                inputs=input_image,
-                label="Example Images"
-            )
-        
-        # Event handlers
-        def update_task_visibility(task):
-            if task == "Object Detection":
-                return gr.update(visible=True), gr.update(visible=False), gr.update(visible=True), gr.update(visible=False)
-            else:
-                return gr.update(visible=False), gr.update(visible=True), gr.update(visible=False), gr.update(visible=True)
-        
-        task_type.change(
-            fn=update_task_visibility,
-            inputs=task_type,
-            outputs=[detection_options, segmentation_results, detection_results, segmentation_results]
+                model_A_threshold_slider = gr.Slider(
+                    minimum=0.1, maximum=0.95, value=0.5, step=0.05, 
+                    label="⚙️ 2. Confidence Threshold for Model A"
+                )
+                user_model_preference_guess = gr.Radio(
+                    ["Model A will be better", "Model B will be better", "They will be similar"], 
+                    label="🤔 3. Your Guess:",
+                    value="Model A will be better"
+                )
+                run_game_button = gr.Button("🚀 Run Detection & Reveal Results!", variant="primary")
+
+            with gr.Group(visible=False) as segmentation_controls_group:
+                gr.Markdown("--- \n ### 🚧 Segmentation Challenge (Coming Soon!)")
+                gr.Markdown("This feature is under active development. Please choose 'Detect Objects' for now.")
+
+    if valid_examples_list:
+        gr.Examples(
+            examples=[[ex_path] for ex_path in valid_examples_list],
+            inputs=[image_uploader],
+            label="✨ Click an Example Image to Load",
+            # cache_examples=True # Set to True if examples are static and processing is heavy
         )
-        
-        # Submit button click event
-        submit_btn.click(
-            fn=process_game,
-            inputs=[input_image, task_type, user_prediction, confidence],
-            outputs=[result_msg, model1_output, model2_output, detection_output, segmentation_output]
+
+    # --- Event Handlers ---
+    def handle_task_selection(selected_task):
+        """Updates visibility of control groups and hides results when task changes."""
+        show_detection = (selected_task == "Detect Objects")
+        return (
+            gr.update(visible=show_detection),       # detection_controls_group
+            gr.update(visible=not show_detection),   # segmentation_controls_group
+            gr.update(visible=False),                # results_feedback_row
+            gr.update(visible=False)                 # results_images_row
         )
+
+    task_type_selector.change(
+        fn=handle_task_selection,
+        inputs=task_type_selector,
+        outputs=[detection_controls_group, segmentation_controls_group, results_feedback_row, results_images_row]
+    )
+
+    def execute_detection_game(image_pil_data, chosen_task, user_guess_str, threshold_for_A):
+        """Main game logic: processes image with both models and returns results."""
+        if image_pil_data is None:
+            msg = "⚠️ **Oops! Please upload an image first.**"
+            return gr.update(value=msg), gr.update(visible=True), gr.update(visible=False), gr.update(value=None), gr.update(value=None)
+
+        if chosen_task != "Detect Objects":
+            msg = f"⚠️ **Hold on!** '{chosen_task}' is not quite ready. Please select 'Detect Objects' to play."
+            return gr.update(value=msg), gr.update(visible=True), gr.update(visible=False), gr.update(value=None), gr.update(value=None)
+
+        threshold_for_B = max(0.05, threshold_for_A - 0.15) # Ensure threshold_B is not too low or negative
         
-        # Add markdown information about the models
-        gr.Markdown("""
-        ## About the Models
-        
-        ### Detection Models:
-        - **Model 1** is Faster R-CNN with ResNet50 backbone, a two-stage detector that's accurate but relatively slower.
-        - **Model 2** is RetinaNet with ResNet50 backbone, a one-stage detector that's designed for better speed-accuracy trade-off.
-        
-        ### Instance Segmentation:
-        - The segmentation model is Mask R-CNN with ResNet50 backbone, which provides pixel-level masks in addition to bounding boxes.
-        
-        ### How is the winner determined?
-        The winner is determined based on a combined score of:
-        1. Number of objects detected
-        2. Average confidence score
-        3. Number of unique classes detected
-        
-        Can you predict which model will perform better on your image?
-        """)
+        print(f"Player guessed: {user_guess_str}", file=sys.stderr)
+        print(f"Model A using threshold: {threshold_for_A:.2f}", file=sys.stderr)
+        print(f"Model B using threshold: {threshold_for_B:.2f}", file=sys.stderr)
+
+        output_path_A = run_detection_on_image(image_pil_data, threshold_for_A, model_A, "Model A")
+        output_path_B = run_detection_on_image(image_pil_data, threshold_for_B, model_B, "Model B")
+
+        feedback_text = (f"💬 You guessed: **{user_guess_str}**.\n\n"
+                         f" দেখে নিন (See the results!): Model A (Threshold: {threshold_for_A:.2f}) vs. Model B (Threshold: {threshold_for_B:.2f})")
         
-    return app
+        return (
+            gr.update(value=feedback_text),                # For user_guess_feedback_display
+            gr.update(visible=True),                       # Make results_feedback_row visible
+            gr.update(visible=True),                       # Make results_images_row visible
+            gr.update(value=output_path_A),                # Set image for output_img_model_A
+            gr.update(value=output_path_B)                 # Set image for output_img_model_B
+        )
+
+    run_game_button.click(
+        fn=execute_detection_game,
+        inputs=[image_uploader, task_type_selector, user_model_preference_guess, model_A_threshold_slider],
+        outputs=[user_guess_feedback_display, results_feedback_row, results_images_row, output_img_model_A, output_img_model_B]
+    )
 
-# Launch the app
 if __name__ == "__main__":
-    app = create_ui()
-    app.launch(debug=True)
+    demo.launch(debug=True) # debug=True is helpful for development