Initial commit: Ready for Streamlit deployment

.gitignore

@@ -0,0 +1,12 @@
+# Virtual environment directory
+.venv/
+# Python files generated by the system
+__pycache__/
+*.pyc
+# Data storage (embeddings change locally, shouldn't be in the repo)
+data/embeddings.pkl
+# Local Streamlit cache and config
+.streamlit/
+# Python dependencies (listed in requirements.txt)
+/lib/
+/include/

app.py

@@ -0,0 +1,151 @@
+import streamlit as st
+from streamlit_webrtc import webrtc_streamer, VideoTransformerBase
+import cv2
+import numpy as np
+
+# --- Import your modular code ---
+from src.utils import load_embeddings, save_embeddings
+from src.detect import detect_face
+from src.embed import get_embedding
+from src.recognize import recognize_face_by_embedding
+from src.register import register_new_user # Ensure this is in your src folder
+
+# Use Streamlit's cache to load the persistent data once
+@st.cache_resource
+def load_registered_data():
+    """Load the persistent data structure."""
+    return load_embeddings()
+
+# Global variables for capturing a registration frame
+REGISTRATION_FRAME = None
+# Initialize frame_lock in session state if it doesn't exist
+if 'frame_lock' not in st.session_state:
+    st.session_state['frame_lock'] = False
+FRAME_LOCK = st.session_state['frame_lock']
+
+class FaceRecognitionTransformer(VideoTransformerBase):
+    def __init__(self, data_store, detector_key, mode):
+        self.data_store = data_store
+        self.detector_key = detector_key
+        self.mode = mode
+        
+    def transform(self, frame):
+        img = frame.to_ndarray(format="bgr")
+
+        # 1. Detection
+        detected_faces = detect_face(img, detector_type=self.detector_key)
+        
+        if detected_faces:
+            # We focus on the largest face for simplicity
+            main_face = max(detected_faces, key=lambda x: x['box'][2] * x['box'][3])
+            x, y, w, h = main_face['box']
+            
+            # Crop the face for processing (Alignment & Cropping) 
+            face_img = img[y:y+h, x:x+w] 
+            
+            # 2. Draw bounding box and label
+            label = "Processing..."
+            color = (255, 255, 0) # Yellow/Cyan
+            
+            if self.mode == "Recognition":
+                # 3. Recognition Logic
+                
+                # Embedding extraction
+                embedding = get_embedding(face_img)
+
+                # Comparison Logic
+                name, distance = recognize_face_by_embedding(
+                    embedding, 
+                    self.data_store['embeddings'], 
+                    self.data_store['names']
+                )
+
+                label = f"{name} (Dist: {distance:.2f})"
+                if name != "Unknown":
+                    color = (0, 255, 0) # Green for known
+                else:
+                    color = (0, 0, 255) # Red for unknown
+            
+            elif self.mode == "Registration":
+                # 3. Registration capture mode
+                label = "Ready to Register"
+                color = (0, 255, 255) # Yellow
+                
+                # Capture the frame for registration if the lock is not set
+                global REGISTRATION_FRAME
+                if not st.session_state['frame_lock']:
+                    REGISTRATION_FRAME = face_img
+            
+            # Draw the box and text
+            cv2.rectangle(img, (x, y), (x + w, y + h), color, 2)
+            cv2.putText(img, label, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, color, 2)
+
+        return img
+
+# --- Streamlit UI ---
+
+st.set_page_config(page_title="Smart Office Face Recognition", layout="wide")
+# Removed erroneous tag
+st.title("👨‍💼 Smart Office Access System")
+st.markdown("This system identifies staff members using a webcam, welcomes them, or registers new visitors.")
+
+st.sidebar.title("System Controls")
+mode = st.sidebar.radio("Select Mode", ["Recognition", "Registration"])
+detector_type = st.sidebar.radio(
+    "Select Detector (Bonus Feature)", 
+    ["CNN-based (Default)", "Classical (Haar Cascade)"]
+)
+detector_key = 'cnn' if detector_type == 'CNN-based (Default)' else 'classical'
+
+# Load the persistent data
+data_store = load_registered_data()
+
+if mode == "Registration":
+    st.header("📝 New User Registration")
+    st.info("Press 'Start' to activate the camera. When ready and a face is detected, enter the staff name and press 'Capture & Register'.")
+    
+    user_name = st.text_input("Enter Staff Name", key='reg_name')
+    
+    # ------------------ Registration Stream ------------------
+    webrtc_ctx_reg = webrtc_streamer(
+        key="registration_stream",
+        video_transformer_factory=lambda: FaceRecognitionTransformer(data_store, detector_key, mode),
+        rtc_configuration={"iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]},
+        media_stream_constraints={"video": True, "audio": False},
+        async_transform=True,
+    )
+    
+    if st.button("Capture & Register") and webrtc_ctx_reg.state.playing:
+        if not user_name:
+            st.error("Please enter a name for registration.")
+        elif REGISTRATION_FRAME is None:
+            st.error("No face detected in the frame. Please look at the camera.")
+        else:
+            # Set lock to prevent transformer from overwriting REGISTRATION_FRAME
+            st.session_state['frame_lock'] = True 
+            
+            with st.spinner(f"Registering {user_name} with {detector_type} detector..."):
+                if register_new_user(REGISTRATION_FRAME, user_name):
+                    st.success(f"Registration successful for **{user_name}**! Embedding stored to {{data/embeddings.pkl}}")
+                    # Force reload the data store to include the new user
+                    load_registered_data.clear() 
+                    st.session_state['frame_lock'] = False
+                else:
+                    st.error("Registration failed. Could not generate embedding.")
+
+elif mode == "Recognition":
+    st.header("🔑 Real-time Recognition Check")
+    st.write(f"Currently **{len(data_store['embeddings'])}** users are registered.")
+
+    # ------------------ Recognition Stream ------------------
+    webrtc_ctx_rec = webrtc_streamer(
+        key="recognition_stream",
+        video_transformer_factory=lambda: FaceRecognitionTransformer(data_store, detector_key, mode),
+        rtc_configuration={"iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]},
+        media_stream_constraints={"video": True, "audio": False},
+        async_transform=True,
+    )
+    
+    # ✅ FIX: IndentationError is fixed here by indenting the st.success line.
+    if webrtc_ctx_rec.state.playing:
+        st.success(f"Recognition running with **{detector_type}** detector...")

requirements.txt

@@ -0,0 +1,6 @@
+streamlit
+streamlit-webrtc
+opencv-python
+deepface
+numpy
+scikit-learn

run.py

@@ -0,0 +1,117 @@
+# run.py
+# run.py (Add this to the very top, before imports)
+
+import os
+os.environ["CUDA_VISIBLE_DEVICES"] = "-1" # Forces TensorFlow to use CPU only
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2" # Suppress warnings
+os.environ["TF_FORCE_GPU_ALLOW_GROWTH"] = "true" # For GPU, but harmless on CPU
+os.environ["NUMEXPR_NUM_THREADS"] = "1" # Limit threads for NumPy/NumExpr
+import argparse
+import cv2
+import sys
+import numpy as np
+import tensorflow as tf
+# Import your core logic modules
+from src.utils import load_embeddings
+from src.detect import detect_face
+from src.embed import get_embedding
+from src.recognize import recognize_face_by_embedding
+from src.register import register_new_user 
+
+# Define the logic to process a captured frame for registration or recognition
+def process_frame(frame, mode, detector_key, data_store):
+    
+    # 1. Detection
+    detected_faces = detect_face(frame, detector_type=detector_key)
+    
+    if detected_faces:
+        # Focus on the largest face for processing
+        main_face = max(detected_faces, key=lambda x: x['box'][2] * x['box'][3])
+        x, y, w, h = main_face['box']
+        face_img = frame[y:y+h, x:x+w] 
+        
+        # Draw bounding box on the displayed frame
+        cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 255), 2)
+        
+        if mode == 'register':
+            # Ask for name when face is captured
+            name = input("Enter name to register: ")
+            
+            # 2. Registration Logic
+            if register_new_user(face_img, name):
+                return f"✅ Registration successful for {name}! Please run recognize mode next."
+            else:
+                return "❌ Registration failed. Could not generate embedding."
+                
+        elif mode in ['recognize', 'identify']:
+            # 3. Recognition Logic
+            embedding = get_embedding(face_img)
+            
+            if embedding is None:
+                return "⚠️ Could not generate embedding for recognition."
+
+            name, distance = recognize_face_by_embedding(
+                embedding, 
+                data_store['embeddings'], 
+                data_store['names']
+            )
+            
+            if name != "Unknown":
+                cv2.putText(frame, name, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2)
+                return f"✅ Recognized: {name} (Dist: {distance:.2f})"
+            else:
+                cv2.putText(frame, "Unknown", (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 255), 2)
+                return f"⚠️ Unknown Person (Dist: {distance:.2f})"
+    
+    return "No face detected in the frame."
+
+# --- Main CLI Function ---
+def main():
+    parser = argparse.ArgumentParser(description="Smart Office Face Recognition System CLI.")
+    parser.add_argument('--mode', required=True, choices=['register', 'recognize', 'identify'], help="Operation mode (register or identify/recognize).")
+    parser.add_argument('--detector', required=True, choices=['cnn', 'classical'], help="Detector backend: cnn (MTCNN) or classical (Haar Cascade).")
+    
+    args = parser.parse_args()
+    data_store = load_embeddings() # Initial load of persistent data
+
+    cap = cv2.VideoCapture(0)
+    if not cap.isOpened():
+        print("Error: Could not open webcam.")
+        sys.exit(1)
+        
+    print(f"\n--- Running in {args.mode.upper()} mode with {args.detector.upper()} detector. ---")
+    print("Press 'c' to CAPTURE/PROCESS a face or 'q' to QUIT.\n")
+
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        # Display instructions on the frame
+        cv2.putText(frame, f"MODE: {args.mode.upper()} | DETECTOR: {args.detector.upper()}", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
+        cv2.putText(frame, "Press 'c' to capture.", (10, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
+        cv2.imshow('Smart Office Face Recognition CLI', frame)
+        
+        key = cv2.waitKey(1) & 0xFF
+
+        if key == ord('q'):
+            break
+
+        elif key == ord('c'):
+            print(f"Capture command received. Processing frame in {args.mode} mode...")
+            
+            # Process the captured frame
+            result = process_frame(frame, args.mode, args.detector, data_store)
+            print(result)
+
+            # FIX: Pylance Scope Fix - If registered, reload the local data_store variable for immediate recognition.
+            if "Registration successful" in result:
+                data_store = load_embeddings() 
+                print("Data store reloaded for new user recognition.")
+
+
+    cap.release()
+    cv2.destroyAllWindows()
+
+if __name__ == '__main__':
+    main()

src/detect.py

@@ -0,0 +1,51 @@
+import cv2
+from deepface import DeepFace
+
+def detect_face(image, detector_type='cnn'):
+    """
+    Detects faces in the image using the specified method (MTCNN or Haar Cascade).
+    
+    Args:
+        image (np.array): The input BGR image frame.
+        detector_type (str): 'cnn' for MTCNN (default) or 'classical' for Haar Cascade.
+        
+    Returns:
+        list: A list of dicts/tuples containing detected face info (bounding box, landmarks, confidence).
+              Format: [{'box': (x, y, w, h), 'landmarks': {...}, 'confidence': float}]
+    """
+    
+    # Map detector type to DeepFace backend name
+    if detector_type == 'cnn':
+        backend = 'mtcnn' # Multi-task Cascaded Convolutional Neural Network [cite: 21]
+    elif detector_type == 'classical':
+        backend = 'opencv' # DeepFace uses 'opencv' for Haar Cascade [cite: 26]
+    else:
+        return []
+
+    results = []
+    
+    try:
+        # DeepFace handles detection, alignment, and returns landmarks (for MTCNN)
+        detected_faces = DeepFace.extract_faces(
+            img_path=image, 
+            detector_backend=backend, 
+            enforce_detection=False # Allow processing even if no face is initially found
+        )
+        
+        for face_info in detected_faces:
+            x, y, w, h = face_info['facial_area'].values()
+            
+            # Note: DeepFace automatically handles alignment and cropping internally for embedding, 
+            # but we return the raw box and a placeholder for structured output
+            results.append({
+                'box': (x, y, w, h),
+                # Landmarks are useful for visualizing the alignment process
+                'landmarks': face_info.get('landmarks', {}), 
+                'confidence': face_info.get('confidence', 1.0)
+            })
+
+    except Exception as e:
+        # print(f"Detection error with {detector_type}: {e}")
+        pass
+
+    return results

src/embed.py

@@ -0,0 +1,38 @@
+import numpy as np
+from deepface import DeepFace
+
+# Global variables to hold the model configuration
+MODEL_NAME = "Facenet"
+DIMENSIONS = 128
+
+def get_embedding(face_image):
+    """
+    Extracts the 128-dimensional embedding from the face image using FaceNet.
+    
+    Args:
+        face_image (np.array): The input BGR image frame (must contain a face).
+        
+    Returns:
+        np.array or None: The 128-dimensional embedding vector.
+    """
+    try:
+        # DeepFace handles alignment, preprocessing, and model prediction internally.
+        # Ensure only the area containing the face is passed, or let DeepFace handle cropping.
+        
+        # We use a wrapper function to ensure only the embedding is returned
+        embedding_objs = DeepFace.represent(
+            img_path=face_image,
+            model_name=MODEL_NAME, 
+            enforce_detection=False # If face is already pre-cropped
+        )
+        
+        if embedding_objs:
+            # The embedding is a 128-D vector 
+            embedding = embedding_objs[0]["embedding"]
+            return np.array(embedding)
+            
+    except Exception as e:
+        # print(f"Embedding generation error: {e}")
+        return None
+        
+    return None

src/preload.py

@@ -0,0 +1,26 @@
+# preload.py (Stored in ~/.deepface/weights/ directory)
+
+import deepface
+import os
+
+print("--- Starting DeepFace Model Preloading ---")
+
+# 1. Force download and initialization of FaceNet (for embeddings)
+print("Loading FaceNet model (128-dimensional embeddings)...")
+try:
+    # Use dot notation for DeepFace submodules to avoid Pylance errors
+    model_facenet = deepface.basemodels.FaceNet.loadModel() 
+    print("✅ FaceNet loaded successfully.")
+except Exception as e:
+    print(f"❌ Error loading FaceNet: {e}")
+
+# 2. Force download and initialization of MTCNN (CNN-based detection)
+print("Loading MTCNN detector (CNN-based detection)...")
+try:
+    # Use dot notation for DeepFace submodules
+    detector_mtcnn = deepface.detectors.FaceDetector.build_model('mtcnn') 
+    print("✅ MTCNN loaded successfully.")
+except Exception as e:
+    print(f"❌ Error loading MTCNN: {e}")
+
+print("--- Preloading Complete ---")

src/recognize.py

@@ -0,0 +1,45 @@
+import numpy as np
+from sklearn.metrics.pairwise import cosine_similarity
+
+# The user is identified if cosine distance < 0.5. 
+# Cosine Similarity = 1 - Cosine Distance
+SIMILARITY_THRESHOLD = 0.5 
+
+def recognize_face_by_embedding(current_embedding, known_embeddings, known_names):
+    """
+    Identifies a known person by comparing the current face embedding against stored ones.
+    
+    Args:
+        current_embedding (np.array): The 128-D embedding of the live face.
+        known_embeddings (list): List of stored embedding vectors (numpy arrays).
+        known_names (list): List of names corresponding to the embeddings.
+        
+    Returns:
+        tuple: (Identified Name or "Unknown", Cosine Distance)
+    """
+    if not known_embeddings or current_embedding is None:
+        return "Unknown", 1.0 # No users registered or failed embedding
+        
+    # Reshape for comparison: (1, 128)
+    current_embedding = current_embedding.reshape(1, -1)
+    
+    # Convert list of known embeddings to a NumPy array (N, 128)
+    known_embeddings_array = np.array(known_embeddings)
+
+    # Calculate Cosine Similarity (vector comparison)
+    similarities = cosine_similarity(current_embedding, known_embeddings_array)[0]
+    
+    # Find the best match (highest similarity)
+    best_match_index = np.argmax(similarities)
+    best_similarity = similarities[best_match_index]
+    
+    # Calculate distance for checking the threshold: Distance = 1 - Similarity
+    best_distance = 1.0 - best_similarity
+    
+    # Check if the similarity surpasses the threshold (i.e., distance < 0.5)
+    if best_distance < SIMILARITY_THRESHOLD:
+        identified_name = known_names[best_match_index]
+        return identified_name, best_distance
+    else:
+        # System notes the person as unknown [cite: 44]
+        return "Unknown", best_distance

src/register.py

@@ -0,0 +1,27 @@
+from .embed import get_embedding
+from .utils import load_embeddings, save_embeddings
+
+def register_new_user(face_image, name):
+    """
+    Registers a new user by generating an embedding and persisting it.
+    
+    Args:
+        face_image (np.array): The input BGR image frame (must contain a face).
+        name (str): The name of the user to register.
+        
+    Returns:
+        bool: True on successful registration, False otherwise.
+    """
+    embedding = get_embedding(face_image)
+    
+    if embedding is not None:
+        data = load_embeddings()
+        
+        # Store the created embedding and name
+        data['embeddings'].append(embedding)
+        data['names'].append(name)
+        
+        # Persist data to {data/embeddings.pkl} [cite: 38]
+        return save_embeddings(data)
+    
+    return False                                                

src/utils.py

@@ -0,0 +1,46 @@
+import pickle
+import os
+
+# Define the persistent storage path, navigating two levels up from src/
+EMBEDDINGS_PATH = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'data', 'embeddings.pkl')
+
+def load_embeddings():
+    """
+    Loads all registered embeddings and associated names from the pickle file.
+    
+    Returns:
+        dict: A dictionary with 'embeddings' (list of numpy arrays) and 'names' (list of strings).
+    """
+    if not os.path.exists(EMBEDDINGS_PATH):
+        # Initialize an empty structure if the file doesn't exist
+        return {'embeddings': [], 'names': []}
+    
+    try:
+        with open(EMBEDDINGS_PATH, 'rb') as f:
+            data = pickle.load(f)
+            # Ensure the loaded data has the expected structure
+            if 'embeddings' not in data or 'names' not in data:
+                 return {'embeddings': [], 'names': []}
+            return data
+    except Exception as e:
+        print(f"Error loading embeddings: {e}")
+        # In case of corruption, return empty data
+        return {'embeddings': [], 'names': []}
+
+def save_embeddings(data):
+    """
+    Saves the updated embeddings and names back to the pickle file.
+    
+    Args:
+        data (dict): The dictionary containing 'embeddings' and 'names' lists.
+    """
+    # Ensure the data directory exists
+    os.makedirs(os.path.dirname(EMBEDDINGS_PATH), exist_ok=True)
+    
+    try:
+        with open(EMBEDDINGS_PATH, 'wb') as f:
+            pickle.dump(data, f)
+        return True
+    except Exception as e:
+        print(f"Error saving embeddings: {e}")
+        return False