Update app.py

app.py

@@ -1,6 +1,9 @@
-# First install required dependencies
+# Install required packages
+import os
 import subprocess
 import sys
+import importlib
+import pkg_resources
 
 def install_package(package, version=None):
     package_spec = f"{package}=={version}" if version else package
@@ -11,229 +14,398 @@ def install_package(package, version=None):
         print(f"Failed to install {package_spec}: {e}")
         raise
 
-# List of required packages with specific versions
-required_packages = [
-    ("opencv-python-headless", "4.7.0.72"),
-    ("deepface", "0.0.79"),
-    ("tensorflow", "2.10.0"),
-    ("gradio", "3.50.2"),
-    ("matplotlib", "3.7.1"),
-    ("pandas", "2.0.3"),
-    ("Pillow", "10.0.1")
-]
-
-# Install all required packages
-for pkg, ver in required_packages:
+def ensure_package(package, version=None):
     try:
-        install_package(pkg, ver)
-    except Exception as e:
-        print(f"Critical error installing {pkg}: {str(e)}")
-        sys.exit(1)
+        if version:
+            pkg_resources.require(f"{package}=={version}")
+        else:
+            importlib.import_module(package)
+        print(f"{package} is already installed with the correct version.")
+    except (ImportError, pkg_resources.VersionConflict, pkg_resources.DistributionNotFound) as e:
+        print(f"Package requirement failed: {e}")
+        install_package(package, version)
+
+# Check if running in a standard environment (not Colab/Jupyter)
+if not os.path.exists("/.dockerenv") and not os.path.exists("/kaggle"):
+    print("Setting up environment...")
+    
+    # Install packages in the correct order with compatible versions
+    ensure_package("numpy", "1.23.5")  # Compatible with TensorFlow 2.10
+    ensure_package("protobuf", "3.20.3")  # Critical for TensorFlow compatibility
+    ensure_package("tensorflow", "2.10.0")  # Stable version with good compatibility
+    
+    # Install core dependencies
+    for pkg in ["gradio", "opencv-python-headless", "matplotlib", "pillow", "pandas"]:
+        ensure_package(pkg)
+    
+    # Install deepface last after all dependencies are set up
+    ensure_package("deepface")
 
-# Now import the rest of the modules
+# Now import the required modules
 import gradio as gr
+import json
 import cv2
 import numpy as np
-from deepface import DeepFace
-import matplotlib.pyplot as plt
 from PIL import Image
 import tempfile
-import os
-import shutil
 import pandas as pd
+import shutil
+import matplotlib.pyplot as plt
+
+# Import DeepFace after ensuring dependencies are properly installed
+from deepface import DeepFace
 
-def verify_faces(img1, img2, threshold=0.6, model="VGG-Face"):
+def verify_faces(img1, img2, threshold=0.70, model="VGG-Face"):
     temp_dir = tempfile.mkdtemp()
-    try:
-        # Save images
-        img1_path = os.path.join(temp_dir, "img1.jpg")
-        img2_path = os.path.join(temp_dir, "img2.jpg")
-        Image.fromarray(img1).save(img1_path) if isinstance(img1, np.ndarray) else img1.save(img1_path)
-        Image.fromarray(img2).save(img2_path) if isinstance(img2, np.ndarray) else img2.save(img2_path)
+    img1_path = os.path.join(temp_dir, "image1.jpg")
+    img2_path = os.path.join(temp_dir, "image2.jpg")
+
+    if isinstance(img1, np.ndarray):
+        Image.fromarray(img1).save(img1_path)
+    else:
+        img1.save(img1_path)
+
+    if isinstance(img2, np.ndarray):
+        Image.fromarray(img2).save(img2_path)
+    else:
+        img2.save(img2_path)
 
-        # Verify faces
+    try:
         result = DeepFace.verify(
             img1_path=img1_path,
             img2_path=img2_path,
             model_name=model,
-            distance_metric="cosine"
+            distance_metric="cosine",
+            threshold=threshold
         )
 
-        # Create visualization
         fig, ax = plt.subplots(1, 2, figsize=(10, 5))
