Update app.py

app.py

@@ -1,47 +1,8 @@
-# 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
-    print(f"Installing {package_spec}...")
-    try:
-        subprocess.check_call([sys.executable, "-m", "pip", "install", "--no-cache-dir", package_spec])
-    except subprocess.CalledProcessError as e:
-        print(f"Failed to install {package_spec}: {e}")
-        raise
-
-def ensure_package(package, version=None):
-    try:
-        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 environment and install dependencies
-if not os.path.exists("/.dockerenv") and not os.path.exists("/kaggle"):
-    print("Setting up environment...")
-    
-    # Install core dependencies
-    ensure_package("numpy", "1.23.5")
-    ensure_package("protobuf", "3.20.3")
-    ensure_package("tensorflow", "2.10.0")
-    ensure_package("opencv-python-headless", "4.7.0.72")
-    ensure_package("deepface", "0.0.79")
-    ensure_package("gradio", "3.50.2")
-    
-    # Install additional required packages
-    for pkg in ["matplotlib", "pillow", "pandas"]:
-        ensure_package(pkg)
+# Install required packages with version locking
+from google.colab import drive
+drive.mount('/content/drive')
+!pip install deepface==0.0.79 tensorflow==2.10.0 opencv-python-headless==4.7.0.72
 
-# Now import the required modules
 import gradio as gr
 import json
 import cv2
@@ -50,14 +11,10 @@ from deepface import DeepFace
 import matplotlib.pyplot as plt
 from PIL import Image
 import tempfile
+import os
 import pandas as pd
 import shutil
 
-# Google Drive integration (for Colab users)
-if 'google.colab' in sys.modules:
-    from google.colab import drive
-    drive.mount('/content/drive')
-
 def verify_faces(img1, img2, threshold=0.70, model="VGG-Face"):
     temp_dir = tempfile.mkdtemp()
     img1_path = os.path.join(temp_dir, "image1.jpg")
@@ -65,17 +22,10 @@ def verify_faces(img1, img2, threshold=0.70, model="VGG-Face"):
     
     try:
         # Save images
-        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)
+        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)
 
-        # Perform verification
+        # Verify faces with proper API parameters
         result = DeepFace.verify(
             img1_path=img1_path, 
             img2_path=img2_path,
@@ -86,50 +36,23 @@ def verify_faces(img1, img2, threshold=0.70, model="VGG-Face"):
         
         # Create visualization
         fig, ax = plt.subplots(1, 2, figsize=(10, 5))
+        for idx, path in enumerate([img1_path, img2_path]):
+            img = cv2.cvtColor(cv2.imread(path), cv2.COLOR_BGR2RGB)
+            ax[idx].imshow(img)
+            ax[idx].set_title(f"Image {idx+1}")
+            ax[idx].axis("off")
         
-        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"{'✅ MATCH' if result['verified'] else '❌ NO MATCH'}\nConfidence: {confidence}%", 
+                    fontsize=14, y=1.05)
         
-        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()
-        
-        # Clean up
-        os.remove(img1_path)
-        os.remove(img2_path)
-        os.rmdir(temp_dir)
-        
-        return fig, result  # Return raw dict instead of JSON string
-
+        return fig, result
+    
     except Exception as e:
-        # Clean up even if error occurs
-        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)
-        
-        error_msg = str(e)
-        if "No face detected" in error_msg:
-            error_msg = "No face detected in one or both images. Please try different images."
-        
-        return None, {"error": error_msg}
+        return None, {"error": str(e)}
+    
+    finally:
+        shutil.rmtree(temp_dir, ignore_errors=True)
 
 def find_faces(query_img, db_folder, threshold=0.70, model="VGG-Face"):
     temp_dir = tempfile.mkdtemp()
@@ -137,114 +60,50 @@ def find_faces(query_img, db_folder, threshold=0.70, model="VGG-Face"):
     
     try:
         # Save query image
-        if isinstance(query_img, np.ndarray):
-            Image.fromarray(query_img).save(query_path)
-        else:
-            query_img.save(query_path)
+        Image.fromarray(query_img).save(query_path) if isinstance(query_img, np.ndarray) else query_img.save(query_path)
 
         # Handle database path
         if isinstance(db_folder, str):
