Update app.py

app.py

@@ -21,25 +21,22 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 EMOTION_MAP = {
-    "angry":    {"emoji": "😠", "folder": "angry"},
-    "disgust":  {"emoji": "🤢", "folder": "disgust"},
-    "fear":     {"emoji": "😨", "folder": "fear"},
-    "happy":    {"emoji": "😄", "folder": "happy"},
-    "sad":      {"emoji": "😢", "folder": "sad"},
+    "angry": {"emoji": "😠", "folder": "angry"},
+    "disgust": {"emoji": "🤢", "folder": "disgust"},
+    "fear": {"emoji": "😨", "folder": "fear"},
+    "happy": {"emoji": "😄", "folder": "happy"},
+    "sad": {"emoji": "😢", "folder": "sad"},
     "surprise": {"emoji": "😲", "folder": "surprise"},
-    "neutral":  {"emoji": "😐", "folder": "neutral"}
+    "neutral": {"emoji": "😐", "folder": "neutral"}
 }
 
-BACKENDS = ['mtcnn', 'opencv', 'ssd', 'dlib']
-
+BACKENDS = ['opencv', 'mtcnn', 'ssd', 'dlib']
 BASE_SAVE_DIR = "/tmp/emotion_dataset"
 Path(BASE_SAVE_DIR).mkdir(parents=True, exist_ok=True)
 
-# Create sub-folders per emotion
 for emotion in EMOTION_MAP.values():
     Path(BASE_SAVE_DIR, emotion["folder"]).mkdir(exist_ok=True)
 
-# CSV log file (batch-no, timestamp, emotion, confidence, image_path)
 LOG_CSV = Path(BASE_SAVE_DIR) / "emotion_logs.csv"
 if not LOG_CSV.exists():
     with open(LOG_CSV, "w", newline="", encoding="utf-8") as f:
@@ -51,24 +48,12 @@ if not LOG_CSV.exists():
 # =========
 
 def write_log(batch_no: str, timestamp_iso: str, emotion: str, confidence: float, image_path: str):
-    """Append a row to the CSV log."""
     try:
         with open(LOG_CSV, "a", newline="", encoding="utf-8") as f:
             csv.writer(f).writerow([batch_no, timestamp_iso, emotion, f"{confidence:.2f}", image_path])
     except Exception as e:
         logger.warning(f"Could not write to CSV log: {e}")
 
-
-def clean_old_files(directory: str, max_files_per_emotion: int = 50):
-    for emotion in EMOTION_MAP.values():
-        files = sorted(Path(directory, emotion["folder"]).glob("*.jpg"), key=os.path.getmtime)
-        while len(files) > max_files_per_emotion:
-            try:
-                files.pop(0).unlink()
-            except Exception as ex:
-                logger.warning(f"Failed removing old file: {ex}")
-
-
 def enhance_image(frame: np.ndarray) -> np.ndarray:
     try:
         gray = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)
@@ -77,7 +62,6 @@ def enhance_image(frame: np.ndarray) -> np.ndarray:
     except Exception:
         return frame
 
-
 def save_face_image(face_region: np.ndarray, emotion: str, confidence: float) -> str:
     emotion_data = EMOTION_MAP.get(emotion, EMOTION_MAP["neutral"])
     timestamp = int(time.time())
@@ -91,42 +75,40 @@ def save_face_image(face_region: np.ndarray, emotion: str, confidence: float) ->
 # =====================
 
 last_process_time = 0
+capture_requested = False
 
 def predict_emotion(batch_no: str, input_data):
-    """Gradio callback: returns processed frame + text summary."""
-    global last_process_time
-
-    # throttle to ~3fps
+    global last_process_time, capture_requested
+    
     now = time.time()
     if now - last_process_time < 0.33:
-        placeholder = input_data if isinstance(input_data, np.ndarray) else None
-        return placeholder, "⌛ Processing..."
+        return input_data if isinstance(input_data, np.ndarray) else None, "⌛ Processing..."
     last_process_time = now
 