-        for i, path in enumerate([img1_path, img2_path]):
-            img = cv2.cvtColor(cv2.imread(path), cv2.COLOR_BGR2RGB)
-            ax[i].imshow(img)
-            ax[i].axis('off')
-            ax[i].set_title(f"Image {i+1}")
-        
-        verified = result['distance'] <= threshold
-        plt.suptitle(f"{'✅ MATCH' if verified else '❌ NO MATCH'}\nDistance: {result['distance']:.4f}")
-        return fig, result
-    
+
+        img1_display = cv2.imread(img1_path)
+        img1_display = cv2.cvtColor(img1_display, cv2.COLOR_BGR2RGB)
+        img2_display = cv2.imread(img2_path)
+        img2_display = cv2.cvtColor(img2_display, cv2.COLOR_BGR2RGB)
+
+        ax[0].imshow(img1_display)
+        ax[0].set_title("Image 1")
+        ax[0].axis("off")
+
+        ax[1].imshow(img2_display)
+        ax[1].set_title("Image 2")
+        ax[1].axis("off")
+
+        verification_result = "✅ FACE MATCHED" if result["verified"] else "❌ FACE NOT MATCHED"
+        confidence = round((1 - result["distance"]) * 100, 2)
+
+        plt.suptitle(f"{verification_result}\nConfidence: {confidence}%\nDistance: {result['distance']:.4f}",
+                    fontsize=16, fontweight='bold',
+                    color='green' if result["verified"] else 'red')
+
+        plt.tight_layout()
+
+        os.remove(img1_path)
+        os.remove(img2_path)
+        os.rmdir(temp_dir)
+
+        return fig, json.dumps(result, indent=2)
+
     except Exception as e:
-        return None, {"error": str(e)}
-    finally:
-        shutil.rmtree(temp_dir, ignore_errors=True)
+        if os.path.exists(img1_path):
+            os.remove(img1_path)
+        if os.path.exists(img2_path):
+            os.remove(img2_path)
+        if os.path.exists(temp_dir):
+            os.rmdir(temp_dir)
 
-def find_faces(query_img, db_input, threshold=0.6, model="VGG-Face"):
+        error_msg = f"Error: {str(e)}"
+        if "No face detected" in str(e):
+            error_msg = "No face detected in one or both images. Please try different images."
+
+        return None, error_msg
+
+def find_faces(query_img, db_folder, threshold=0.70, model="VGG-Face"):
     temp_dir = tempfile.mkdtemp()
+    query_path = os.path.join(temp_dir, "query.jpg")
+
+    if isinstance(query_img, np.ndarray):
+        Image.fromarray(query_img).save(query_path)
+    else:
+        query_img.save(query_path)
+
+    if isinstance(db_folder, str):
+        db_path = db_folder
+    else:
+        db_path = os.path.join(temp_dir, "db")
+        os.makedirs(db_path, exist_ok=True)
+
+        for i, file in enumerate(db_folder):
+            file_ext = os.path.splitext(file.name)[1]
+            shutil.copy(file.name, os.path.join(db_path, f"image_{i}{file_ext}"))
+
     try:
-        # Save query image
-        query_path = os.path.join(temp_dir, "query.jpg")
-        Image.fromarray(query_img).save(query_path) if isinstance(query_img, np.ndarray) else query_img.save(query_path)
+        dfs = DeepFace.find(
+            img_path=query_path,
+            db_path=db_path,
+            model_name=model,
+            distance_metric="cosine",
+            threshold=threshold
+        )
 
-        # Handle database input
-        if isinstance(db_input, str) and os.path.isdir(db_input):
-            db_path = db_input
+        if isinstance(dfs, list):
+            if len(dfs) == 0:
+                return None, "No matching faces found in the database."
+            df = dfs[0]
         else:
-            db_path = os.path.join(temp_dir, "db")
-            os.makedirs(db_path, exist_ok=True)
-            if db_input:
-                for i, file in enumerate(db_input):
-                    ext = os.path.splitext(file.name)[1]
-                    shutil.copy(file.name, os.path.join(db_path, f"img_{i}{ext}"))
-
-        # Find faces
-        try:
-            dfs = DeepFace.find(
-                img_path=query_path,
-                db_path=db_path,
-                model_name=model,
-                distance_metric="cosine",
-                silent=True
-            )
-        except Exception as e:
-            return None, {"error": f"Face detection failed: {str(e)}"}
+            df = dfs
 
-        df = dfs[0] if isinstance(dfs, list) else dfs
         if df.empty:
-            return None, {"error": "No matches found"}
-        df = df[df['distance'] <= threshold].sort_values('distance')
+            return None, "No matching faces found in the database."
+
+        df = df.sort_values(by=["distance"])
 