-            if db_folder.startswith("/content/drive"):
-                db_path = db_folder
-            else:
-                db_path = os.path.abspath(db_folder)
-                if not os.path.exists(db_path):
-                    return None, {"error": "Invalid database path - directory does not exist"}
+            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):
-                orig_filename = file.orig_name
-                file_ext = os.path.splitext(orig_filename)[1]
-                new_filename = f"image_{i}{file_ext}"
-                shutil.copy(file.name, os.path.join(db_path, new_filename))
+                ext = os.path.splitext(file.name)[1]
+                shutil.copy(file.name, os.path.join(db_path, f"img_{i}{ext}"))
 
-        # Find matches
+        # Find faces with corrected API parameters
         dfs = DeepFace.find(
             img_path=query_path,
             db_path=db_path,
             model_name=model,
             distance_metric="cosine",
-            threshold=threshold,
+            enforce_detection=False,
             silent=True
         )
         
         # Process results
-        if isinstance(dfs, list):
-            if len(dfs) == 0:
-                return None, {"error": "No matching faces found in the database."}
-            df = dfs[0]
-        else:
-            df = dfs
-            
-        if df.empty:
-            return None, {"error": "No matching faces found in the database."}
-        
-        df = df.sort_values(by=["distance"])
+        df = dfs[0] if isinstance(dfs, list) else dfs
+        df = df[df['distance'] <= threshold].sort_values('distance')
         
         # Create visualization
-        num_matches = min(4, len(df))
-        fig, axes = plt.subplots(1, num_matches + 1, figsize=(15, 5))
-        
-        query_display = cv2.imread(query_path)
-        query_display = cv2.cvtColor(query_display, cv2.COLOR_BGR2RGB)
-        axes[0].imshow(query_display)
+        fig, axes = plt.subplots(1, min(4, len(df)) if len(df) > 0 else plt.subplots(1, 1))
+        axes[0].imshow(cv2.cvtColor(cv2.imread(query_path), cv2.COLOR_BGR2RGB))
         axes[0].set_title("Query Image")
-        axes[0].axis("off")
         
-        valid_matches = 0
-        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.imread(match_path)
-                if match_img is None:
-                    continue
-                    
-                match_img = cv2.cvtColor(match_img, cv2.COLOR_BGR2RGB)
-                axes[valid_matches+1].imshow(match_img)
-                axes[valid_matches+1].set_title(f"Match #{valid_matches+1}")
-                axes[valid_matches+1].axis("off")
-                valid_matches += 1
-            except Exception as e:
-                continue
+        for idx, (_, row) in enumerate(df.head(3).iterrows()):
+            if idx >= len(axes)-1: break
+            match_img = cv2.cvtColor(cv2.imread(row['identity']), cv2.COLOR_BGR2RGB)
+            axes[idx+1].imshow(match_img)
+            axes[idx+1].set_title(f"Match {idx+1}\n{row['distance']:.2f}")
         
-        # Hide empty axes
-        for j in range(valid_matches+1, num_matches+1):
-            axes[j].axis("off")
-        
-        plt.suptitle(f"Found {len(df)} matching faces", fontsize=16, fontweight='bold')
-        plt.tight_layout()
-        
-        # Prepare results
-        results = df[["identity", "distance"]].copy()
-        results["confidence"] = (1 - results["distance"]) * 100
-        results["confidence"] = results["confidence"].round(2)
-        results = results.rename(columns={"identity": "Image Path"}).to_dict('records')
-        
-        return fig, results
-
+        return fig, df[['identity', 'distance']].to_dict('records')
+    
     except Exception as e:
-        error_msg = str(e)
-        if "No face detected" in error_msg:
-            error_msg = "No face detected in the query image. Please try a different image."
-        elif "No such file or directory" in error_msg:
-            error_msg = "Invalid database path or corrupted image files"
-        
-        return None, {"error": error_msg}
+        return None, {"error": str(e)}
     
     finally:
