Update app.py

app.py

@@ -1,25 +1,21 @@
-import streamlit as st
+import gradio as gr
 import cv2
-import requests
-import base64
-import json
 import numpy as np
+import time
 from PIL import Image
 import io
-import time
+import base64
+import requests
+import json
+import os
 
-# Page configuration
-st.set_page_config(
-    page_title="Face Analysis with Llama Vision",
-    page_icon="🧠",
-    layout="wide"
-)
+# Initialize face detector
+face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
 
-# Ollama server configuration
+# Ollama server configuration - replace with FaceAPI implementation as needed
 OLLAMA_SERVER = "10.100.20.76:11434"
 MODEL_NAME = "llama3.2-vision:latest"
 
-# Function to encode image for the API
 def encode_image_to_base64(image_array):
     """Convert numpy image array to base64 encoding required by the Ollama API"""
     # Convert numpy array to PIL Image
@@ -33,7 +29,6 @@ def encode_image_to_base64(image_array):
     img_str = base64.b64encode(buffer.getvalue()).decode('utf-8')
     return img_str
 
-# Function to analyze images with the vision model
 def analyze_with_vision_model(image_array):
     """Send image to Ollama vision model and analyze the response"""
     try:
@@ -92,201 +87,91 @@ def analyze_with_vision_model(image_array):
         return gender, age, emotion
     
     except Exception as e:
-        st.error(f"Error analyzing image: {str(e)}")
+        print(f"Error analyzing image: {str(e)}")
         return "Error", "Error", "Error"
 
-# App title and description
-st.title("Face Analysis with Delay & Single Capture")
-st.write("This app waits for 7 seconds to let you position yourself, then detects and analyzes your face.")
-
-# Create layout
-col1, col2 = st.columns([3, 2])
-
-# Webcam display in column 1
-with col1:
-    st.write("### Webcam Feed")
-    webcam_placeholder = st.empty()
-
-# Results display in column 2
-with col2:
-    st.write("### Captured Face")
-    face_placeholder = st.empty()
+def detect_and_analyze(input_image):
+    """Process the uploaded image - detect face and analyze"""
+    if input_image is None:
+        return None, "Please upload an image", "", "", ""
     
-    st.write("### Analysis Results")
-    result_container = st.container()
-    analysis_status = result_container.empty()
-    gender_text = result_container.empty()
-    age_text = result_container.empty()
-    emotion_text = result_container.empty()
-
-# Initialize session state variables
-if 'face_captured' not in st.session_state:
-    st.session_state.face_captured = False
-if 'captured_face' not in st.session_state:
-    st.session_state.captured_face = None
-if 'capture_in_progress' not in st.session_state:
-    st.session_state.capture_in_progress = False
-if 'start_time' not in st.session_state:
-    st.session_state.start_time = None
-
-# Function to reset the app state
-def reset_app():
-    st.session_state.face_captured = False
-    st.session_state.captured_face = None
-    st.session_state.capture_in_progress = False
-    st.session_state.start_time = None
-
-# Create buttons
-col_btn1, col_btn2 = st.columns(2)
-with col_btn1:
-    start_button = st.button("Start Webcam", key="start")
-with col_btn2:
-    reset_button = st.button("Reset", key="reset", on_click=reset_app)
-
-if reset_button:
-    st.rerun()
-
-if start_button or st.session_state.capture_in_progress:
-    # Set capture in progress flag
-    st.session_state.capture_in_progress = True
+    # Convert to numpy array if needed
+    if not isinstance(input_image, np.ndarray):
+        try:
+            input_image = np.array(input_image)
+        except:
+            return None, "Error processing image", "", "", ""
     
-    # Initialize face detector
-    face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+    # Make a copy for display
+    display_image = input_image.copy()
     
-    # Open webcam
-    cap = cv2.VideoCapture(0)
+    # Convert to grayscale for face detection
+    if len(input_image.shape) == 3:  # Color image
+        gray = cv2.cvtColor(input_image, cv2.COLOR_BGR2GRAY)
+    else:  # Already grayscale
+        gray = input_image
     
-    # Set the start time if it's not already set
-    if st.session_state.start_time is None:
-        st.session_state.start_time = time.time()
+    # Detect faces
+    faces = face_cascade.detectMultiScale(gray, 1.1, 4)
     