-        # Create visualization
         num_matches = min(4, len(df))
         fig, axes = plt.subplots(1, num_matches + 1, figsize=(15, 5))
-        
-        # Show query image
-        query_img = cv2.cvtColor(cv2.imread(query_path), cv2.COLOR_BGR2RGB)
-        axes[0].imshow(query_img)
-        axes[0].set_title("Query")
-        axes[0].axis('off')
-
-        # Show matches
+
+        query_display = cv2.imread(query_path)
+        query_display = cv2.cvtColor(query_display, cv2.COLOR_BGR2RGB)
+        axes[0].imshow(query_display)
+        axes[0].set_title("Query Image")
+        axes[0].axis("off")
+
         for i in range(num_matches):
-            if i >= len(df): break
-            match_path = df.iloc[i]['identity']
-            if not os.path.exists(match_path):
-                continue
-            try:
-                match_img = cv2.cvtColor(cv2.imread(match_path), cv2.COLOR_BGR2RGB)
-                axes[i+1].imshow(match_img)
-                axes[i+1].set_title(f"Match {i+1}\n{df.iloc[i]['distance']:.4f}")
-                axes[i+1].axis('off')
-            except:
-                continue
-
-        return fig, df[['identity', 'distance']].to_dict('records')
-    
+            match_path = df.iloc[i]["identity"]
+            distance = df.iloc[i]["distance"]
+            confidence = round((1 - distance) * 100, 2)
+
+            match_img = cv2.imread(match_path)
+            match_img = cv2.cvtColor(match_img, cv2.COLOR_BGR2RGB)
+
+            axes[i+1].imshow(match_img)
+            axes[i+1].set_title(f"Match #{i+1}\nConfidence: {confidence}%")
+            axes[i+1].axis("off")
+
+        plt.suptitle(f"Found {len(df)} matching faces", fontsize=16, fontweight='bold')
+        plt.tight_layout()
+
+        results = df[["identity", "distance"]].copy()
+        results["confidence"] = (1 - results["distance"]) * 100
+        results["confidence"] = results["confidence"].round(2)
+        results = results.rename(columns={"identity": "Image Path"})
+
+        os.remove(query_path)
+        if not isinstance(db_folder, str):
+            shutil.rmtree(db_path)
+
+        return fig, results.to_dict('records')
+
     except Exception as e:
-        return None, {"error": str(e)}
-    finally:
-        shutil.rmtree(temp_dir, ignore_errors=True)
+        if os.path.exists(query_path):
+            os.remove(query_path)
+
+        error_msg = f"Error: {str(e)}"
+        if "No face detected" in str(e):
+            error_msg = "No face detected in the query image. Please try a different image."
+
+        return None, error_msg
 
-def analyze_face(img, actions=['age', 'gender', 'emotion']):
+def analyze_face(img, actions=['age', 'gender', 'race', 'emotion']):
     temp_dir = tempfile.mkdtemp()
-    try:
-        # Save image
-        img_path = os.path.join(temp_dir, "analyze.jpg")
-        Image.fromarray(img).save(img_path) if isinstance(img, np.ndarray) else img.save(img_path)
+    img_path = os.path.join(temp_dir, "analyze.jpg")
+
+    if isinstance(img, np.ndarray):
+        Image.fromarray(img).save(img_path)
+    else:
+        img.save(img_path)
 
-        # Analyze face
+    try:
         results = DeepFace.analyze(
             img_path=img_path,
             actions=actions,
-            enforce_detection=False,
+            enforce_detection=True,
             detector_backend='opencv'
         )
 
