Update app.py

app.py

@@ -1,12 +1,4 @@
 import os
-import csv
-import zipfile
-import shutil
-import re
-from datetime import datetime
-os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
-os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
-
 import cv2
 import gradio as gr
 from deepface import DeepFace
@@ -15,6 +7,7 @@ from PIL import Image
 import time
 from pathlib import Path
 import pandas as pd
+import re
 
 # Configuration
 EMOTION_MAP = {
@@ -48,7 +41,6 @@ def log_emotion(batch_no, emotion, confidence, face_path, annotated_path):
         writer.writerow([timestamp, batch_no, emotion, confidence, str(face_path), str(annotated_path)])
 
 def validate_batch_no(batch_no):
-    """Validate that batch number contains only digits"""
     if not batch_no.strip():
         return False, "Batch number cannot be empty"
     if not re.match(r'^\d+$', batch_no):
@@ -56,7 +48,6 @@ def validate_batch_no(batch_no):
     return True, ""
 
 def process_frame(batch_no, frame):
-    """Process a single frame for emotion detection"""
     if not batch_no.strip() or frame is None:
         return None, None, "Waiting for input...", False, False
     
@@ -88,567 +79,142 @@ def process_frame(batch_no, frame):
         confidence = result['emotion'][emotion]
         region = result['region']
         
-        # Extract face coordinates
         x, y, w, h = region['x'], region['y'], region['w'], region['h']
         
-        # Save raw face crop
-        face_crop = frame[y:y+h, x:x+w]
+        # Save files and log data
         timestamp = int(time.time())
         face_dir = SAVE_DIR / "faces" / emotion
         face_path = face_dir / f"{batch_no}_{timestamp}.jpg"
-        cv2.imwrite(str(face_path), face_crop)
+        cv2.imwrite(str(face_path), frame[y:y+h, x:x+w])
         
-        # Create and save annotated image
-        annotated_frame = frame.copy()
-        cv2.rectangle(annotated_frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
-        cv2.putText(annotated_frame, f"{emotion} {EMOTION_MAP[emotion]} {confidence:.1f}%", 
-                   (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2)
+        annotated = frame.copy()
+        cv2.rectangle(annotated, (x,y), (x+w,y+h), (0,255,0), 2)
+        cv2.putText(annotated, f"{emotion} {confidence:.1f}%", 
+                   (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0,255,0), 2)
         
         annotated_dir = SAVE_DIR / "annotated" / emotion
         annotated_path = annotated_dir / f"{batch_no}_{timestamp}.jpg"
-        cv2.imwrite(str(annotated_path), annotated_frame)
+        cv2.imwrite(str(annotated_path), annotated)
         
-        # Log both paths
         log_emotion(batch_no, emotion, confidence, face_path, annotated_path)
         
-        # Convert back to PIL format for display
-        output_img = Image.fromarray(cv2.cvtColor(annotated_frame, cv2.COLOR_BGR2RGB))
-        return output_img, f"Batch {batch_no}: {emotion.title()} ({confidence:.1f}%)", "", True, True
-    
-    except Exception as e:
-        return None, None, f"Error: {str(e)}", False, False
-
-def process_batch_input(batch_no):
-    """Handle batch number input and activate webcam"""
-    is_valid, validation_msg = validate_batch_no(batch_no)
-    if not is_valid:
         return (
-            gr.Textbox(interactive=True),
-            gr.Textbox(value=validation_msg, visible=bool(validation_msg)),
-            gr.Image(visible=False),
-            gr.Image(visible=False),
-            gr.Textbox(visible=False),
-            gr.Button(visible=False),
-            gr.Textbox(visible=False)  # For trigger
+            Image.fromarray(cv2.cvtColor(annotated, cv2.COLOR_BGR2RGB)),
+            f"Batch {batch_no}: {emotion.title()} ({confidence:.1f}%)",
+            "",
+            True,
+            True
         )
     
-    return (
-        gr.Textbox(interactive=False),
-        gr.Textbox(value="Webcam activated - position your face", visible=True),
-        gr.Image(visible=True, streaming=True),
-        gr.Image(visible=False),
-        gr.Textbox(visible=False),
-        gr.Button(visible=False),
-        gr.Textbox(value=str(time.time()), visible=False)  # Initialize trigger
-    )
-
-def reset_interface():
-    """Reset the interface to initial state"""
-    return (
-        gr.Textbox(value="", interactive=True),
-        gr.Textbox(value="", visible=False),
-        gr.Image(value=None, visible=False),
-        gr.Image(visible=False),
-        gr.Textbox(visible=False),
-        gr.Button(visible=False),
-        gr.Textbox(visible=False)
-    )
-
-def get_image_gallery(emotion, image_type):
-    """Get image gallery for selected emotion and type"""
-    if emotion == "All Emotions":
-        image_dict = {}
-        for emot in EMOTION_MAP.keys():
-            folder = SAVE_DIR / image_type / emot
-            image_dict[emot] = [str(f) for f in folder.glob("*.jpg") if f.exists()]
-    else:
-        folder = SAVE_DIR / image_type / emotion
-        image_dict = {emotion: [str(f) for f in folder.glob("*.jpg") if f.exists()]}
-    return image_dict
-
-def create_custom_zip(file_paths):
-    """Create zip from selected images and return the file path"""
-    if not file_paths:
-        return None
-    
-    temp_dir = SAVE_DIR / "temp_downloads"
-    temp_dir.mkdir(exist_ok=True)
-    zip_path = temp_dir / f"emotion_images_{int(time.time())}.zip"
-    
-    if zip_path.exists():
-        try:
-            zip_path.unlink()
-        except Exception as e:
-            print(f"Error deleting old zip: {e}")
-    
-    try:
-        with zipfile.ZipFile(zip_path, 'w') as zipf:
-            for file_path in file_paths:
-                file_path = Path(file_path)
-                if file_path.exists():
-                    zipf.write(file_path, arcname=file_path.name)
-        return str(zip_path) if zip_path.exists() else None
-    except Exception as e:
-        print(f"Error creating zip file: {e}")
-        return None
-
-def download_all_emotions_structured():
-    """Download all emotions in a structured ZIP with folders for each emotion"""
-    temp_dir = SAVE_DIR / "temp_downloads"
-    temp_dir.mkdir(exist_ok=True)
-    zip_path = temp_dir / f"all_emotions_structured_{int(time.time())}.zip"
-    
-    if zip_path.exists():
-        try:
-            zip_path.unlink()
-        except Exception as e:
-            print(f"Error deleting old zip: {e}")
-    
-    try:
-        with zipfile.ZipFile(zip_path, 'w') as zipf:
-            for emotion in EMOTION_MAP.keys():
-                # Add faces
-                face_dir = SAVE_DIR / "faces" / emotion
-                for face_file in face_dir.glob("*.jpg"):
-                    if face_file.exists():
-                        arcname = f"faces/{emotion}/{face_file.name}"
-                        zipf.write(face_file, arcname=arcname)
-                
-                # Add annotated images
-                annotated_dir = SAVE_DIR / "annotated" / emotion
-                for annotated_file in annotated_dir.glob("*.jpg"):
-                    if annotated_file.exists():
-                        arcname = f"annotated/{emotion}/{annotated_file.name}"
-                        zipf.write(annotated_file, arcname=arcname)
-        return str(zip_path) if zip_path.exists() else None
-    except Exception as e:
-        print(f"Error creating structured zip file: {e}")
-        return None
-
-def delete_selected_images(selected_images):
-    """Delete selected images with proper validation"""
-    if not selected_images:
-        return "No images selected for deletion"
-    
-    deleted_count = 0
-    failed_deletions = []
-    
-    for img_path in selected_images:
-        img_path = Path(img_path)
-        try:
-            if img_path.exists():
-                img_path.unlink()
-                deleted_count += 1
-            else:
-                failed_deletions.append(str(img_path))
-        except Exception as e:
-            print(f"Error deleting {img_path}: {e}")
-            failed_deletions.append(str(img_path))
-    
-    if deleted_count > 0 and LOG_FILE.exists():
-        try:
-            df = pd.read_csv(LOG_FILE)
-            for img_path in selected_images:
-                img_path = str(img_path)
-                if "faces" in img_path:
-                    df = df[df.face_path != img_path]
-                else:
-                    df = df[df.annotated_path != img_path]
-            df.to_csv(LOG_FILE, index=False)
-        except Exception as e:
-            print(f"Error updating logs: {e}")
-    
-    status_msg = f"Deleted {deleted_count} images"
-    if failed_deletions:
-        status_msg += f"\nFailed to delete {len(failed_deletions)} images"
-    return status_msg
-
-def delete_images_in_category(emotion, image_type, confirm=False):
-    """Delete all images in a specific category with confirmation"""
-    if not confirm:
-        return "Please check the confirmation box to delete all images in this category"
-    
-    if emotion == "All Emotions":
-        deleted_count = 0
-        for emot in EMOTION_MAP.keys():
-            deleted_count += delete_images_in_category(emot, image_type, confirm=True)
-        return f"Deleted {deleted_count} images across all emotion categories"
-    
-    folder = SAVE_DIR / image_type / emotion
-    deleted_count = 0
-    failed_deletions = []
-    
-    for file in folder.glob("*"):
-        if file.is_file():
-            try:
-                file.unlink()
-                deleted_count += 1
-            except Exception as e:
-                print(f"Error deleting {file}: {e}")
-                failed_deletions.append(str(file))
-    
-    if deleted_count > 0 and LOG_FILE.exists():
-        try:
-            df = pd.read_csv(LOG_FILE)
-            if image_type == "faces":
-                df = df[df.emotion != emotion]
-            else:
-                df = df[~((df.emotion == emotion) & (df.annotated_path.str.contains(str(folder))))]
-            df.to_csv(LOG_FILE, index=False)
-        except Exception as e:
-            print(f"Error updating logs: {e}")
-    
-    status_msg = f"Deleted {deleted_count} images from {emotion}/{image_type}"
-    if failed_deletions:
-        status_msg += f"\nFailed to delete {len(failed_deletions)} images"
-    return status_msg
-
-def get_logs():
-    if LOG_FILE.exists():
-        return pd.read_csv(LOG_FILE)
-    return pd.DataFrame()
-
-def view_logs():
-    df = get_logs()
-    if not df.empty:
-        try:
-            return df.to_markdown()
-        except ImportError:
-            return df.to_string()
-    return "No logs available yet"
-
-def download_logs():
-    if LOG_FILE.exists():
-        temp_dir = SAVE_DIR / "temp_downloads"
-        temp_dir.mkdir(exist_ok=True)
-        download_path = temp_dir / "emotion_logs.csv"
-        shutil.copy2(LOG_FILE, download_path)
-        return str(download_path)
-    return None
-
-def clear_all_data():
-    """Clear all images and logs"""
-    deleted_count = 0
-    
-    for emotion in EMOTION_MAP.keys():
-        for img_type in ["faces", "annotated"]:
-            folder = SAVE_DIR / img_type / emotion
-            for file in folder.glob("*"):
-                if file.is_file():
-                    try:
-                        file.unlink()
-                        deleted_count += 1
-                    except Exception as e:
-                        print(f"Error deleting {file}: {e}")
-    
-    temp_dir = SAVE_DIR / "temp_downloads"
-    if temp_dir.exists():
-        try:
-            shutil.rmtree(temp_dir)
-        except Exception as e:
-            print(f"Error deleting temp directory: {e}")
-    
-    if LOG_FILE.exists():
-        try:
-            LOG_FILE.unlink()
-        except Exception as e:
-            print(f"Error deleting log file: {e}")
-    
-    try:
-        with open(LOG_FILE, 'w', newline='') as f:
-            writer = csv.writer(f)
-            writer.writerow(["timestamp", "batch_no", "emotion", "confidence", "face_path", "annotated_path"])
     except Exception as e:
-        print(f"Error recreating log file: {e}")
-    
-    empty_df = pd.DataFrame(columns=["timestamp", "batch_no", "emotion", "confidence", "face_path", "annotated_path"])
-    return f"Deleted {deleted_count} items. All data has been cleared.", empty_df, None
+        return None, None, f"Error: {str(e)}", False, False
 
-# Capture Interface
-with gr.Blocks(title="Emotion Capture", css="""
-    .gradio-container { max-width: 800px !important }
-    .message { color: red; font-weight: bold; }
-    .status { color: blue; font-weight: bold; }
-    .gallery { grid-template-columns: repeat(auto-fill, minmax(200px, 1fr)); }
-    .disabled-input { background-color: #f0f0f0; }
-""") as capture_interface:
-    
-    gr.Markdown("""
-    # Automatic Emotion Capture
-    1. Enter/scan your batch number (numbers only)
-    2. Webcam will activate automatically
-    3. System detects your face continuously
-    4. Results appear instantly
-    5. Click "Done" to reset
-    """)
+# Main Interface
+with gr.Blocks(title="Auto Emotion Detection") as interface:
+    gr.Markdown("# Automatic Emotion Detection")
+    gr.Markdown("1. Enter your batch number\n2. Webcam will activate automatically\n3. System will detect your face\n4. Results will appear")
     
     with gr.Row():
-        batch_no = gr.Textbox(
+        batch_input = gr.Textbox(
             label="Batch Number", 
-            placeholder="Enter or scan numbers only",
+            placeholder="Enter numbers only",
             interactive=True
         )
-    
-    status = gr.Textbox(
-        label="Status", 
-        interactive=False, 
-        elem_classes="status",
-        visible=False
-    )
+        status = gr.Textbox(
+            label="Status",
+            interactive=False,
+            visible=False
+        )
     
     with gr.Row():
         webcam = gr.Image(
             sources=["webcam"],
-            type="pil",
-            label="Face Capture",
             streaming=True,
             mirror_webcam=True,
             visible=False,
             interactive=False
         )
-    
-    with gr.Row():
         result_img = gr.Image(
-            label="Analysis Result", 
-            interactive=False, 
+            label="Result",
             visible=False
         )
     
     with gr.Row():
         result_text = gr.Textbox(
-            label="Emotion Result", 
-            interactive=False, 
+            label="Analysis",
             visible=False
         )
-    
-    with gr.Row():
         done_btn = gr.Button(
-            "Done", 
+            "Done",
             visible=False
         )
     
     # Hidden trigger for continuous processing
     trigger = gr.Textbox(visible=False)
     
-    # Auto-activate webcam on valid batch number
-    batch_no.change(
-        process_batch_input,
-        inputs=batch_no,
-        outputs=[batch_no, status, webcam, result_img, result_text, done_btn, trigger]
-    )
-    
-    # Continuous face detection processing chain
-    def process_and_retrigger(batch_no, webcam_img, trigger_val):
-        # Process current frame
-        result_img, result_text, msg, show_img, show_text = process_frame(batch_no, webcam_img)
+    def handle_batch_input(batch_no):
+        is_valid, msg = validate_batch_no(batch_no)
+        if not is_valid:
+            return (
+                gr.Textbox(interactive=True),
+                gr.Textbox(value=msg, visible=bool(msg)),
+                gr.Image(visible=False),
+                gr.Image(visible=False),
+                gr.Textbox(visible=False),
+                gr.Button(visible=False),
+                gr.Textbox(visible=False)
+            )
         
-        # Return outputs plus updated trigger
-        return result_img, result_text, msg, show_img, show_text, gr.Textbox.update(value=str(time.time()))
+        return (
+            gr.Textbox(interactive=False),
+            gr.Textbox(value="Webcam activated - position your face", visible=True),
+            gr.Image(visible=True),
+            gr.Image(visible=False),
+            gr.Textbox(visible=False),
+            gr.Button(visible=False),
+            gr.Textbox(value=str(time.time()), visible=False)
+        )
     
-    webcam.change(
-        process_and_retrigger,
-        inputs=[batch_no, webcam, trigger],
-        outputs=[result_img, result_text, status, result_img, result_text, trigger]
-    )
+    def process_and_continue(batch_no, frame, trigger_val):
+        result_img, result_text, msg, show_img, show_text = process_frame(batch_no, frame)
+        return (
+            result_img, 
+            result_text, 
+            msg, 
+            show_img, 
+            show_text, 
+            gr.Textbox.update(value=str(time.time()))
+        )
     
-    # Reset interface
-    done_btn.click(
-        reset_interface,
-        outputs=[batch_no, status, webcam, result_img, result_text, done_btn, trigger]
+    # Setup event handlers
+    batch_input.change(
+        handle_batch_input,
+        inputs=batch_input,
+        outputs=[batch_input, status, webcam, result_img, result_text, done_btn, trigger]
     )
-
-# Data Management Interface
-with gr.Blocks(title="Data Management") as data_interface:
     
-    gr.Markdown("# Data Management Interface")
+    webcam.change(
+        process_and_continue,
+        inputs=[batch_input, webcam, trigger],
+        outputs=[result_img, result_text, status, result_img, result_text, trigger],
+        queue=False
+    )
     
-    with gr.Tab("Image Management"):
-        with gr.Column():
-            gr.Markdown("## Select and Manage Images")
-            with gr.Row():
-                emotion_selector = gr.Dropdown(
-                    choices=["All Emotions"] + list(EMOTION_MAP.keys()),
-                    label="Emotion Category",
-                    value="All Emotions"
-                )
-                image_type_selector = gr.Dropdown(
-                    choices=["faces", "annotated"],
-                    label="Image Type",
-                    value="faces"
-                )
-                refresh_btn = gr.Button("Refresh Gallery")
-            
-            current_image_paths = gr.State([])
-            
-            gallery = gr.Gallery(
-                label="Image Gallery",
-                columns=4
-            )
-            selected_images = gr.CheckboxGroup(
-                label="Selected Images",
-                interactive=True,
-                value=[]
-            )
-            
-            with gr.Row(variant="panel"):
-                with gr.Column():
-                    gr.Markdown("### Download Options")
-                    download_btn = gr.Button("Download Selected", variant="primary")
-                    download_all_btn = gr.Button("Download All in Category")
-                    download_structured_btn = gr.Button("Download All (Structured)", variant="primary")
-                    download_output = gr.File(label="Download Result", visible=False)
-                
-                with gr.Column():
-                    gr.Markdown("### Delete Options")
-                    delete_btn = gr.Button("Delete Selected", variant="stop")
-                    with gr.Row():
-                        delete_confirm = gr.Checkbox(label="I confirm I want to delete ALL images in this category", value=False)
-                        delete_all_btn = gr.Button("Delete All in Category", variant="stop", interactive=False)
-                    delete_output = gr.Textbox(label="Delete Status")
-            
-            def update_gallery_components(emotion, image_type):
-                image_dict = get_image_gallery(emotion, image_type)
-                gallery_items = []
-                image_paths = []
-                for emotion, images in image_dict.items():
-                    for img_path in images:
-                        gallery_items.append((img_path, f"{emotion}: {Path(img_path).name}"))
-                        image_paths.append(img_path)
-                return gallery_items, image_paths
-            
-            initial_gallery, initial_paths = update_gallery_components("All Emotions", "faces")
-            gallery.value = initial_gallery
-            current_image_paths.value = initial_paths
-            selected_images.choices = initial_paths
-            
-            def update_components(emotion, image_type):
-                gallery_items, image_paths = update_gallery_components(emotion, image_type)
-                return {
-                    gallery: gallery_items,
-                    current_image_paths: image_paths,
-                    selected_images: gr.CheckboxGroup(choices=image_paths, value=[])
-                }
-            
-            emotion_selector.change(
-                update_components,
-                inputs=[emotion_selector, image_type_selector],
-                outputs=[gallery, current_image_paths, selected_images]
-            )
-            
-            image_type_selector.change(
-                update_components,
-                inputs=[emotion_selector, image_type_selector],
-                outputs=[gallery, current_image_paths, selected_images]
-            )
-            
-            refresh_btn.click(
-                update_components,
-                inputs=[emotion_selector, image_type_selector],
-                outputs=[gallery, current_image_paths, selected_images]
-            )
-            
-            download_btn.click(
-                lambda selected: create_custom_zip(selected),
-                inputs=selected_images,
-                outputs=download_output,
-                api_name="download_selected"
-            ).then(
-                lambda x: gr.File(visible=x is not None),
-                inputs=download_output,
-                outputs=download_output
-            )
-            
-            download_all_btn.click(
-                lambda emotion, img_type: create_custom_zip(
-                    [str(f) for f in (SAVE_DIR / img_type / (emotion if emotion != "All Emotions" else "*")).glob("*.jpg") if f.exists()]
-                ),
-                inputs=[emotion_selector, image_type_selector],
-                outputs=download_output,
-                api_name="download_all"
-            ).then(
-                lambda x: gr.File(visible=x is not None),
-                inputs=download_output,
-                outputs=download_output
-            )
-            
-            download_structured_btn.click(
-                download_all_emotions_structured,
-                outputs=download_output,
-                api_name="download_all_structured"
-            ).then(
-                lambda x: gr.File(visible=x is not None),
-                inputs=download_output,
-                outputs=download_output
-            )
-            
-            delete_btn.click(
-                lambda selected: {
-                    "delete_output": delete_selected_images(selected),
-                    **update_components(emotion_selector.value, image_type_selector.value)
-                },
-                inputs=selected_images,
-                outputs=[delete_output, gallery, current_image_paths, selected_images]
-            )
-            
-            delete_confirm.change(
-                lambda x: gr.Button(interactive=x),
-                inputs=delete_confirm,
-                outputs=delete_all_btn
-            )
-            
-            delete_all_btn.click(
-                lambda emotion, img_type, confirm: {
-                    "delete_output": delete_images_in_category(emotion, img_type, confirm),
-                    **update_components(emotion, img_type)
-                },
-                inputs=[emotion_selector, image_type_selector, delete_confirm],
-                outputs=[delete_output, gallery, current_image_paths, selected_images]
-            )
+    def reset_all():
+        return (
+            gr.Textbox(value="", interactive=True),
+            gr.Textbox(value="", visible=False),
+            gr.Image(visible=False),
+            gr.Image(visible=False),
+            gr.Textbox(visible=False),
+            gr.Button(visible=False),
+            gr.Textbox(visible=False)
+        )
     
-    with gr.Tab("Emotion Logs"):
-        with gr.Column():
-            gr.Markdown("## Emotion Analysis Logs")
-            with gr.Row():
-                refresh_logs_btn = gr.Button("Refresh Logs")
-                download_logs_btn = gr.Button("Download Logs as CSV")
-                clear_all_btn = gr.Button("Clear All Data", variant="stop")
-            
-            logs_display = gr.Markdown()
-            logs_csv = gr.File(label="Logs Download", visible=False)
-            clear_message = gr.Textbox(label="Status", interactive=False)
-            
-            refresh_logs_btn.click(
-                view_logs,
-                outputs=logs_display
-            )
-            
-            download_logs_btn.click(
-                download_logs,
-                outputs=logs_csv,
-                api_name="download_logs"
-            ).then(
-                lambda x: gr.File(visible=x is not None),
-                inputs=logs_csv,
-                outputs=logs_csv
-            )
-            
-            clear_all_btn.click(
-                clear_all_data,
-                outputs=[clear_message, logs_display, logs_csv]
-            ).then(
-                lambda: update_components("All Emotions", "faces"),
-                outputs=[gallery, current_image_paths]
-            ).then(
-                lambda: gr.CheckboxGroup(choices=[], value=[]),
-                outputs=selected_images
-            )
-
-# Combine interfaces
-demo = gr.TabbedInterface(
-    [capture_interface, data_interface],
-    ["Emotion Capture", "Data Management"],
-    css=".gradio-container { max-width: 1200px !important }"
-)
+    done_btn.click(
+        reset_all,
+        outputs=[batch_input, status, webcam, result_img, result_text, done_btn, trigger]
+    )
 
 if __name__ == "__main__":
-    demo.launch()
+    interface.launch()