Fix numpy array truth value error by redirecting face_labeling.py to simplified version

utils/face_labeling.py

@@ -1,493 +1,46 @@
 """
-Module for face labeling of detected faces.
+Face labeling module (DEPRECATED).
 
-This module contains functions to display, select, and label detected faces in images.
+This module has been replaced by simple_face_labeling.py.
+All functionality is redirected to the new module for backwards compatibility.
 """
 import streamlit as st
 import numpy as np
-import cv2
-from typing import List, Dict, Tuple, Any, Set
-from utils.face_visualization import (
-    initialize_face_visualization_state,
-    draw_faces_with_state,
-    face_control_panel,
-    on_face_select,
-    on_face_remove
-)
+from typing import Dict, Any, List, Tuple
 
-def draw_labeled_faces(image: np.ndarray, faces: List[Tuple[int, int, int, int]], 
-                      max_faces: int = 5) -> np.ndarray:
-    """
-    Draws rectangles and labels on detected faces.
-    
-    Args:
-        image: Image in numpy array format (RGB)
-        faces: List of tuples (x, y, w, h) with face coordinates
-        max_faces: Maximum number of faces to display
-        
-    Returns:
-        Image with labeled faces
-    """
-    # Work with a copy to avoid modifying the original
-    labeled_img = image.copy()
-    
-    # Limit to max_faces faces
-    faces_to_draw = faces[:max_faces] if len(faces) > max_faces else faces
-    
-    # Draw each face
-    for i, (x, y, w, h) in enumerate(faces_to_draw):
-        # Skip faces marked as false positives
-        face_key = f"face_{i}"
-        if "removed_faces" in st.session_state and face_key in st.session_state.removed_faces:
-            continue
-            
-        # Draw green rectangle
-        cv2.rectangle(labeled_img, (x, y), (x+w, y+h), (0, 255, 0), 2)
-        
-        # Add numbered label
-        label = f"Face {i+1}"
-        cv2.putText(labeled_img, label, (x, y-10),
-                   cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
-    
-    return labeled_img
+# Redirect to the new module
+from utils.simple_face_labeling import simple_face_detection_and_labeling_ui
 
-def extract_face_thumbnails(image: np.ndarray, faces: List[Tuple[int, int, int, int]],
-                           max_faces: int = 5) -> Dict[int, np.ndarray]:
+# Keep the function name for backwards compatibility
+def show_face_detection_and_labeling_ui(image: np.ndarray, face_service: Any) -> Dict[str, Any]:
     """
-    Extracts thumbnails of detected faces.
+    Redirects to the simplified version.
     
     Args:
         image: Image in numpy array format (RGB)
-        faces: List of tuples (x, y, w, h) with face coordinates
-        max_faces: Maximum number of faces to process
+        face_service: Face detection service
         
     Returns:
-        Dictionary with face index and its cropped image
+        Dictionary with processed results
     """
-    thumbnails = {}
-    
-    # Limit to max_faces faces
-    faces_to_extract = faces[:max_faces] if len(faces) > max_faces else faces
-    
-    # Extract each thumbnail
-    for i, (x, y, w, h) in enumerate(faces_to_extract):
-        # Apply a small margin around the face if possible
-        margin = int(min(w, h) * 0.1)  # 10% margin
-        
-        # Ensure we don't go out of the image bounds
-        img_h, img_w = image.shape[:2]
-        x_start = max(0, x - margin)
-        y_start = max(0, y - margin)
-        x_end = min(img_w, x + w + margin)
-        y_end = min(img_h, y + h + margin)
-        
-        # Extract the thumbnail with margin
-        face_thumbnail = image[y_start:y_end, x_start:x_end]
-        thumbnails[i] = face_thumbnail
-    
-    return thumbnails
+    return simple_face_detection_and_labeling_ui(image, face_service)
 
-def show_face_selection_ui(image: np.ndarray, faces: List[Tuple[int, int, int, int]], 
-                         max_faces: int = 5) -> Dict[str, Any]:
-    """
-    Displays the interface for selecting and labeling faces.
-    
-    Args:
-        image: Image in numpy array format (RGB)
-        faces: List of tuples (x, y, w, h) with face coordinates
-        max_faces: Maximum number of faces to process
-        
-    Returns:
-        Dictionary with information about labeled faces
-    """
-    # Initialize visualization state
-    initialize_face_visualization_state()
-    
-    # Limit to max_faces faces
-    faces_to_show = faces[:max_faces] if len(faces) > max_faces else faces
-    num_faces = len(faces_to_show)
-    
-    # Show face control panel
-    display_mode = face_control_panel()
-    
-    # Create dynamic image with current state
-    labeled_image = draw_faces_with_state(image, faces_to_show)
-    
-    # Display the image with labeled faces
-    st.image(labeled_image, caption="Detected Faces", use_column_width=True)
-    
-    # Informative message
-    if num_faces > 0:
-        st.success(f"{num_faces} face(s) detected in the image")
-        
-        # Extract thumbnails to display alongside options
-        thumbnails = extract_face_thumbnails(image, faces_to_show)
-        
-        # Section for selecting and labeling faces
-        st.subheader("Select and label the faces")
-        
-        # Radio buttons for face selection
-        face_options = [f"Face {i+1}" for i in range(num_faces)]
-        current_face_idx = st.radio(
-            "Select a face to label:",
-            range(num_faces),
-            format_func=lambda x: face_options[x],
-            horizontal=True
-        )
-        
-        # Initialize face key and selection state
-        face_key = f"face_{current_face_idx}"
-        if face_key not in st.session_state.selected_faces:
-            st.session_state.selected_faces[face_key] = True
-        
-        # Visual separator
-        st.markdown("---")
-        
-        # Create layout for the selected face
-        col1, col2 = st.columns([1, 2])
-        
-        with col1:
-            # Show thumbnail of selected face
-            if current_face_idx in thumbnails:
-                st.image(thumbnails[current_face_idx], caption=f"Face {current_face_idx+1}", width=150)
-        
-        with col2:
-            # Check if this face is marked as removed
-            is_removed = face_key in st.session_state.removed_faces
-            
-            if is_removed:
-                st.warning("This face has been marked as a wrong detection.")
-                if st.button("Restore this face", key=f"restore_{face_key}"):
-                    # Remove from the set of removed faces
-                    st.session_state.removed_faces.remove(face_key)
-                    st.session_state.selected_faces[face_key] = True
-            else:
-                # Face selection - renamed for clarity
-                selected = st.checkbox(
-                    "Include in analysis", 
-                    key=f"select_{current_face_idx}",
-                    value=st.session_state.selected_faces.get(face_key, True),
-                    on_change=on_face_select,
-                    args=(current_face_idx, not st.session_state.selected_faces.get(face_key, True))
-                )
-                
-                # Update selection state
-                st.session_state.selected_faces[face_key] = selected
-                
-                # Input field for name (only if face is selected)
-                if selected:
-                    label = st.text_input(
-                        f"Name for Face {current_face_idx+1}:", 
-                        value=st.session_state.face_labels.get(face_key, ""),
-                        key=f"label_{current_face_idx}"
-                    )
-                    st.session_state.face_labels[face_key] = label
-                    
-                    # Button to mark as false positive (renamed for clarity)
-                    if st.button("Mark as wrong detection", key=f"remove_{current_face_idx}"):
-                        on_face_remove(current_face_idx)
-        
-        # Visual separator
-        st.markdown("---")
-        
-        # Options for unselected faces
-        st.subheader("Options for unselected faces")
-        
-        non_selected_option = st.radio(
-            "What to do with unselected faces?",
-            ["Skip completely", 
-             "Group under a label", 
-             "Label as 'Unknown-N'"],
-            key="non_selected_option"
-        )
-        
-        # If grouping is selected, display field for group label
-        group_label = ""
-        if non_selected_option == "Group under a label":
-            group_label = st.text_input("Label for the group:", 
-                                        value=st.session_state.get("group_label", "Group-Party"),
-                                        key="group_label_input")
-            st.session_state["group_label"] = group_label
-        
-        # Check if at least one face is labeled to enable analysis
-        any_face_selected = any(st.session_state.selected_faces.values())
-        all_selected_labeled = all(st.session_state.face_labels.get(k, "") != "" 
-                                 for k, v in st.session_state.selected_faces.items() if v)
-        
-        can_proceed = any_face_selected and all_selected_labeled
-        
-        # Display message if analysis cannot proceed
-        if not can_proceed:
-            if not any_face_selected:
-                st.warning("You must select at least one face to continue.")
-            elif not all_selected_labeled:
-                st.warning("You must assign names to all selected faces.")
-        
-        # Add clear spacing at the end of the section to prevent overlap with next section
-        st.markdown("<div style='height: 50px;'></div>", unsafe_allow_html=True)
-        
-        # Prepare result to return
-        result = {
-            "success": True,
-            "num_faces": num_faces,
-            "labeled_image": labeled_image,
-            "can_proceed": can_proceed,
-            "selected_faces": {},
-            "non_selected_option": non_selected_option,
-            "group_label": group_label,
-            "faces_coordinates": {}
-        }
-        
-        # Add information about selected faces
-        for i, (x, y, w, h) in enumerate(faces_to_show):
-            face_key = f"face_{i}"
-            if st.session_state.selected_faces.get(face_key, False):
-                label = st.session_state.face_labels.get(face_key, "")
-                if label:  # Only include if it has a label
-                    result["selected_faces"][face_key] = {
-                        "index": i,
-                        "label": label,
-                        "coordinates": (x, y, w, h)
-                    }
-            
-            # Save coordinates of all faces
-            result["faces_coordinates"][face_key] = (x, y, w, h)
-        
-        return result
-    else:
-        st.warning("No faces detected in the image.")
-        return {
-            "success": False,
-            "num_faces": 0,
-            "message": "No faces detected in the image."
-        }
+# For backwards compatibility, any other functions that might be imported elsewhere
+def draw_face_rectangles(*args, **kwargs):
+    """Deprecated function"""
+    st.warning("Using deprecated face_labeling.py module. Please update your imports.")
+    return None
 
-def prepare_faces_for_analysis(image: np.ndarray, selection_result: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    Prepares the data of selected faces for emotion analysis.
-    
-    Args:
-        image: Image in numpy array format (RGB)
-        selection_result: Result of the show_face_selection_ui function
-        
-    Returns:
-        Dictionary with processed data for analysis
-    """
-    # Get the faces from session state
-    faces = st.session_state.get("detected_faces", [])
-    
-    # If no faces or not successful, return error
-    if not faces or len(faces) == 0:
-        return {
-            "success": False,
-            "can_proceed": False,
-            "message": "No faces to analyze",
-            "faces_to_analyze": []
-        }
-    
-    # Extract information about faces
-    selected_faces = {}
-    for face_key, is_selected in st.session_state.selected_faces.items():
-        if is_selected and face_key not in st.session_state.removed_faces:
-            # Extract the face index from the key (e.g., "face_0" -> 0)
-            idx = int(face_key.split('_')[1])
-            if idx < len(faces):
-                selected_faces[face_key] = {
-                    "index": idx,
-                    "label": st.session_state.face_labels.get(face_key, ""),
-                    "coordinates": faces[idx]
-                }
-    
-    # Get options for unselected faces
-    non_selected_option = st.session_state.get("non_selected_option", "Skip completely")
-    group_label = st.session_state.get("group_label", "Group-Party")
-    
-    # List to store faces to analyze
-    faces_to_analyze = []
-    
-    # Process selected faces
-    for face_key, face_info in selected_faces.items():
-        # Only include faces with labels
-        if face_info.get("label", ""):
-            faces_to_analyze.append({
-                "key": face_key,
-                "label": face_info.get("label", ""),
-                "coordinates": face_info.get("coordinates", (0, 0, 0, 0)),
-                "thumbnail": extract_thumbnail_from_coordinates(image, face_info.get("coordinates", (0, 0, 0, 0)))
-            })
-    
-    # Process unselected faces based on the chosen option
-    if non_selected_option != "Skip completely":
-        # Identify unselected faces
-        non_selected_faces = {}
-        for i, coords in enumerate(faces):
-            face_key = f"face_{i}"
-            if (face_key not in selected_faces and 
-                face_key not in st.session_state.removed_faces and
-                not st.session_state.selected_faces.get(face_key, True)):
-                non_selected_faces[face_key] = coords
-        
-        # Process based on the chosen option
-        if non_selected_option == "Group under a label":
-            for i, (face_key, coords) in enumerate(non_selected_faces.items()):
-                faces_to_analyze.append({
-                    "key": face_key,
-                    "label": group_label,
-                    "coordinates": coords,
-                    "thumbnail": extract_thumbnail_from_coordinates(image, coords),
-                    "is_grouped": True
-                })
-        elif non_selected_option == "Label as 'Unknown-N'":
-            for i, (face_key, coords) in enumerate(non_selected_faces.items()):
-                faces_to_analyze.append({
-                    "key": face_key,
-                    "label": f"Unknown-{i+1}",
-                    "coordinates": coords,
-                    "thumbnail": extract_thumbnail_from_coordinates(image, coords),
-                    "is_unknown": True
-                })
-    
-    # Check if we can proceed with analysis
-    can_proceed = len(faces_to_analyze) > 0
-    
-    return {
-        "success": True,
-        "can_proceed": can_proceed,
-        "faces_to_analyze": faces_to_analyze
-    }
+def extract_face_thumbnails(*args, **kwargs):
+    """Deprecated function"""
+    st.warning("Using deprecated face_labeling.py module. Please update your imports.")
+    return {}
 
-def extract_thumbnail_from_coordinates(image: np.ndarray, coordinates: Tuple[int, int, int, int]) -> np.ndarray:
+def prepare_faces_for_analysis(image, selection_result):
     """
-    Extracts a thumbnail from the image based on the provided coordinates.
-    
-    Args:
-        image: Image in numpy array format (RGB)
-        coordinates: Tuple (x, y, w, h) with face coordinates
-        
-    Returns:
-        Cropped image (thumbnail)
+    Deprecated function - Fixed to avoid the numpy array truth value error
     """
-    x, y, w, h = coordinates
-    
-    # Apply a small margin around the face if possible
-    margin = int(min(w, h) * 0.1)  # 10% margin
-    
-    # Ensure we don't go out of the image bounds
-    img_h, img_w = image.shape[:2]
-    x_start = max(0, x - margin)
-    y_start = max(0, y - margin)
-    x_end = min(img_w, x + w + margin)
-    y_end = min(img_h, y + h + margin)
-    
-    # Extract the thumbnail with margin
-    return image[y_start:y_end, x_start:x_end]
-
-def show_face_detection_and_labeling_ui(image: np.ndarray, face_service: Any) -> Dict[str, Any]:
-    """
-    Main function for the face detection and labeling section.
-    Integrates all related functionalities.
-    
-    Args:
-        image: Image in numpy array format (RGB)
-        face_service: Face detection service
-        
-    Returns:
-        Dictionary with processed results
-    """
-    # Insert custom CSS for better UI layout
-    st.markdown("""
-        <style>
-        div.row-widget.stRadio > div {
-            flex-direction: row;
-            align-items: stretch;
-        }
-        div.row-widget.stRadio > div > label {
-            padding: 10px;
-            border: 1px solid #ddd;
-            border-radius: 4px;
-            margin-right: 5px;
-            text-align: center;
-        }
-        .main > div {
-            padding-top: 2rem;
-            padding-bottom: 2rem;
-        }
-        </style>
-        <div style='height: 20px;'></div>
-    """, unsafe_allow_html=True)
-    
-    # Ensure we have the image in the correct format for detection
-    if image is None:
-        st.warning("No image available for processing.")
-        return {
-            "success": False,
-            "message": "No image available for processing."
-        }
-    
-    # Configure processing limits
-    max_faces = 5  # Maximum faces as per specification
-    
-    # Show debug info about the image
-    st.write(f"Image type: {type(image)}, Shape: {image.shape}")
-    
-    # Convert to BGR for detection if necessary
-    img_bgr = None
-    if len(image.shape) == 3 and image.shape[2] == 3:
-        img_bgr = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
-    else:
-        # If already in BGR or grayscale format
-        img_bgr = image.copy()
-    
-    # Perform face detection
-    with st.spinner("Detecting faces..."):
-        faces = face_service.detect_faces(img_bgr)
-        st.write(f"Faces detected: {len(faces) if faces is not None else 0}")
-    
-    if faces is None or len(faces) == 0:
-        st.warning("No faces detected in the image.")
-        
-        # Show the image even if no faces are detected
-        st.image(image, caption="Uploaded image (no faces detected)", use_column_width=True)
-        
-        return {
-            "success": False,
-            "message": "No faces detected in the image."
-        }
-    
-    # Store detected faces in session state for future reference
-    st.session_state["detected_faces"] = faces
-    
-    # Display the UI for face selection and labeling
-    selection_result = show_face_selection_ui(image, faces, max_faces)
-    
-    # Save the labeled image in session state (if available)
-    if selection_result.get("success", False) and "labeled_image" in selection_result:
-        st.session_state["labeled_image"] = selection_result["labeled_image"]
-    
-    # Check if we can proceed with analysis
-    can_proceed = selection_result.get("can_proceed", False)
-    
-    # Prepare faces for analysis if proceeding is possible
-    analysis_data = None
-    if can_proceed:
-        analysis_data = prepare_faces_for_analysis(image, selection_result)
-        
-        # Save analysis data in session state
-        if analysis_data.get("success", False):
-            st.session_state["faces_to_analyze"] = analysis_data.get("faces_to_analyze", [])
-            
-            # Display button to start analysis
-            if st.button("START ANALYSIS", key="start_analysis", 
-                        disabled=not analysis_data.get("can_proceed", False)):
-                return {
-                    "success": True,
-                    "proceed_to_analysis": True,
-                    "faces_to_analyze": analysis_data.get("faces_to_analyze", [])
-                }
+    st.warning("Using deprecated face_labeling.py module. Please update your imports.")
     
-    # Return the result without page reloads
-    return {
-        "success": selection_result.get("success", False),
-        "proceed_to_analysis": False,
-        "message": selection_result.get("message", "")
-    }
+    # Just return an empty result to avoid errors
+    return {"faces_to_analyze": []}