-        # Process results
-        results = results if isinstance(results, list) else [results]
-        fig = plt.figure(figsize=(10, 5))
-        
-        # Show image
-        plt.subplot(121)
-        img_display = cv2.cvtColor(cv2.imread(img_path), cv2.COLOR_BGR2RGB)
-        plt.imshow(img_display)
-        plt.title("Input Image")
-        plt.axis('off')
-
-        # Show attributes
-        plt.subplot(122)
-        attributes = {k: v for res in results for k, v in res.items() if k != 'region'}
-        plt.barh(list(attributes.keys()), list(attributes.values()))
-        plt.title("Analysis Results")
+        if isinstance(results, list):
+            num_faces = len(results)
+        else:
+            num_faces = 1
+            results = [results]
+
+        fig = plt.figure(figsize=(14, 7))
+
+        img_display = cv2.imread(img_path)
+        img_display = cv2.cvtColor(img_display, cv2.COLOR_BGR2RGB)
+
+        main_ax = plt.subplot2grid((2, 4), (0, 0), colspan=2, rowspan=2)
+        main_ax.imshow(img_display)
+        main_ax.set_title(f"Analyzed Image ({num_faces} face{'s' if num_faces > 1 else ''} detected)")
+        main_ax.axis('off')
+
+        for i, face_result in enumerate(results):
+            if i >= 4:
+                break
+
+            age = face_result.get('age', 'N/A')
+            gender = face_result.get('dominant_gender', 'N/A')
+            race = face_result.get('dominant_race', 'N/A')
+            emotion = face_result.get('dominant_emotion', 'N/A')
+
+            gender_conf = 'N/A'
+            if 'gender' in face_result and isinstance(face_result['gender'], dict):
+                for g, conf in face_result['gender'].items():
+                    if g.lower() == gender.lower():
+                        gender_conf = f"{conf:.1f}%"
+                        break
+
+            race_conf = 'N/A'
+            if 'race' in face_result and isinstance(face_result['race'], dict):
+                for r, conf in face_result['race'].items():
+                    if r.lower() == race.lower():
+                        race_conf = f"{conf:.1f}%"
+                        break
+
+            emotion_conf = 'N/A'
+            if 'emotion' in face_result and isinstance(face_result['emotion'], dict):
+                for e, conf in face_result['emotion'].items():
+                    if e.lower() == emotion.lower():
+                        emotion_conf = f"{conf:.1f}%"
+                        break
+
+            ax = plt.subplot2grid((2, 4), (0 if i < 2 else 1, 2 + (i % 2)))
+
+            text = (
+                f"Face #{i+1}\n\n"
+                f"Age: {age}\n\n"
+                f"Gender: {gender} ({gender_conf})\n\n"
+                f"Race: {race} ({race_conf})\n\n"
+                f"Emotion: {emotion} ({emotion_conf})"
+            )
+
+            ax.text(0.5, 0.5, text, ha='center', va='center', fontsize=11)
+            ax.axis('off')
+
         plt.tight_layout()
 
-        return fig, results
-    
+        os.remove(img_path)
+        os.rmdir(temp_dir)
+
+        formatted_results = []
+        for i, res in enumerate(results[:8]):
+            face_data = {
+                "face_number": i+1,
+                "age": res.get("age", "N/A"),
+                "gender": {
+                    "dominant": res.get("dominant_gender", "N/A"),
+                    "confidence": res.get("gender", {})
+                },
+                "race": {
+                    "dominant": res.get("dominant_race", "N/A"),
+                    "confidence": res.get("race", {})
+                },
+                "emotion": {
+                    "dominant": res.get("dominant_emotion", "N/A"),
+                    "confidence": res.get("emotion", {})
+                }
+            }
+            formatted_results.append(face_data)
+
+        return fig, formatted_results
+
     except Exception as e:
