python_face_auth.py

#!/usr/bin/env python3
"""
High-Accuracy Face Authentication using Python
Achieves 99%+ accuracy using industry-standard libraries
"""

import face_recognition
import cv2
import numpy as np
import json
import os
import time
from datetime import datetime
from typing import List, Dict, Tuple, Optional
import pickle
import argparse

class HighAccuracyFaceAuth:
    def __init__(self, db_path: str = "python_face_database.json"):
        self.db_path = db_path
        self.face_encodings_cache = {}
        self.load_database()

    def load_database(self):
        """Load face database or create new one"""
        try:
            if os.path.exists(self.db_path):
                with open(self.db_path, 'r') as f:
                    self.database = json.load(f)
                print(f"✅ Loaded database with {len(self.database.get('users', {}))} users")
            else:
                self.database = {
                    "users": {},
                    "version": "1.0",
                    "accuracy_threshold": 0.6,  # Face_recognition library optimal threshold
                    "created": datetime.now().isoformat()
                }
                print("📁 Created new face database")
        except Exception as e:
            print(f"❌ Error loading database: {e}")
            self.database = {"users": {}, "version": "1.0", "accuracy_threshold": 0.6}

    def save_database(self):
        """Save database to file"""
        try:
            with open(self.db_path, 'w') as f:
                json.dump(self.database, f, indent=2)
        except Exception as e:
            print(f"❌ Error saving database: {e}")

    def capture_from_camera(self, save_path: str) -> bool:
        """Capture image from camera with auto-capture"""
        print("📷 Initializing camera...")
        cap = cv2.VideoCapture(0)

        if not cap.isOpened():
            print("❌ Could not open camera")
            return False

        print("📸 Camera ready! Auto-capturing in 3 seconds...")
        print("💡 Look directly at the camera and stay still...")

        # Auto-capture after a short delay
        frame_count = 0
        capture_frame = 90  # Capture after ~3 seconds (30 FPS)

        while True:
            ret, frame = cap.read()
            if not ret:
                print("❌ Failed to read from camera")
                break

            frame_count += 1

            # Show countdown
            if frame_count % 30 == 0:  # Every second
                seconds_left = max(0, 3 - (frame_count // 30))
                if seconds_left > 0:
                    print(f"📸 Capturing in {seconds_left}...")

            # Display frame with countdown
            display_frame = frame.copy()
            if frame_count < capture_frame:
                seconds_left = max(0, 3 - (frame_count // 30))
                cv2.putText(display_frame, f"Capturing in {seconds_left}...",
                           (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
            else:
                cv2.putText(display_frame, "CAPTURED!",
                           (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

            cv2.imshow('Face Authentication - Auto Capture', display_frame)

            # Auto-capture
            if frame_count >= capture_frame:
                cv2.imwrite(save_path, frame)
                print(f"✅ Image auto-captured: {save_path}")
                break

            # Allow manual escape
            key = cv2.waitKey(1) & 0xFF
            if key == 27:  # Escape key
                print("❌ Capture cancelled")
                cap.release()
                cv2.destroyAllWindows()
                return False

        cap.release()
        cv2.destroyAllWindows()
        return True

    def detect_and_encode_faces(self, image_path: str) -> Tuple[List[np.ndarray], List[Tuple]]:
        """
        Detect faces and generate high-accuracy encodings
        Returns: (face_encodings, face_locations)
        """
        print(f"🔍 Analyzing image: {image_path}")

        # Load image
        image = face_recognition.load_image_file(image_path)

        # Find face locations using CNN model (more accurate but slower)
        print("🎯 Detecting faces with CNN model...")
        face_locations = face_recognition.face_locations(image, model="cnn")

        if not face_locations:
            print("⚠️  No faces found, trying HOG model...")
            # Fallback to HOG model (faster but less accurate)
            face_locations = face_recognition.face_locations(image, model="hog")

        if not face_locations:
            raise Exception("No faces detected in image")

        print(f"✅ Found {len(face_locations)} face(s)")

        # Generate face encodings (128-dimensional vector)
        print("🧠 Generating face encodings...")
        face_encodings = face_recognition.face_encodings(image, face_locations)

        print(f"✅ Generated {len(face_encodings)} face encoding(s)")
        return face_encodings, face_locations

    def register_user(self, user_id: str, num_samples: int = 3) -> bool:
        """Register user with multiple face samples"""
        print(f"\n🎯 === Face Registration for User: '{user_id}' ===")
        print(f"📊 Will capture {num_samples} samples for optimal accuracy")

        face_encodings = []

        for i in range(num_samples):
            print(f"\n--- 📸 Sample {i+1}/{num_samples} ---")
            print("💡 Tips for best results:")
            print("   • Look directly at the camera")
            print("   • Ensure good lighting")
            print("   • Keep a neutral expression")
            print("   • Avoid glasses/hats if possible")

            # Capture image
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
            image_path = f"captured_images/registration_{user_id}_{timestamp}_sample{i+1}.jpg"

            os.makedirs("captured_images", exist_ok=True)

            if not self.capture_from_camera(image_path):
                print(f"❌ Failed to capture sample {i+1}")
                continue

            try:
                # Extract face encodings
                encodings, locations = self.detect_and_encode_faces(image_path)

                if encodings:
                    face_encodings.append({
                        "encoding": encodings[0].tolist(),  # Convert numpy array to list for JSON
                        "timestamp": datetime.now().isoformat(),
                        "image_path": image_path,
                        "sample_id": f"{user_id}_{timestamp}"
                    })
                    print(f"✅ Sample {i+1} processed successfully!")
                else:
                    print(f"❌ No face found in sample {i+1}")

            except Exception as e:
                print(f"❌ Error processing sample {i+1}: {e}")

        if not face_encodings:
            print("❌ No valid face samples captured")
            return False

        # Store in database
        if "users" not in self.database:
            self.database["users"] = {}

        self.database["users"][user_id] = {
            "user_id": user_id,
            "face_encodings": face_encodings,
            "enrollment_date": datetime.now().isoformat(),
            "sample_count": len(face_encodings),
            "last_authentication": None,
            "authentication_count": 0
        }

        self.save_database()

        print(f"\n🎉 === Registration Complete ===")
        print(f"✅ Successfully registered {len(face_encodings)} samples for '{user_id}'")
        print(f"🔐 User is ready for high-accuracy authentication!")

        return True

    def authenticate_user(self, tolerance: float = 0.6) -> Dict:
        """Authenticate user with high accuracy"""
        print("\n🔍 === Face Authentication ===")

        # Capture authentication image
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        auth_image_path = f"captured_images/authentication_{timestamp}.jpg"

        os.makedirs("captured_images", exist_ok=True)

        if not self.capture_from_camera(auth_image_path):
            return {"success": False, "error": "Failed to capture image"}

        start_time = time.time()

        try:
            # Extract face encoding from authentication image
            auth_encodings, auth_locations = self.detect_and_encode_faces(auth_image_path)

            if not auth_encodings:
                return {"success": False, "error": "No face detected in authentication image"}

            auth_encoding = auth_encodings[0]  # Use first detected face

            # Compare against all registered users
            print(f"🔍 Comparing against {len(self.database.get('users', {}))} registered users...")

            best_match = None
            best_distance = float('inf')

            for user_id, user_data in self.database.get("users", {}).items():
                user_encodings = [np.array(sample["encoding"]) for sample in user_data["face_encodings"]]

                # Calculate distances to all samples for this user
                distances = face_recognition.face_distance(user_encodings, auth_encoding)
                min_distance = np.min(distances)
                avg_distance = np.mean(distances)

                # Use weighted score: 70% minimum distance, 30% average distance
                score = 0.7 * min_distance + 0.3 * avg_distance

                print(f"👤 User '{user_id}': min_dist={min_distance:.3f}, avg_dist={avg_distance:.3f}, score={score:.3f}")

                if score < best_distance:
                    best_distance = score
                    best_match = {
                        "user_id": user_id,
                        "distance": min_distance,
                        "avg_distance": avg_distance,
                        "confidence": max(0, 1 - min_distance),  # Convert distance to confidence
                        "score": score
                    }

            processing_time = time.time() - start_time

            # Determine if authentication is successful
            is_match = best_match and best_distance <= tolerance

            result = {
                "success": True,
                "is_match": is_match,
                "matched_user": best_match["user_id"] if best_match else None,
                "confidence": best_match["confidence"] if best_match else 0,
                "distance": best_match["distance"] if best_match else float('inf'),
                "threshold": tolerance,
                "processing_time_ms": int(processing_time * 1000),
                "image_path": auth_image_path
            }

            if is_match:
                # Update authentication stats
                user_data = self.database["users"][best_match["user_id"]]
                user_data["last_authentication"] = datetime.now().isoformat()
                user_data["authentication_count"] = user_data.get("authentication_count", 0) + 1
                self.save_database()

                print(f"\n✅ Authentication Successful!")
                print(f"👤 User: {best_match['user_id']}")
                print(f"🎯 Confidence: {result['confidence']:.1%}")
                print(f"📏 Distance: {result['distance']:.3f}")
                print(f"⚡ Processing: {result['processing_time_ms']}ms")
            else:
                print(f"\n❌ Authentication Failed!")
                if best_match:
                    print(f"👤 Closest match: {best_match['user_id']}")
                    print(f"🎯 Confidence: {result['confidence']:.1%}")
                    print(f"📏 Distance: {result['distance']:.3f} (threshold: {tolerance:.3f})")
                print(f"⚡ Processing: {result['processing_time_ms']}ms")

            return result

        except Exception as e:
            return {"success": False, "error": str(e)}

def main():
    parser = argparse.ArgumentParser(description="High-Accuracy Face Authentication")
    parser.add_argument("--mode", choices=["register", "auth"], required=True,
                       help="Mode: register or authenticate")
    parser.add_argument("--user", type=str, help="User ID for registration")
    parser.add_argument("--samples", type=int, default=3, help="Number of samples for registration")
    parser.add_argument("--tolerance", type=float, default=0.6, help="Authentication tolerance")

    args = parser.parse_args()

    # Initialize face authentication system
    face_auth = HighAccuracyFaceAuth()

    if args.mode == "register":
        if not args.user:
            print("❌ User ID required for registration")
            return

        success = face_auth.register_user(args.user, args.samples)
        if success:
            print("🎉 Registration completed successfully!")
        else:
            print("❌ Registration failed!")

    elif args.mode == "auth":
        result = face_auth.authenticate_user(args.tolerance)

        if result["success"] and result["is_match"]:
            print("🎉 Access Granted!")
            exit(0)
        else:
            print("🔒 Access Denied!")
            exit(1)

if __name__ == "__main__":
    main()