Update app.py

app.py

@@ -1,126 +1,97 @@
 import gradio as gr
 
 import gradio as gr
-import cv2
 import numpy as np
-from PIL import Image
 import time
 
-# Assuming you have these functions from your ML/DL code
-# def load_model():
-#     # Your model loading code
-#     pass
-# def preprocess_image(img):
-#     # Your preprocessing code
-#     pass
-# def predict_spoof(img):
-#     # Your prediction code
-#     pass
+def placeholder_process(image):
+    """Placeholder function - replace with your backend integration"""
+    time.sleep(1)  # Simulate processing time
+    return image, "Real", 0.95
 
-def process_webcam_frame(frame):
-    # Convert frame to RGB (Gradio webcam outputs BGR)
-    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-    
-    # Make prediction (you'll need to implement this with your model)
-    # result = predict_spoof(frame_rgb)
-    # For demonstration, using a placeholder result
-    result = {"prediction": "Real", "confidence": 0.95}
-    
-    # Add overlay text to frame
-    text = f"Prediction: {result['prediction']}"
-    conf_text = f"Confidence: {result['confidence']:.2f}"
-    
-    # Create a semi-transparent overlay
-    overlay = frame_rgb.copy()
-    cv2.rectangle(overlay, (10, 10), (300, 80), (0, 0, 0), -1)
-    frame_rgb = cv2.addWeighted(overlay, 0.3, frame_rgb, 0.7, 0)
-    
-    # Add text
-    cv2.putText(frame_rgb, text, (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 
-                0.8, (255, 255, 255), 2)
-    cv2.putText(frame_rgb, conf_text, (20, 70), cv2.FONT_HERSHEY_SIMPLEX, 
-                0.8, (255, 255, 255), 2)
-    
-    return frame_rgb
-
-def process_uploaded_image(image):
-    # Convert to RGB if needed
-    if isinstance(image, np.ndarray):
-        if len(image.shape) == 3 and image.shape[2] == 3:
-            image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
-        else:
-            image_rgb = image
-    else:
-        image_rgb = np.array(image)
-    
-    # Make prediction (implement with your model)
-    # result = predict_spoof(image_rgb)
-    # Placeholder result
-    result = {"prediction": "Spoof", "confidence": 0.88}
-    
-    # Create output image with overlay
-    output_img = image_rgb.copy()
-    h, w = output_img.shape[:2]
-    
-    # Add semi-transparent overlay
-    overlay = output_img.copy()
-    cv2.rectangle(overlay, (10, 10), (300, 80), (0, 0, 0), -1)
-    output_img = cv2.addWeighted(overlay, 0.3, output_img, 0.7, 0)
-    
-    # Add prediction text
-    text = f"Prediction: {result['prediction']}"
-    conf_text = f"Confidence: {result['confidence']:.2f}"
-    
-    cv2.putText(output_img, text, (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 
-                0.8, (255, 255, 255), 2)
-    cv2.putText(output_img, conf_text, (20, 70), cv2.FONT_HERSHEY_SIMPLEX, 
-                0.8, (255, 255, 255), 2)
-    
-    return output_img
+def format_result(image, label, confidence):
+    """Format and display the result"""
+    return (
+        image, 
+        f"Detection Result: {label}", 
+        f"Confidence Score: {confidence:.2%}",
+        gr.update(visible=True)
+    )
 
-# Create Gradio interface
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    # Header
     gr.Markdown("""
-    # Face Spoofing Detection
-    Upload an image or use your webcam to detect face spoofing attempts in real-time.
+    # Face Spoofing Detection System
+    ### Detect real vs spoofed faces in real-time or from uploaded images
     """)
     
+    # Main Interface
     with gr.Tabs():
+        # Webcam Tab
         with gr.Tab("Webcam Detection"):
             with gr.Row():
-                webcam_input = gr.Image(source="webcam", streaming=True)
-                webcam_output = gr.Image()
-            webcam_input.stream(
-                process_webcam_frame,
-                inputs=webcam_input,
-                outputs=webcam_output,
-                show_progress=False
-            )
+                with gr.Column(scale=2):
+                    webcam = gr.Image(source="webcam", streaming=True, label="Webcam Feed")
+                with gr.Column(scale=1):
+                    webcam_status = gr.Textbox(label="Status", value="Ready", interactive=False)
+                    webcam_result = gr.Textbox(label="Detection", interactive=False)
+                    webcam_conf = gr.Textbox(label="Confidence", interactive=False)
+                    webcam_alert = gr.Alert(visible=False)
+            
+            webcam_button = gr.Button("Start Detection", variant="primary")
         
+        # Image Upload Tab
         with gr.Tab("Image Upload"):
             with gr.Row():
-                image_input = gr.Image(type="numpy", label="Upload Image")
-                image_output = gr.Image(type="numpy", label="Detection Result")
+                with gr.Column(scale=2):
+                    image_input = gr.Image(label="Upload Image", type="numpy")
+                with gr.Column(scale=1):
+                    image_status = gr.Textbox(label="Status", value="Ready", interactive=False)
+                    image_result = gr.Textbox(label="Detection", interactive=False)
+                    image_conf = gr.Textbox(label="Confidence", interactive=False)
+                    image_alert = gr.Alert(visible=False)
             
-            image_button = gr.Button("Detect Spoofing")
-            image_button.click(
-                process_uploaded_image,
-                inputs=image_input,
-                outputs=image_output
-            )
+            image_button = gr.Button("Analyze Image", variant="primary")
     
-    gr.Markdown("""
-    ### How it works
-    This system uses advanced deep learning techniques to detect whether a face is real or spoofed (e.g., displayed on a screen or printed on paper).
+    # Info Section
+    with gr.Accordion("Information", open=False):
+        gr.Markdown("""
+        ### How to Use
+        1. Choose either Webcam or Image Upload mode
+        2. For webcam: Click 'Start Detection' to begin real-time analysis
+        3. For images: Upload an image and click 'Analyze Image'
+        
+        ### Best Practices
+        - Ensure good lighting conditions
+        - Position face clearly in the frame
+        - Keep steady and avoid rapid movements
+        - For best results, maintain a distance of 30-60cm from the camera
+        
+        ### System Requirements
+        - Webcam with minimum 720p resolution (for live detection)
+        - Stable internet connection
+        - Supported browsers: Chrome, Firefox, Safari
+        """)
     
-    ### Tips
-    - Ensure good lighting for better detection
-    - Keep your face centered in the frame
-    - For uploaded images, make sure the face is clearly visible
-    """)
+    # Event handlers
+    def update_status(is_webcam=True):
+        prefix = "Webcam" if is_webcam else "Image"
+        return f"{prefix} analysis in progress..."
+    
+    image_button.click(
+        fn=lambda img: (update_status(False), *placeholder_process(img)),
+        inputs=[image_input],
+        outputs=[image_status, image_input, image_result, image_conf, image_alert]
+    )
+    
+    webcam_button.click(
+        fn=lambda img: (update_status(True), *placeholder_process(img)),
+        inputs=[webcam],
+        outputs=[webcam_status, webcam, webcam_result, webcam_conf, webcam_alert]
+    )
 
+# Launch the interface
 if __name__ == "__main__":
     demo.launch(share=True)
-
 # demo = gr.Interface(fn=greet, inputs="text", outputs="text")
 # demo.launch()