-    # validate batch number
     batch_no = batch_no.strip() or "UNKNOWN"
 
     if input_data is None:
         return None, "No image input. Check webcam or file upload."
 
-    # load / convert frame
-    if isinstance(input_data, str):  # uploaded file path
+    if isinstance(input_data, str):
         frame = cv2.imread(input_data)
         if frame is None:
             return None, "Error reading uploaded image file."
         frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-    else:  # numpy array from webcam
+    else:
         frame = input_data.copy()
         if frame.ndim == 3 and frame.shape[2] == 4:
             frame = cv2.cvtColor(frame, cv2.COLOR_RGBA2RGB)
 
     frame = enhance_image(frame)
 
-    # face & emotion detection (try multiple backends)
     results = None
     for backend in BACKENDS:
         try:
-            results = DeepFace.analyze(frame, actions=['emotion'], detector_backend=backend, enforce_detection=False, silent=True)
+            results = DeepFace.analyze(frame, actions=['emotion'], 
+                                    detector_backend=backend, 
+                                    enforce_detection=False, 
+                                    silent=True)
             break
         except Exception:
             continue
@@ -137,17 +119,11 @@ def predict_emotion(batch_no: str, input_data):
     emotion_summary = ""
     timestamp_iso = time.strftime("%Y-%m-%dT%H:%M:%S")
 
-    if isinstance(results, list):
-        iterable = results
-    else:
-        iterable = [results]
-
-    for res in iterable:
+    for res in results if isinstance(results, list) else [results]:
         (x, y, w, h) = (res['region'][k] for k in ('x', 'y', 'w', 'h'))
         dom_emotion = res['dominant_emotion']
         conf = res['emotion'][dom_emotion]
 
-        # crop face with padding
         pad = 20
         x1, y1 = max(0, x-pad), max(0, y-pad)
         x2, y2 = min(frame.shape[1], x+w+pad), min(frame.shape[0], y+h+pad)
@@ -155,145 +131,122 @@ def predict_emotion(batch_no: str, input_data):
         if face_region.size == 0:
             continue
 
-        # save face & log row
         img_path = save_face_image(face_region, dom_emotion, conf)
         write_log(batch_no, timestamp_iso, dom_emotion, conf, img_path)
 
-        # draw overlays
         cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
         emoji = EMOTION_MAP[dom_emotion]['emoji']