-        # Clean up
-        if os.path.exists(query_path):
-            os.remove(query_path)
-        if 'db_path' in locals() and not isinstance(db_folder, str):
-            shutil.rmtree(db_path, ignore_errors=True)
+        shutil.rmtree(temp_dir, ignore_errors=True)
 
 def analyze_face(img, actions=['age', 'gender', 'race', 'emotion']):
     temp_dir = tempfile.mkdtemp()
@@ -252,179 +111,89 @@ def analyze_face(img, actions=['age', 'gender', 'race', 'emotion']):
     
     try:
         # Save image
-        if isinstance(img, np.ndarray):
-            Image.fromarray(img).save(img_path)
-        else:
-            img.save(img_path)
+        Image.fromarray(img).save(img_path) if isinstance(img, np.ndarray) else img.save(img_path)
 
-        # Analyze image
+        # Analyze face
         results = DeepFace.analyze(
             img_path=img_path,
             actions=actions,
-            enforce_detection=True,
+            enforce_detection=False,
             detector_backend='opencv'
         )
         
         # Process results
-        if isinstance(results, list):
-            num_faces = len(results)
-        else:
-            num_faces = 1
-            results = [results]
-        
-        # Create visualization
-        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')
+        results = results if isinstance(results, list) else [results]
+        fig = plt.figure(figsize=(10, 5))
         
-        for i, face_result in enumerate(results[:4]):
-            # Get analysis data
-            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')
-            
-            # Create subplot
-            ax = plt.subplot2grid((2, 4), (0 if i < 2 else 1, 2 + (i % 2)))
-            text = f"Face #{i+1}\n\nAge: {age}\nGender: {gender}\nRace: {race}\nEmotion: {emotion}"
-            ax.text(0.5, 0.5, text, ha='center', va='center', fontsize=11)
-            ax.axis('off')
-        
-        plt.tight_layout()
+        # Display main image
+        plt.subplot(121)
+        plt.imshow(cv2.cvtColor(cv2.imread(img_path), cv2.COLOR_BGR2RGB))
+        plt.title("Input Image")
+        plt.axis('off')
         
-        # Format results
-        formatted_results = []
-        for i, res in enumerate(results[:8]):
-            face_data = {
-                "face_number": i+1,
-                "age": res.get("age", "N/A"),
-                "gender": res.get("dominant_gender", "N/A"),
-                "race": res.get("dominant_race", "N/A"),
-                "emotion": res.get("dominant_emotion", "N/A")
-            }
-            formatted_results.append(face_data)
+        # Display attributes
+        plt.subplot(122)
+        attrs = {k:v for res in results for k,v in res.items() if k != 'region'}
+        plt.barh(list(attrs.keys()), list(attrs.values()))
+        plt.title("Analysis Results")
         
-        return fig, formatted_results
+        return fig, results
     
     except Exception as e:
-        error_msg = str(e)
-        if "No face detected" in error_msg:
-            error_msg = "No face detected in the image. Please try a different image."
-        
-        return None, {"error": error_msg}
+        return None, {"error": str(e)}
     
     finally:
-        # Clean up
-        if os.path.exists(img_path):
-            os.remove(img_path)
-        if os.path.exists(temp_dir):
-            os.rmdir(temp_dir)
+        shutil.rmtree(temp_dir, ignore_errors=True)
 
