Update app.py

app.py

@@ -1,82 +1,69 @@
-import gradio as gr
 import cv2
-import face_recognition
+import mediapipe as mp
 import numpy as np
-import pickle
-import os
-
-# Directory where face images are stored
-dataset_dir = "face_images"
-
-# Check if face encodings file exists, if not create it
-encodings_file = "face_encodings.pkl"
-if not os.path.exists(encodings_file):
-    def create_encodings():
-        known_face_encodings = []
-        known_face_names = []
-
-        for person_name in os.listdir(dataset_dir):
-            person_folder = os.path.join(dataset_dir, person_name)
-            if not os.path.isdir(person_folder):
-                continue
-
-            for filename in os.listdir(person_folder):
-                image_path = os.path.join(person_folder, filename)
-                image = face_recognition.load_image_file(image_path)
-                face_encodings = face_recognition.face_encodings(image)
-
-                if face_encodings:
-                    known_face_encodings.append(face_encodings[0])
-                    known_face_names.append(person_name)
+import gradio as gr
 
-        encodings_data = {"encodings": known_face_encodings, "names": known_face_names}
-        with open(encodings_file, "wb") as file:
-            pickle.dump(encodings_data, file)
-        print("Encodings saved to face_encodings.pkl")
+# Initialize Mediapipe solutions
+mp_hands = mp.solutions.hands
+mp_face_mesh = mp.solutions.face_mesh
+mp_drawing = mp.solutions.drawing_utils
 
-    create_encodings()
+# Function to process and draw landmarks on the input image
+def process_image(input_image):
+    # Convert input image to RGB for Mediapipe
+    rgb_image = cv2.cvtColor(input_image, cv2.COLOR_BGR2RGB)
 
-# Load face encodings
-with open(encodings_file, "rb") as file:
-    data = pickle.load(file)
-    known_face_encodings = data["encodings"]
-    known_face_names = data["names"]
+    # Initialize Hands and Face Mesh models
+    with mp_hands.Hands(static_image_mode=True, min_detection_confidence=0.5) as hands, \
+         mp_face_mesh.FaceMesh(static_image_mode=True, min_detection_confidence=0.5) as face_mesh:
+        
+        # Process the image for hands
+        hand_results = hands.process(rgb_image)
+        # Process the image for face mesh
+        face_results = face_mesh.process(rgb_image)
 
-def capture_and_recognize():
-    cap = cv2.VideoCapture(0)
-    ret, frame = cap.read()
-    if not ret:
-        cap.release()
-        return None, "Failed to capture image from webcam."
+        # Draw Hand Landmarks
+        if hand_results.multi_hand_landmarks:
+            for hand_landmarks in hand_results.multi_hand_landmarks:
+                mp_drawing.draw_landmarks(
+                    input_image, hand_landmarks, mp_hands.HAND_CONNECTIONS,
+                    mp_drawing.DrawingSpec(color=(121, 22, 76), thickness=2, circle_radius=4),
+                    mp_drawing.DrawingSpec(color=(250, 44, 250), thickness=2, circle_radius=2)
+                )
 
-    rgb_image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-    face_locations = face_recognition.face_locations(rgb_image)
-    face_encodings = face_recognition.face_encodings(rgb_image, face_locations)
+        # Draw Face Mesh Landmarks
+        if face_results.multi_face_landmarks:
+            for face_landmarks in face_results.multi_face_landmarks:
+                mp_drawing.draw_landmarks(
+                    input_image, face_landmarks, mp_face_mesh.FACEMESH_TESSELATION,
+                    mp_drawing.DrawingSpec(color=(80, 110, 10), thickness=1, circle_radius=1),
+                    mp_drawing.DrawingSpec(color=(80, 256, 121), thickness=1, circle_radius=1)
+                )
+    
+    return input_image
 
-    names = []
-    for face_encoding in face_encodings:
-        matches = face_recognition.compare_faces(known_face_encodings, face_encoding)
-        name = "Unknown"
-        face_distances = face_recognition.face_distance(known_face_encodings, face_encoding)
-        best_match_index = np.argmin(face_distances)
-        if matches[best_match_index]:
-            name = known_face_names[best_match_index]
-        names.append(name)
+# Gradio interface
+def gradio_interface(image):
+    # Convert Gradio PIL image to OpenCV format
+    image = np.array(image)
+    image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
 
-        for (top, right, bottom, left), name in zip(face_locations, names):
-            cv2.rectangle(frame, (left, top), (right, bottom), (0, 255, 0), 2)
-            cv2.putText(frame, name, (left + 6, bottom - 6), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
+    # Process the image to detect landmarks
+    processed_image = process_image(image)
 
-    cap.release()
-    return frame, "Recognized Names: " + ", ".join(names)
+    # Convert the processed image back to RGB for display in Gradio
+    processed_image = cv2.cvtColor(processed_image, cv2.COLOR_BGR2RGB)
+    return processed_image
 
+# Define Gradio app
 iface = gr.Interface(
-    fn=capture_and_recognize,
-    inputs=[],
-    outputs=["image", "text"],
-    live=True,
-    title="Facial Recognition Attendance System",
-    description="Capture your face for attendance."
+    fn=gradio_interface,
+    inputs=gr.Image(type="pil", tool="editor"),
+    outputs=gr.Image(type="numpy"),
+    title="Face and Hand Landmarks Detection",
+    description="Upload an image or take a photo to detect face and hand landmarks using Mediapipe and OpenCV."
 )
 
-iface.launch()
+# Launch Gradio app
+if __name__ == "__main__":
+    iface.launch()