face_recognition_service.py

import os
import logging
import numpy as np
import cv2
from database import get_all_students

# Path to OpenCV's Haar cascade for face detection
CASCADE_PATH = os.path.join(cv2.data.haarcascades, 'haarcascade_frontalface_default.xml')
face_cascade = cv2.CascadeClassifier(CASCADE_PATH)

def get_face_encoding_from_image_file(image_path):
    """Extract face features from an image file using OpenCV."""
    try:
        # Load the image
        image = cv2.imread(image_path)
        if image is None:
            logging.error(f"Failed to load image: {image_path}")
            return None
            
        # Convert to grayscale for face detection
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        
        # Detect faces
        faces = face_cascade.detectMultiScale(gray, 1.1, 4)
        
        if len(faces) == 0:
            logging.warning(f"No face found in image: {image_path}")
            return None
        
        # Get the first face (assuming one person per image)
        x, y, w, h = faces[0]
        
        # Extract face region
        face_img = gray[y:y+h, x:x+w]
        
        # Resize to a standard size for consistency
        face_img = cv2.resize(face_img, (100, 100))
        
        # Flatten the image to create a simple "encoding"
        # This is not as sophisticated as face_recognition's encodings,
        # but it can work for basic differentiation
        face_encoding = face_img.flatten().astype(np.float32)
        
        # Normalize the encoding
        face_encoding = face_encoding / 255.0
        
        return face_encoding
    
    except Exception as e:
        logging.error(f"Error getting face encoding: {str(e)}")
        return None

def recognize_faces(image_path):
    """Recognize faces in an image by comparing with stored student faces."""
    try:
        # Get all students with their face encodings
        students = get_all_students()
        known_face_encodings = []
        known_face_ids = []
        
        for student in students:
            if 'face_encoding' in student and student['face_encoding']:
                known_face_encodings.append(np.array(student['face_encoding']))
                known_face_ids.append(student['id'])
        
        if not known_face_encodings:
            logging.warning("No student face encodings found in database")
            return []
        
        # Load the image
        image = cv2.imread(image_path)
        if image is None:
            logging.error(f"Failed to load image: {image_path}")
            return []
            
        # Convert to grayscale
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        
        # Detect faces
        faces = face_cascade.detectMultiScale(gray, 1.1, 4)
        
        if len(faces) == 0:
            logging.warning(f"No faces found in image: {image_path}")
            return []
        
        recognized_student_ids = []
        
        # For each detected face
        for (x, y, w, h) in faces:
            # Extract and process face region
            face_img = gray[y:y+h, x:x+w]
            face_img = cv2.resize(face_img, (100, 100))
            face_encoding = face_img.flatten().astype(np.float32) / 255.0
            
            # Compare with known faces
            best_match_id = None
            lowest_distance = float('inf')
            
            for i, known_encoding in enumerate(known_face_encodings):
                # Calculate Euclidean distance between encodings
                distance = np.linalg.norm(face_encoding - known_encoding)
                
                # If distance is below threshold, consider it a match
                if distance < 0.5 and distance < lowest_distance:  # Adjust threshold as needed
                    lowest_distance = distance
                    best_match_id = known_face_ids[i]
            
            # If a match was found
            if best_match_id and best_match_id not in recognized_student_ids:
                recognized_student_ids.append(best_match_id)
        
        return recognized_student_ids
    
    except Exception as e:
        logging.error(f"Error recognizing faces: {str(e)}")
        return []

def draw_face_boxes(image_path, output_path):
    """Draw boxes around detected faces in an image and save to output path."""
    try:
        # Load the image
        image = cv2.imread(image_path)
        if image is None:
            logging.error(f"Failed to load image: {image_path}")
            return 0
            
        # Convert to grayscale
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        
        # Detect faces
        faces = face_cascade.detectMultiScale(gray, 1.1, 4)
        
        # Draw rectangle around each face
        for (x, y, w, h) in faces:
            cv2.rectangle(image, (x, y), (x+w, y+h), (0, 255, 0), 2)
        
        # Save the output image
        cv2.imwrite(output_path, image)
        
        return len(faces)
    
    except Exception as e:
        logging.error(f"Error drawing face boxes: {str(e)}")
        return 0

def get_face_count_from_image(image_path):
    """Count the number of faces in an image."""
    try:
        # Load the image
        image = cv2.imread(image_path)
        if image is None:
            logging.error(f"Failed to load image: {image_path}")
            return 0
            
        # Convert to grayscale
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        
        # Detect faces
        faces = face_cascade.detectMultiScale(gray, 1.1, 4)
        
        return len(faces)
    
    except Exception as e:
        logging.error(f"Error counting faces: {str(e)}")
        return 0