-        return None, {"error": str(e)}
-    finally:
-        shutil.rmtree(temp_dir, ignore_errors=True)
+        if os.path.exists(img_path):
+            os.remove(img_path)
+        if os.path.exists(temp_dir):
+            os.rmdir(temp_dir)
+
+        error_msg = f"Error: {str(e)}"
+        if "No face detected" in str(e):
+            error_msg = "No face detected in the image. Please try a different image."
+
+        return None, error_msg
+
+with gr.Blocks(title="Complete Face Recognition Tool", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🔍 Complete Face Recognition Tool
+    This tool provides three face recognition features:
+    - **Verify Faces**: Compare two specific images to check if they contain the same person
+    - **Find Faces**: Search for matching faces in a database/folder
+    - **Analyze Face**: Determine age, gender, race, and emotion from a facial image
+    """)
 
-# Gradio Interface
-with gr.Blocks(title="Face Recognition Toolkit", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🧑💻 Face Recognition Toolkit")
-    
     with gr.Tabs():
-        with gr.Tab("Verify Faces"):
+        with gr.TabItem("Verify Faces"):
+            with gr.Row():
+                img1_input = gr.Image(label="First Image", type="pil")
+                img2_input = gr.Image(label="Second Image", type="pil")
+
             with gr.Row():
-                img1 = gr.Image(label="First Image", type="pil")
-                img2 = gr.Image(label="Second Image", type="pil")
-            verify_threshold = gr.Slider(0.1, 1.0, 0.6, label="Match Threshold")
-            verify_model = gr.Dropdown(["VGG-Face", "Facenet", "OpenFace"], value="VGG-Face")
-            verify_btn = gr.Button("Verify Faces")
-            verify_output = gr.Plot()
-            verify_json = gr.JSON()
-            
-            verify_btn.click(
+                verify_threshold = gr.Slider(minimum=0.1, maximum=0.9, value=0.6, step=0.05,
+                                       label="Similarity Threshold (lower = stricter matching)")
+                verify_model = gr.Dropdown(
+                    choices=["VGG-Face", "Facenet", "OpenFace", "DeepFace", "ArcFace"],
+                    value="VGG-Face",
+                    label="Face Recognition Model"
+                )
+
+            verify_button = gr.Button("Verify Faces", variant="primary")
+
+            verify_result_plot = gr.Plot(label="Verification Result")
+            verify_json = gr.JSON(label="Technical Details")
+
+            verify_button.click(
                 verify_faces,
-                [img1, img2, verify_threshold, verify_model],
-                [verify_output, verify_json]
+                inputs=[img1_input, img2_input, verify_threshold, verify_model],
+                outputs=[verify_result_plot, verify_json]
             )
 
-        with gr.Tab("Find Faces"):
-            query_img = gr.Image(label="Query Image", type="pil")
-            db_input = gr.Textbox("", label="Database Path (optional)")
-            db_files = gr.File(file_count="multiple", label="Upload Database Images")
-            find_threshold = gr.Slider(0.1, 1.0, 0.6, label="Similarity Threshold")
-            find_model = gr.Dropdown(["VGG-Face", "Facenet", "OpenFace"], value="VGG-Face")
-            find_btn = gr.Button("Find Matches")
-            find_output = gr.Plot()
-            find_json = gr.JSON()
-            
-            find_btn.click(
+        with gr.TabItem("Find Faces"):
+            query_img = gr.Image(label="Query Image (Face to find)", type="pil")
+            db_path_input = gr.Textbox(label="Database Path (folder containing images to search in)")
+            db_files_input = gr.File(label="Or upload images for database", file_count="multiple")
+
+            with gr.Row():
+                find_threshold = gr.Slider(minimum=0.1, maximum=0.9, value=0.6, step=0.05,
+                                     label="Similarity Threshold (lower = stricter matching)")
+                find_model = gr.Dropdown(
+                    choices=["VGG-Face", "Facenet", "OpenFace", "DeepFace", "ArcFace"],
+                    value="VGG-Face",
+                    label="Face Recognition Model"
+                )
+
+            find_button = gr.Button("Find Matching Faces", variant="primary")
+
+            find_result_plot = gr.Plot(label="Search Results")
+            find_results_table = gr.JSON(label="Detailed Results")
+
+            find_button.click(
                 find_faces,
-                [query_img, db_files, find_threshold, find_model],
-                [find_output, find_json]
+                inputs=[query_img, db_path_input, find_threshold, find_model],
+                outputs=[find_result_plot, find_results_table]
             )
 
-        with gr.Tab("Analyze Face"):
-            analyze_img = gr.Image(label="Input Image", type="pil")
-            analyze_actions = gr.CheckboxGroup(
-                ["age", "gender", "emotion", "race"], 
-                value=["age", "gender", "emotion"],
-                label="Analysis Features"
+            db_files_input.change(
+                lambda x: "",
+                inputs=db_files_input,
+                outputs=db_path_input
             )
-            analyze_btn = gr.Button("Analyze")
-            analyze_output = gr.Plot()
-            analyze_json = gr.JSON()
-            
-            analyze_btn.click(
+
+        with gr.TabItem("Analyze Face"):
+            analyze_img = gr.Image(label="Upload Image for Analysis", type="pil")
+            actions_checkboxes = gr.CheckboxGroup(
+                choices=["age", "gender", "race", "emotion"],
+                value=["age", "gender", "race", "emotion"],
+                label="Select Attributes to Analyze"
+            )
+
+            analyze_button = gr.Button("Analyze Face", variant="primary")
+
+            analyze_result_plot = gr.Plot(label="Analysis Results")
+            analyze_json = gr.JSON(label="Detailed Analysis")
+
+            analyze_button.click(
                 analyze_face,
-                [analyze_img, analyze_actions],
-                [analyze_output, analyze_json]
+                inputs=[analyze_img, actions_checkboxes],
+                outputs=[analyze_result_plot, analyze_json]
             )
 
 demo.launch()