-        cv2.putText(frame, f"{dom_emotion} {emoji}", (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2)
+        cv2.putText(frame, f"{dom_emotion} {emoji}", (x, y-10), 
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2)
 
         emotion_summary += f"Batch {batch_no} => {dom_emotion.title()} {emoji}: {conf:.1f}%\n"
 
-    clean_old_files(BASE_SAVE_DIR)
     emotion_summary = emotion_summary.strip() or "No emotion data."
     return frame, emotion_summary
 
-# ==========
-# Zip helpers
-# ==========
-
-def get_saved_faces():
-    return [str(p) for p in Path(BASE_SAVE_DIR).rglob("*.jpg")]
-
-
-def create_zip_file(face_files, zip_name: str) -> str | None:
-    if not face_files:
-        return None
-    zip_path = Path(BASE_SAVE_DIR) / zip_name
-    with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zf:
-        for f in face_files:
-            zf.write(f, Path(f).relative_to(BASE_SAVE_DIR))
-    return str(zip_path)
-
 # ========================
 # Gradio Interface Building
 # ========================
 
 def build_interface():
-    with gr.Blocks(title="Emotion Detection & Logging", css=".gradio-container {max-width: 900px !important}") as demo:
+    with gr.Blocks(title="Automated Emotion Detection", css="""
+        .gradio-container {max-width: 900px !important}
+        .capture-btn {background: #ff4d4d !important; color: white !important}
+        """) as demo:
+        
         gr.Markdown("""
-        # Real-Time Emotion Detection with Batch Logging
-        1. **Scan/enter employee batch number**
-        2. **Capture face via webcam** or **upload an image**
-        3. Faces are **saved per emotion** and every detection is **logged** (CSV) with batch number, timestamp & confidence
+        # Automated Emotion Detection System
+        1. **Scan your batch number**
+        2. **System will automatically capture your face after 5 seconds**
+        3. **Emotion analysis results will appear below**
         """)
 
-        with gr.Tabs() as tabs:
-            # ------------- Live Camera Tab -------------
-            with gr.Tab("🎥 Live Camera", id="live_cam_tab") as live_tab:
-                batch_live = gr.Textbox(label="Scan/Enter Batch No", placeholder="e.g. E123")
-                webcam = gr.Image(streaming=True, label="Live Camera", mirror_webcam=True)
-                cam_out = gr.Image(label="Processed Output")
-                cam_txt = gr.Textbox(label="Detection Log")
-                webcam.change(predict_emotion, inputs=[batch_live, webcam], outputs=[cam_out, cam_txt])
-
-            # ------------- Upload Image Tab -------------
-            with gr.Tab("📁 Upload Image", id="upload_tab"):
-                batch_up = gr.Textbox(label="Scan/Enter Batch No", placeholder="e.g. E456")
-                uploader = gr.Image(type="filepath", label="Upload Image")
-                up_out = gr.Image(label="Processed Output")
-                up_txt = gr.Textbox(label="Detection Log")
-                uploader.change(predict_emotion, inputs=[batch_up, uploader], outputs=[up_out, up_txt])
-
-            # ------------- Dataset / Logs Tab -------------
-            with gr.Tab("💾 Dataset & Logs", id="data_tab"):
-                gr.Markdown("### Browse Saved Faces & Download Logs")
-                emotion_select = gr.Dropdown(list(EMOTION_MAP.keys()), value="happy", label="Select Emotion")
-                emo_gallery = gr.Gallery(label="Faces for selected emotion", columns=4)
-                all_gallery = gr.Gallery(label="All Faces", columns=4)
-
-                def refresh_galleries(selected_emotion):
-                    emo_dir = Path(BASE_SAVE_DIR) / EMOTION_MAP[selected_emotion]['folder']
-                    emo_files = [str(p) for p in emo_dir.glob("*.jpg")]
-                    return emo_files, get_saved_faces()
-
-                emotion_select.change(refresh_galleries, inputs=emotion_select, outputs=[emo_gallery, all_gallery])
-                refresh_btn = gr.Button("🔄 Refresh")
-                refresh_btn.click(refresh_galleries, inputs=emotion_select, outputs=[emo_gallery, all_gallery])
-
-                # Download buttons
-                with gr.Row():
-                    download_emo_btn = gr.Button("📦 Download selected emotion faces")
-                    download_all_btn = gr.Button("📦 Download all faces")
-                    download_logs_btn = gr.Button("📔 Download CSV logs")
-                
-                out_emo_zip = gr.File(label="Download", visible=False)
-                out_all_zip = gr.File(label="Download", visible=False)
-                out_logs = gr.File(label="CSV", visible=False)
-
-                def dl_emo(selected_emotion):
-                    emo_dir = Path(BASE_SAVE_DIR) / EMOTION_MAP[selected_emotion]['folder']
-                    zip_path = create_zip_file([str(p) for p in emo_dir.glob("*.jpg")], f"{selected_emotion}_faces.zip")
-                    return gr.File(value=zip_path, visible=bool(zip_path))
-
-                def dl_all():
-                    return gr.File(value=create_zip_file(get_saved_faces(), "all_faces.zip"), visible=True)
-
-                def dl_csv():
-                    return gr.File(value=str(LOG_CSV), visible=True)
-
-                download_emo_btn.click(dl_emo, inputs=emotion_select, outputs=out_emo_zip)
-                download_all_btn.click(dl_all, outputs=out_all_zip)
-                download_logs_btn.click(dl_csv, outputs=out_logs)
-
-                # Clear all data
-                clear_btn = gr.Button("🗑️ Clear ALL faces & logs", variant="stop")
-                def clear_everything():
-                    for f in get_saved_faces():
-                        try: 
-                            Path(f).unlink() 
-                        except: 
-                            pass
-                    try: 
-                        LOG_CSV.unlink() 
-                    except: 
-                        pass
-                    return [], [], gr.File(visible=False), gr.File(visible=False)
-                clear_btn.click(clear_everything, outputs=[emo_gallery, all_gallery, out_emo_zip, out_all_zip])
-
-        # Auto-switch to webcam after batch number is entered
-        batch_live.change(
-            fn=None,
+        batch_no = gr.Textbox(label="Scan/Enter Batch Number", 
+                            placeholder="e.g. EMP123", 
+                            elem_classes=["batch-input"])
+        
+        with gr.Row():
+            webcam = gr.Image(streaming=True, label="Live Camera Feed", 
+                            mirror_webcam=True, visible=False)
+            output_image = gr.Image(label="Processed Result", visible=False)
+        
+        result_text = gr.Textbox(label="Emotion Analysis Result", visible=False)
+        
+        # Hidden components for control flow
+        capture_trigger = gr.Button(visible=False)
+        batch_state = gr.State("UNKNOWN")
+
+        def toggle_components(batch_value):
+            if batch_value.strip():
+                return [
+                    gr.Image(visible=True),  # webcam
+                    gr.Image(visible=False),  # output_image
+                    gr.Textbox(visible=False),  # result_text
+                    True  # trigger capture
+                ]
+            return [gr.Image(visible=False), gr.Image(visible=False), 
+                   gr.Textbox(visible=False), False]
+
+        def capture_and_analyze(batch_value, img):
+            if img is None:
+                return None, None, "No face detected. Please try again."
+            
+            frame = img.copy()
+            if frame.ndim == 3 and frame.shape[2] == 4:
+                frame = cv2.cvtColor(frame, cv2.COLOR_RGBA2RGB)
+            
+            processed_frame, emotion_text = predict_emotion(batch_value, frame)
+            return processed_frame, processed_frame, emotion_text
+
+        # When batch number is entered
+        batch_no.change(
+            toggle_components,
+            inputs=[batch_no],
+            outputs=[webcam, output_image, result_text, capture_trigger]
+        ).then(
+            lambda: time.sleep(5),  # Wait 5 seconds
+            None,
+            None,
+            queue=False
+        ).then(
+            lambda: gr.Button(click=True),  # Trigger capture
+            None,
+            capture_trigger,
+            queue=False
+        )
+
+        # When capture is triggered
+        capture_trigger.click(
+            capture_and_analyze,
+            inputs=[batch_no, webcam],
+            outputs=[webcam, output_image, result_text]
+        )
+
+        demo.load(
+            None,
+            None,
+            None,
             js="""
-            (batchValue) => {
-                if (batchValue && batchValue.trim() !== '') {
-                    setTimeout(() => {
-                        document.querySelectorAll('.tab-nav button')[0].click();
-                    }, 5000);
+            function focusBatchInput() {
+                const batchInput = document.querySelector('.batch-input input');
+                if (batchInput) {
+                    batchInput.focus();
+                    batchInput.addEventListener('input', function(e) {
+                        if (e.target.value.trim() !== '') {
+                            setTimeout(() => {
+                                const webcam = document.querySelector('[aria-label="Live Camera Feed"]');
+                                if (webcam) webcam.click();
+                            }, 5000);
+                        }
+                    });
                 }
-                return [];
             }
+            document.addEventListener('DOMContentLoaded', focusBatchInput);
             """
         )
 
-        # Initial gallery load
-        demo.load(lambda sel="happy": refresh_galleries(sel), outputs=[emo_gallery, all_gallery])
-
     return demo
 
-
 demo = build_interface()
 
 if __name__ == "__main__":