Update app.py

app.py

@@ -1,4 +1,12 @@
 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
@@ -7,7 +15,6 @@ from PIL import Image
 import time
 from pathlib import Path
 import pandas as pd
-import re
 
 # Configuration
 EMOTION_MAP = {
@@ -41,21 +48,27 @@ 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):
         return False, "Batch number must contain only numbers"
     return True, ""
 
-def process_frame(batch_no, frame):
-    if not batch_no.strip() or frame is None:
-        return None, None, "Waiting for input...", False, False
+def predict_emotion(batch_no: str, image):
+    if not batch_no.strip():
+        return None, None, "Please enter a batch number first", gr.Image(visible=False), gr.Textbox(visible=False), gr.Button(visible=False)
+    
+    if image is None:
+        return None, None, "Please capture your face first", gr.Image(visible=False), gr.Textbox(visible=False), gr.Button(visible=False)
     
     try:
-        frame = np.array(frame)
+        # Convert PIL Image to OpenCV format
+        frame = np.array(image)
         if frame.ndim == 3:
             frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
         
+        # Try different backends for face detection
         results = None
         for backend in BACKENDS:
             try:
@@ -63,158 +76,604 @@ def process_frame(batch_no, frame):
                     frame, 
                     actions=['emotion'],
                     detector_backend=backend,
-                    enforce_detection=False,
+                    enforce_detection=True,
                     silent=True
                 )
-                if results:
-                    break
+                break
             except Exception:
                 continue
 
         if not results:
-            return None, None, "Position your face in frame", False, False
+            return None, None, "No face detected. Please try again.", gr.Image(visible=False), gr.Textbox(visible=False), gr.Button(visible=False)
 
-        result = results[0]
+        # Process the first face found
+        result = results[0] if isinstance(results, list) else results
         emotion = result['dominant_emotion']
         confidence = result['emotion'][emotion]
         region = result['region']
         
+        # Extract face coordinates
         x, y, w, h = region['x'], region['y'], region['w'], region['h']
         
-        # Save files and log data
+        # 1. Save raw face crop
+        face_crop = frame[y:y+h, x:x+w]
         timestamp = int(time.time())
         face_dir = SAVE_DIR / "faces" / emotion
         face_path = face_dir / f"{batch_no}_{timestamp}.jpg"
-        cv2.imwrite(str(face_path), frame[y:y+h, x:x+w])
+        cv2.imwrite(str(face_path), face_crop)
         
-        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)
+        # 2. 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_dir = SAVE_DIR / "annotated" / emotion
         annotated_path = annotated_dir / f"{batch_no}_{timestamp}.jpg"
-        cv2.imwrite(str(annotated_path), annotated)
+        cv2.imwrite(str(annotated_path), annotated_frame)
         
+        # 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}%)", "", gr.Image(visible=True), gr.Textbox(visible=True), gr.Button(visible=True)
+    
+    except Exception as e:
+        return None, None, f"Error processing image: {str(e)}", gr.Image(visible=False), gr.Textbox(visible=False), gr.Button(visible=False)
+
+def check_batch_no(batch_no):
+    """Check if batch number is entered and valid"""
+    is_valid, validation_msg = validate_batch_no(batch_no)
+    if not is_valid:
+        return (
+            gr.Textbox(interactive=True),  # Keep batch_no interactive
+            gr.Textbox(value=validation_msg, visible=bool(validation_msg)),  # Show validation message
+            gr.Image(visible=False),       # Hide webcam
+            gr.Image(visible=False),       # Hide result image
+            gr.Textbox(visible=False),     # Hide result text
+            gr.Button(visible=False)       # Hide done button
+        )
+    
+    # After validation, disable input and show countdown
+    return (
+        gr.Textbox(interactive=False),     # Disable batch_no
+        gr.Textbox(value="Processing will start in 5 seconds...", visible=True),  # Show countdown
+        gr.Image(visible=False),           # Keep webcam hidden initially
+        gr.Image(visible=False),           # Hide result image
+        gr.Textbox(visible=False),         # Hide result text
+        gr.Button(visible=False)           # Hide done button
+    )
+
+def activate_webcam(batch_no):
+    """Actually activate the webcam after the delay"""
+    is_valid, _ = validate_batch_no(batch_no)
+    if not is_valid:
         return (
-            Image.fromarray(cv2.cvtColor(annotated, cv2.COLOR_BGR2RGB)),
-            f"Batch {batch_no}: {emotion.title()} ({confidence:.1f}%)",
-            "",
-            True,
-            True
+            gr.Textbox(interactive=True),  # Re-enable batch_no if invalid
+            gr.Textbox(visible=False),     # Hide message
+            gr.Image(visible=False),       # Hide webcam
+            gr.Image(visible=False),       # Hide result image
+            gr.Textbox(visible=False),     # Hide result text
+            gr.Button(visible=False)       # Hide done button
         )
     