-# Create Gradio interface
-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 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 facial images
-    """)
+# Gradio interface
+with gr.Blocks(title="Face Analysis Tool", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🔍 Face Analysis Toolkit")
     
     with gr.Tabs():
-        # Verify Faces Tab
-        with gr.TabItem("Verify Faces"):
+        with gr.Tab("Verify Faces"):
+            gr.Markdown("## Compare two faces")
             with gr.Row():
-                img1 = gr.Image(label="First Image", type="pil")
-                img2 = gr.Image(label="Second Image", type="pil")
+                img1 = gr.Image(type="pil", label="First Face")
+                img2 = gr.Image(type="pil", label="Second Face")
+            thresh = gr.Slider(0.1, 1.0, 0.6, label="Matching Threshold")
+            model = gr.Dropdown(["VGG-Face", "Facenet", "OpenFace"], value="VGG-Face")
+            verify_btn = gr.Button("Compare Faces")
+            result_plot = gr.Plot()
+            result_json = gr.JSON()
             
-            with gr.Row():
-                verify_threshold = gr.Slider(0.1, 0.9, value=0.6, step=0.05,
-                                           label="Similarity Threshold (lower = stricter)")
-                verify_model = gr.Dropdown(
-                    choices=["VGG-Face", "Facenet", "OpenFace", "DeepFace", "ArcFace"],
-                    value="VGG-Face",
-                    label="Recognition Model"
-                )
-            
-            verify_btn = gr.Button("Verify Faces", variant="primary")
-            
-            with gr.Row():
-                verify_plot = gr.Plot(label="Comparison Result")
-                verify_results = gr.JSON(label="Verification Details")
-
-        # Find Faces Tab
-        with gr.TabItem("Find Faces"):
-            query_img = gr.Image(label="Query Image", type="pil")
-            
-            with gr.Row():
-                db_path = gr.Textbox(
-                    label="Database Path",
-                    placeholder="/content/drive/MyDrive/your_folder or local path"
-                )
-                db_files = gr.File(label="Or upload images", file_count="multiple")
-            
-            with gr.Row():
-                find_threshold = gr.Slider(0.1, 0.9, value=0.6, step=0.05,
-                                         label="Similarity Threshold")
-                find_model = gr.Dropdown(
-                    choices=["VGG-Face", "Facenet", "OpenFace", "DeepFace", "ArcFace"],
-                    value="VGG-Face",
-                    label="Recognition Model"
-                )
-            
-            find_btn = gr.Button("Find Matches", variant="primary")
-            
-            with gr.Row():
-                find_plot = gr.Plot(label="Matching Results")
-                find_results = gr.JSON(label="Match Details")
-
-        # Analyze Face Tab
-        with gr.TabItem("Analyze Face"):
-            analyze_img = gr.Image(label="Input Image", type="pil")
-            analyze_actions = gr.CheckboxGroup(
-                choices=["age", "gender", "race", "emotion"],
-                value=["age", "gender", "race", "emotion"],
-                label="Analysis Features"
+            verify_btn.click(
+                verify_faces, 
+                [img1, img2, thresh, model], 
+                [result_plot, result_json]
             )
+        
+        with gr.Tab("Find Faces"):
+            gr.Markdown("## Find similar faces in database")
+            query = gr.Image(type="pil", label="Query Image")
+            db = gr.Textbox("/content/drive/MyDrive/db", label="Database Path")
+            files = gr.File(file_count="multiple", label="Or upload files")
+            find_btn = gr.Button("Search Faces")
+            matches_plot = gr.Plot()
+            matches_json = gr.JSON()
             
-            analyze_btn = gr.Button("Analyze Face", variant="primary")
+            find_btn.click(
+                find_faces, 
+                [query, db, thresh, model], 
+                [matches_plot, matches_json]
+            )
+            files.change(lambda x: None, [files], [db])
+        
+        with gr.Tab("Analyze Face"):
+            gr.Markdown("## Analyze facial attributes")
+            inp_img = gr.Image(type="pil", label="Input Image")
+            analyze_btn = gr.Button("Analyze")
+            analysis_plot = gr.Plot()
+            analysis_json = gr.JSON()
             
-            with gr.Row():
-                analyze_plot = gr.Plot(label="Analysis Visualization")
-                analyze_results = gr.JSON(label="Detailed Analysis")
-
-    # Event handlers
-    verify_btn.click(
-        verify_faces,
-        inputs=[img1, img2, verify_threshold, verify_model],
-        outputs=[verify_plot, verify_results]
-    )
-    
-    find_btn.click(
-        find_faces,
-        inputs=[query_img, db_path, find_threshold, find_model],
-        outputs=[find_plot, find_results]
-    )
-    
-    db_files.change(
-        lambda x: "",
-        inputs=db_files,
-        outputs=db_path
-    )
-    
-    analyze_btn.click(
-        analyze_face,
-        inputs=[analyze_img, analyze_actions],
-        outputs=[analyze_plot, analyze_results]
-    )
+            analyze_btn.click(
+                analyze_face, 
+                [inp_img], 
+                [analysis_plot, analysis_json]
+            )
 
-# Launch the app
-if __name__ == "__main__":
-    demo.launch()
+demo.launch()