-    try:
-        # If we haven't captured a face yet
-        if not st.session_state.face_captured:
-            # Define the warm-up period (in seconds)
-            warmup_period = 7  # seconds to wait before starting detection
-            
-            # Loop until we capture a face
-            while True:
-                # Capture frame from webcam
-                ret, frame = cap.read()
-                if not ret:
-                    st.error("Could not access webcam.")
-                    break
-                
-                # Calculate elapsed time
-                elapsed_time = time.time() - st.session_state.start_time
-                remaining_time = max(0, warmup_period - elapsed_time)
-                
-                # Make a copy for display
-                display_frame = frame.copy()
-                
-                # During warm-up period, just show the webcam feed with countdown
-                if elapsed_time < warmup_period:
-                    # Add countdown text to the frame
-                    cv2.putText(
-                        display_frame, 
-                        f"Getting ready... {int(remaining_time)}s", 
-                        (50, 50), 
-                        cv2.FONT_HERSHEY_SIMPLEX, 
-                        1, 
-                        (0, 255, 255), 
-                        2
-                    )
-                    
-                    analysis_status.info(f"Please position yourself... Starting detection in {int(remaining_time)} seconds")
-                else:
-                    # After warm-up, start face detection
-                    analysis_status.info("Detecting face...")
-                    
-                    # Convert to grayscale for face detection
-                    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-                    
-                    # Detect faces
-                    faces = face_cascade.detectMultiScale(gray, 1.1, 4)
-                    
-                    # If faces are detected
-                    if len(faces) > 0:
-                        # Get the largest face (assuming it's the main subject)
-                        largest_face = max(faces, key=lambda rect: rect[2] * rect[3])
-                        (x, y, w, h) = largest_face
-                        
-                        # Draw rectangle around the face
-                        cv2.rectangle(display_frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
-                        
-                        # Extract the face image
-                        face_roi = frame[y:y+h, x:x+w]
-                        
-                        if face_roi.size > 0:
-                            # Capture the face
-                            st.session_state.captured_face = face_roi.copy()
-                            st.session_state.face_captured = True
-                            
-                            # Display the captured face
-                            face_rgb = cv2.cvtColor(face_roi, cv2.COLOR_BGR2RGB)
-                            face_placeholder.image(face_rgb, caption="Captured Face", channels="RGB")
-                            
-                            break
-                    
-                    # Add detecting text to the frame
-                    cv2.putText(
-                        display_frame, 
-                        "Detecting face...", 
-                        (50, 50), 
-                        cv2.FONT_HERSHEY_SIMPLEX, 
-                        1, 
-                        (0, 255, 0), 
-                        2
-                    )
-                
-                # Convert BGR to RGB for display
-                display_rgb = cv2.cvtColor(display_frame, cv2.COLOR_BGR2RGB)
-                
-                # Update the webcam feed
-                webcam_placeholder.image(display_rgb, caption="Camera Feed", channels="RGB")
-                
-                # Short delay to control frame rate
-                time.sleep(0.1)
-                
-        # If we've already captured a face, analyze it
-        if st.session_state.face_captured and st.session_state.captured_face is not None:
-            # Display the analysis status
-            analysis_status.info("Analyzing captured face...")
-            
-            # Analyze the face
-            gender, age, emotion = analyze_with_vision_model(st.session_state.captured_face)
-            
-            # Display results
-            analysis_status.success("Analysis complete!")
-            gender_text.markdown(f"**Gender:** {gender}")
-            age_text.markdown(f"**Age:** {age}")
-            emotion_text.markdown(f"**Emotion:** {emotion}")
-            
-            # Reset the capture in progress flag
-            st.session_state.capture_in_progress = False
-            
-            # Display a final frame with the detected face
-            if st.session_state.captured_face is not None:
-                face_rgb = cv2.cvtColor(st.session_state.captured_face, cv2.COLOR_BGR2RGB)
-                face_placeholder.image(face_rgb, caption="Captured Face", channels="RGB")
-            
-    except Exception as e:
-        st.error(f"An error occurred: {str(e)}")
+    # If faces are detected
+    if len(faces) > 0:
+        # Get the largest face (assuming it's the main subject)
+        largest_face = max(faces, key=lambda rect: rect[2] * rect[3])
+        (x, y, w, h) = largest_face
+        
+        # Extract the face image
+        face_roi = input_image[y:y+h, x:x+w]
+        
+        # Draw rectangle around the face
+        cv2.rectangle(display_image, (x, y), (x+w, y+h), (0, 255, 0), 2)
+        
+        # Analyze the face
+        gender, age, emotion = analyze_with_vision_model(face_roi)
+        
+        return face_roi, "Analysis complete!", gender, age, emotion
     
-    finally:
-        # Release webcam when done
-        cap.release()
+    return None, "No face detected in the image", "", "", ""
 
-# Add some information at the bottom
-st.markdown("---")
-st.markdown("""
-### How it works
-1. Click "Start Webcam" to begin
-2. The app will show your webcam feed for 7 seconds to let you position yourself
-3. After the countdown, it will automatically detect and capture your face
-4. The captured face is sent to the Llama 3.2 Vision model for analysis
-5. Results show gender, age range, and emotion
-6. Click "Reset" to start over
+def main():
+    # Create Gradio interface
+    with gr.Blocks(title="Face Analysis App") as demo:
+        gr.Markdown("# Face Analysis App")
+        gr.Markdown("Upload a face image or take a photo to analyze gender, age, and emotion.")
+        
+        with gr.Row():
+            with gr.Column(scale=3):
+                # For old Gradio versions, use standard Image input
+                image_input = gr.Image(label="Face Image Input")
+                analyze_btn = gr.Button("Analyze Face")
+            
+            with gr.Column(scale=2):
+                face_output = gr.Image(label="Detected Face")
+                status_output = gr.Textbox(label="Status")
+                gender_output = gr.Textbox(label="Gender")
+                age_output = gr.Textbox(label="Age Range")
+                emotion_output = gr.Textbox(label="Emotion")
+        
+        # Connect the components
+        analyze_btn.click(
+            fn=detect_and_analyze,
+            inputs=[image_input],
+            outputs=[face_output, status_output, gender_output, age_output, emotion_output]
+        )
+        
+        gr.Markdown("---")
+        gr.Markdown("""
+        ### How it works
+        1. Upload a photo or take a picture with your webcam
+        2. Click "Analyze Face"
+        3. The app will detect your face and analyze it
+        4. Results will show gender, age range, and emotion
+        
+        For best results, ensure good lighting and position your face clearly in the frame.
+        """)
+    
+    # Launch the app
+    demo.launch(share=True)
 
-For best results, ensure good lighting and position your face clearly in the frame.
-""")
+if __name__ == "__main__":
+    main()