+    return (
+        gr.Textbox(interactive=False),     # Keep batch_no disabled
+        gr.Textbox(value="Please capture your face now", visible=True),  # Show instruction
+        gr.Image(visible=True),            # Show webcam
+        gr.Image(visible=False),           # Hide result image
+        gr.Textbox(visible=False),         # Hide result text
+        gr.Button(visible=False)           # Hide done button
+    )
+
+def reset_interface():
+    """Reset the interface to initial state"""
+    return (
+        gr.Textbox(value="", interactive=True),  # Enable batch_no
+        gr.Textbox(value="", visible=False),     # Hide message
+        gr.Image(value=None, visible=False),    # Hide webcam
+        gr.Image(visible=False),                 # Hide result image
+        gr.Textbox(visible=False),               # Hide result text
+        gr.Button(visible=False)                 # Hide done button
+    )
+
+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:
-        return None, None, f"Error: {str(e)}", False, False
+        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
 
-# 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")
+# Capture Interface
+with gr.Blocks(title="Emotion Capture", css="""
+    .gradio-container { max-width: 800px !important }
+    .message { color: red; font-weight: bold; }
+    .gallery { grid-template-columns: repeat(auto-fill, minmax(200px, 1fr)); }
+    .disabled-input { background-color: #f0f0f0; }
+    .processing { color: orange; font-weight: bold; }
+    .success { color: green; font-weight: bold; }
+""") as capture_interface:
+    
+    gr.Markdown("""
+    # Emotion Capture Interface
+    1. Enter/scan your batch number (numbers only)
+    2. System will automatically proceed after 5 seconds of inactivity
+    3. Webcam will activate for face capture
+    4. View your emotion analysis results
+    5. Click "Done" to reset the interface
+    """)
     
     with gr.Row():
-        batch_input = gr.Textbox(
+        batch_no = gr.Textbox(
             label="Batch Number", 
-            placeholder="Enter numbers only",
+            placeholder="Enter or scan numbers only",
             interactive=True
         )
-        status = gr.Textbox(
-            label="Status",
-            interactive=False,
-            visible=False
-        )
+    
+    message = gr.Textbox(
+        label="Status", 
+        interactive=False, 
+        elem_classes="message",
+        visible=False
+    )
     
     with gr.Row():
         webcam = gr.Image(
             sources=["webcam"],
-            streaming=True,
+            type="pil",
+            label="Face Capture",
+            interactive=True,
             mirror_webcam=True,
-            visible=False,
-            interactive=False
+            visible=False
         )
+    
+    with gr.Row():
         result_img = gr.Image(
-            label="Result",
+            label="Analysis Result", 
+            interactive=False, 
             visible=False
         )
     
     with gr.Row():
         result_text = gr.Textbox(
-            label="Analysis",
+            label="Emotion Result", 
+            interactive=False, 
             visible=False
         )
+    
+    with gr.Row():
         done_btn = gr.Button(
-            "Done",
+            "Done", 
             visible=False
         )
     
-    # Hidden trigger for continuous processing
-    trigger = gr.Textbox(visible=False)
-    
-    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 (
-            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)
-        )
-    
-    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()))
-        )
-    
-    # Setup event handlers
-    batch_input.change(
-        handle_batch_input,
-        inputs=batch_input,
-        outputs=[batch_input, status, webcam, result_img, result_text, done_btn, trigger]
+    # Detect when user stops typing (with 5 second delay)
+    batch_no.change(
+        check_batch_no,
+        inputs=batch_no,
+        outputs=[batch_no, message, webcam, result_img, result_text, done_btn],
+        queue=False
+    ).then(
+        lambda: time.sleep(5),  # Wait for 5 seconds of inactivity
+        None,
+        None,
+        queue=False
+    ).then(
+        activate_webcam,
+        inputs=batch_no,
+        outputs=[batch_no, message, webcam, result_img, result_text, done_btn],
+        queue=False
     )
     
+    # Process when webcam captures an image
     webcam.change(
-        process_and_continue,
-        inputs=[batch_input, webcam, trigger],
-        outputs=[result_img, result_text, status, result_img, result_text, trigger],
-        queue=False
+        predict_emotion,
+        inputs=[batch_no, webcam],
+        outputs=[result_img, result_text, message, result_img, result_text, done_btn]
     )
     
-    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)
-        )
-    
+    # Reset interface when Done is clicked
     done_btn.click(
-        reset_all,
-        outputs=[batch_input, status, webcam, result_img, result_text, done_btn, trigger]
+        reset_interface,
+        outputs=[batch_no, message, webcam, result_img, result_text, done_btn]
     )
 
+# Data Management Interface
+with gr.Blocks(title="Data Management") as data_interface:
+    
+    gr.Markdown("# Data Management Interface")
+    
+    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]
+            )
+    
+    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 }"
+)
+
 if __name__ == "__main__":
-    interface.launch()
+    demo.launch()