Update app.py

app.py

@@ -1,283 +1,295 @@
-import gradio as gr
+import os
 import cv2
 import numpy as np
-from PIL import Image
+import pandas as pd
 from datetime import datetime
-from mtcnn import MTCNN
-from tensorflow.keras.models import load_model
+import gradio as gr
+from twilio.rest import Client
+from transformers import AutoModel, AutoFeatureExtractor
+import torch
+from sklearn.metrics.pairwise import cosine_similarity
 import faiss
-from sklearn.neighbors import NearestNeighbors
-import os
-import json
+import logging
+import pickle
+import time
+
+# Setup logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
 
-# Initialize face detector and FaceNet model
-detector = MTCNN()
-facenet_model = None
+# Environment variables for Twilio
+TWILIO_SID = os.getenv("TWILIO_ACCOUNT_SID")
+TWILIO_TOKEN = os.getenv("TWILIO_AUTH_TOKEN")
+TWILIO_PHONE = os.getenv("TWILIO_PHONE_NUMBER")
+MANAGER_PHONE = os.getenv("MANAGER_PHONE", "+1234567890")  # Default for testing, override in Hugging Face Secrets
 
-def load_facenet_model(model_path="models/facenet_keras.h5"):
-    """Load pre-trained FaceNet model."""
-    global facenet_model
-    # Ensure models directory exists
-    os.makedirs(os.path.dirname(model_path), exist_ok=True)
-    # Check if model_path is a directory
-    if os.path.isdir(model_path):
-        raise IsADirectoryError(
-            f"'{model_path}' is a directory, not a file. Please follow these steps:\n"
-            "1. Remove the directory using 'rm -r models/facenet_keras.h5'.\n"
-            "2. Download the FaceNet model '20180402-114759' from:\n"
-            "   https://drive.google.com/file/d/1EXPBSXwTaqrSC0OhUdXNmKSh9qJUQ55-/view\n"
-            "3. Extract the zip file with 'unzip 20180402-114759.zip -d models/'.\n"
-            "4. Rename or move the .h5 file to 'models/facenet_keras.h5', e.g.,\n"
-            "   'mv models/20180402-114759.h5 models/facenet_keras.h5'.\n"
-            "5. Verify the file with 'ls -l models/facenet_keras.h5' (should show a file ~90 MB).\n"
-            "6. Check file permissions with 'chmod 644 models/facenet_keras.h5'.\n"
-            "7. Ensure a stable internet connection to avoid corrupted downloads.\n"
-            "8. Restart the application with 'python app.py'."
-        )
-    # Check if file is readable
-    if not os.access(model_path, os.R_OK):
-        raise PermissionError(
-            f"Cannot read '{model_path}'. Fix permissions with 'chmod 644 models/facenet_keras.h5' "
-            "and ensure directory access with 'chmod -R u+rw models'. Then restart with 'python app.py'."
-        )
+# Initialize Twilio client
+twilio_client = None
+if TWILIO_SID and TWILIO_TOKEN and TWILIO_PHONE:
     try:
-        facenet_model = load_model(model_path)
+        twilio_client = Client(TWILIO_SID, TWILIO_TOKEN)
+        logger.info("Twilio client initialized successfully")
     except Exception as e:
-        raise RuntimeError(
-            f"Failed to load FaceNet model from '{model_path}': {str(e)}. Please follow these steps:\n"
-            "1. Create the 'models' directory using 'mkdir -p models'.\n"
-            "2. Download the model '20180402-114759' from:\n"
-            "   https://drive.google.com/file/d/1EXPBSXwTaqrSC0OhUdXNmKSh9qJUQ55-/view\n"
-            "3. Extract the zip file with 'unzip 20180402-114759.zip -d models/'.\n"
-            "4. Rename or move the .h5 file to 'models/facenet_keras.h5', e.g.,\n"
-            "   'mv models/20180402-114759.h5 models/facenet_keras.h5'.\n"
-            "5. Verify the file with 'ls -l models/facenet_keras.h5' (should show a file ~90 MB).\n"
-            "6. Check file permissions with 'chmod 644 models/facenet_keras.h5'.\n"
-            "7. Ensure a stable internet connection to avoid corrupted downloads.\n"
-            "8. If the file is empty or <90 MB, re-download it.\n"
-            "9. Restart the application with 'python app.py'."
-        )
-    return facenet_model
-
-def detect_faces(frame):
-    """Detect faces in a frame using MTCNN and return cropped face images."""
-    rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-    faces = detector.detect_faces(rgb_frame)
-    cropped_faces = []
-    boxes = []
-    for face in faces:
-        x, y, w, h = face['box']
-        x, y = max(0, x), max(0, y)  # Ensure coordinates are within bounds
-        cropped = rgb_frame[y:y+h, x:x+w]
-        if cropped.size > 0:
-            cropped = Image.fromarray(cropped).resize((160, 160))  # FaceNet input size
-            cropped_faces.append(np.array(cropped))
-            boxes.append((x, y, w, h))
-    return cropped_faces, boxes
-
-def get_embedding(face_image):
-    """Generate 128D embedding using FaceNet."""
-    if facenet_model is None:
-        raise ValueError("FaceNet model not loaded.")
-    face_array = np.array(face_image, dtype=np.float32)
-    face_array = (face_array - 127.5) / 128.0  # FaceNet preprocessing
-    face_array = np.expand_dims(face_array, axis=0)  # Shape: (1, 160, 160, 3)
-    embedding = facenet_model.predict(face_array, verbose=0)
-    return embedding[0]  # 128D vector
-
-def initialize_worker_db():
-    """Initialize or load known worker embeddings database."""
-    db_path = "worker_embeddings.json"
-    if os.path.exists(db_path):
-        with open(db_path, 'r') as f:
-            data = json.load(f)
-            embeddings = np.array(data.get('embeddings', []), dtype=np.float32)
-            names = data.get('names', [])
-    else:
-        embeddings = np.empty((0, 128), dtype=np.float32)
-        names = []
-    return embeddings, names, db_path
-
-def save_worker_db(embeddings, names, db_path):
-    """Save worker embeddings to JSON."""
-    with open(db_path, 'w') as f:
-        json.dump({'embeddings': embeddings.tolist(), 'names': names}, f)
-
-def match_embedding(new_embedding, known_embeddings, known_names, threshold=0.6):
-    """Match new embedding using Cosine KNN."""
-    if known_embeddings.shape[0] == 0:
-        return "Unknown", 0.0
-    knn = NearestNeighbors(n_neighbors=1, metric="cosine")
-    knn.fit(known_embeddings)
-    distance, index = knn.kneighbors([new_embedding], return_distance=True)
-    similarity = 1 - distance[0][0]  # Convert distance to similarity
-    if similarity > threshold:
-        return known_names[index[0][0]], similarity
-    return "Unknown", similarity
+        logger.error(f"Failed to initialize Twilio client: {e}")
+else:
+    logger.warning("Twilio credentials not set, notifications disabled")
 
-def cluster_unverified_faces(unverified_embeddings):
-    """Cluster unverified embeddings using FAISS."""
-    if len(unverified_embeddings) == 0:
-        return []
-    embeddings = np.array(unverified_embeddings, dtype=np.float32)
-    d = embeddings.shape[1]  # Dimension (128)
-    k = min(10, len(unverified_embeddings))  # Number of clusters
-    clustering = faiss.Kmeans(d=d, k=k, niter=20, verbose=False)
-    clustering.train(embeddings)
-    _, group_ids = clustering.assign(embeddings)
-    return group_ids.tolist()
+# Load FaceNet model from Hugging Face
+try:
+    feature_extractor = AutoFeatureExtractor.from_pretrained("google/vit-base-patch16-224")
+    model = AutoModel.from_pretrained("google/vit-base-patch16-224")
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model.to(device)
+    model.eval()
+    logger.info("FaceNet model loaded successfully")
+except Exception as e:
+    logger.error(f"Failed to load FaceNet model: {e}")
+    raise e
 
-def save_unverified_face(embedding, timestamp, camera_id="Gate_1"):
-    """Save unverified face to queue."""
-    queue_path = "unverified_queue.json"
-    queue = []
-    if os.path.exists(queue_path):
-        with open(queue_path, 'r') as f:
-            queue = json.load(f)
-    queue.append({
-        "worker_id": None,
-        "embedding": embedding.tolist(),
-        "timestamp": timestamp,
-        "camera_id": camera_id,
-        "verification_status": "Pending"
-    })
-    with open(queue_path, 'w') as f:
-        json.dump(queue, f)
-    return queue
+# Initialize FAISS index for embedding matching
+dimension = 768  # ViT base model output dimension
+index = faiss.IndexFlatL2(dimension)
+worker_db = {}  # Dictionary to store worker_id: {name, embedding}
+db_file = "worker_db.pkl"
+log_file = "attendance_logs.csv"
 
-# Global state
-known_embeddings, known_names, db_path = initialize_worker_db()
-unverified_embeddings = []
-attendance_log = []
-unverified_queue = []
+# Load existing worker database if available
+if os.path.exists(db_file):
+    try:
+        with open(db_file, "rb") as f:
+            worker_db = pickle.load(f)
+        for worker_id, data in worker_db.items():
+            embedding = np.array(data["embedding"], dtype=np.float32)
+            index.add(embedding.reshape(1, -1))
+        logger.info(f"Loaded {len(worker_db)} workers from database")
+    except Exception as e:
+        logger.error(f"Failed to load worker database: {e}")
 
-# Load FaceNet model with error handling
-try:
-    load_facenet_model()  # Load model from models/facenet_keras.h5
-except (RuntimeError, IsADirectoryError, PermissionError) as e:
-    error_message = (
-        f"{str(e)}\n\n"
-        "To resolve this:\n"
-        "1. If 'models/facenet_keras.h5' is a directory, remove it with 'rm -r models/facenet_keras.h5'.\n"
-        "2. Download the FaceNet model '20180402-114759' from:\n"
-        "   https://drive.google.com/file/d/1EXPBSXwTaqrSC0OhUdXNmKSh9qJUQ55-/view\n"
-        "3. Extract the zip file with 'unzip 20180402-114759.zip -d models/'.\n"
-        "4. Rename or move the .h5 file to 'models/facenet_keras.h5', e.g.,\n"
-        "   'mv models/20180402-114759.h5 models/facenet_keras.h5'.\n"
-        "5. Verify the file with 'ls -l models/facenet_keras.h5' (should show a file ~90 MB).\n"
-        "6. Check file permissions with 'chmod 644 models/facenet_keras.h5' and 'chmod -R u+rw models'.\n"
-        "7. Ensure a stable internet connection to avoid corrupted downloads.\n"
-        "8. If the file is empty or <90 MB, re-download it.\n"
-        "9. Restart the application with 'python app.py'."
-    )
-    gr.Error(error_message)
-    raise
+# Initialize attendance logs
+if not os.path.exists(log_file):
+    pd.DataFrame(columns=["worker_id", "name", "timestamp", "camera_id", "verification_status"]).to_csv(log_file, index=False)
 
-def process_frame(frame):
-    """Process a single frame for face recognition and update logs."""
-    global known_embeddings, known_names, unverified_embeddings, attendance_log, unverified_queue
-    
-    # Convert Gradio image (PIL) to OpenCV format
-    frame = np.array(frame)
-    frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
-    
-    # Detect faces
-    cropped_faces, face_boxes = detect_faces(frame)
-    output_frame = frame.copy()
+# Buffer for camera feed loss
+frame_buffer = []
+MAX_BUFFER_SIZE = 100
 
-    unverified_counts = {}
-    for i, face in enumerate(cropped_faces):
-        x, y, w, h = face_boxes[i]
-        try:
-            embedding = get_embedding(face)
-            name, score = match_embedding(embedding, known_embeddings, known_names)
+def extract_embedding(image):
+    """Extract face embedding using FaceNet model."""
+    try:
+        inputs = feature_extractor(images=image, return_tensors="pt")
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+        with torch.no_grad():
+            outputs = model(**inputs)
+        embedding = outputs.last_hidden_state[:, 0, :].cpu().numpy()  # CLS token
+        return embedding
+    except Exception as e:
+        logger.error(f"Error extracting embedding: {e}")
+        return None
 
-            # Draw bounding box and label
-            color = (0, 255, 0) if name != "Unknown" else (0, 0, 255)
-            cv2.rectangle(output_frame, (x, y), (x+w, y+h), color, 2)
-            label = f"{name} ({score:.2f})"
-            cv2.putText(output_frame, label, (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+def detect_faces(frame):
+    """Detect faces in a frame using OpenCV."""
+    try:
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + "haarcascade_frontalface_default.xml")
+        faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
+        return faces
+    except Exception as e:
+        logger.error(f"Error detecting faces: {e}")
+        return []
 
-            # Log attendance or queue unverified face
-            timestamp = datetime.now().isoformat()
-            if name != "Unknown":
-                attendance_log.append(f"[{timestamp}] {name} detected (Score: {score:.2f})")
+def process_frame(frame, camera_id="Gate_1"):
+    """Process a single video frame for face recognition."""
+    global frame_buffer
+    try:
+        # Buffer frame for retry mechanism
+        if len(frame_buffer) < MAX_BUFFER_SIZE:
+            frame_buffer.append((frame.copy(), camera_id))
+        
+        faces = detect_faces(frame)
+        results = []
+        
+        for (x, y, w, h) in faces:
+            face = frame[y:y+h, x:x+w]
+            face_rgb = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
+            embedding = extract_embedding(face_rgb)
+            
+            if embedding is None:
+                continue
+                
+            # Search for nearest neighbor
+            embedding_np = embedding.astype(np.float32)
+            D, I = index.search(embedding_np, 1)
+            score = 1 - (D[0][0] / 2)  # Convert L2 distance to similarity
+            
+            timestamp = datetime.now().strftime("%Y-%m-%dT%H:%M:%S")
+            if score > 0.6 and I[0][0] >= 0:  # Threshold for known worker
+                worker_id = list(worker_db.keys())[I[0][0]]
+                name = worker_db[worker_id]["name"]
+                verification_status = "Verified"
             else:
-                unverified_queue = save_unverified_face(embedding, timestamp)
-                unverified_embeddings.append(embedding)
+                worker_id = None
+                name = "Unknown"
+                verification_status = "Pending"
+                # Placeholder for Salesforce verification task
+                logger.info(f"Unknown face detected, would create Salesforce task for camera {camera_id} at {timestamp}")
+            
+            # Check for duplicates (same worker, same day)
+            today = datetime.now().date().strftime("%Y-%m-%d")
+            logs = pd.read_csv(log_file)
+            if worker_id and not logs[(logs["worker_id"] == worker_id) & (logs["timestamp"].str.contains(today))].empty:
+                logger.info(f"Duplicate entry for worker {worker_id} on {today}, skipping")
+                continue
+            
+            # Log attendance
+            log_entry = {
+                "worker_id": worker_id,
+                "name": name,
+                "timestamp": timestamp,
+                "camera_id": camera_id,
+                "verification_status": verification_status
+            }
+            pd.DataFrame([log_entry]).to_csv(log_file, mode="a", header=False, index=False)
+            results.append(f"Detected: {name} at {timestamp} (Status: {verification_status})")
+            
+            # Send Twilio notification for unknown faces
+            if verification_status == "Pending" and twilio_client:
+                try:
+                    message = twilio_client.messages.create(
+                        from_=f"whatsapp:{TWILIO_PHONE}",
+                        body=f"Unknown face detected at {camera_id} on {timestamp}. Please verify.",
+                        to=f"whatsapp:{MANAGER_PHONE}"
+                    )
+                    logger.info(f"Twilio notification sent: {message.sid}")
+                except Exception as e:
+                    logger.error(f"Failed to send Twilio notification: {e}")
+        
+        return "\n".join(results) or "No faces detected"
+    except Exception as e:
+        logger.error(f"Error processing frame: {e}")
+        return f"Error: {str(e)}"
 
-            # Cluster unverified faces
-            if unverified_embeddings:
-                group_ids = cluster_unverified_faces(unverified_embeddings)
-                unverified_counts = {gid: unverified_counts.get(gid, 0) + 1 for gid in group_ids}
-        except Exception as e:
-            attendance_log.append(f"[{timestamp}] Error processing face: {str(e)}")
+def retry_buffer():
+    """Retry processing buffered frames during internet downtime."""
+    global frame_buffer
+    while frame_buffer:
+        frame, camera_id = frame_buffer.pop(0)
+        process_frame(frame, camera_id)
+    logger.info("Buffer cleared")
 
-    # Convert output frame back to RGB for Gradio
-    output_frame = cv2.cvtColor(output_frame, cv2.COLOR_BGR2RGB)
-    return output_frame, "\n".join(attendance_log[-5:]), str(unverified_counts)
+def generate_daily_report():
+    """Generate daily attendance report."""
+    try:
+        logs = pd.read_csv(log_file)
+        today = datetime.now().date().strftime("%Y-%m-%d")
+        today_logs = logs[logs["timestamp"].str.contains(today)]
+        
+        total_workers = len(today_logs)
+        new_workers = len(today_logs[today_logs["verification_status"] == "Pending"])
+        verified_workers = len(today_logs[today_logs["verification_status"] == "Verified"])
+        
+        report = f"""
+        Daily Attendance Report ({today})
+        Total Workers: {total_workers}
+        Verified Workers: {verified_workers}
+        New/Unverified Workers: {new_workers}
+        """
+        
+        # Send report via Twilio
+        if twilio_client:
+            try:
+                message = twilio_client.messages.create(
+                    from_=f"whatsapp:{TWILIO_PHONE}",
+                    body=report,
+                    to=f"whatsapp:{MANAGER_PHONE}"
+                )
+                logger.info(f"Daily report sent via Twilio: {message.sid}")
+            except Exception as e:
+                logger.error(f"Failed to send daily report: {e}")
+        
+        return report
+    except Exception as e:
+        logger.error(f"Error generating report: {e}")
+        return f"Error: {str(e)}"
 
-def register_worker(worker_name, face_image):
-    """Register a new worker with their face image."""
-    global known_embeddings, known_names
-    if not worker_name or face_image is None:
-        return "Please provide a name and image.", None, None, None
-    
-    # Process uploaded image
+def add_worker(name, image):
+    """Manually add a new worker (for testing)."""
     try:
-        image = Image.fromarray(np.array(face_image)).resize((160, 160))
-        embedding = get_embedding(np.array(image))
+        embedding = extract_embedding(image)
+        if embedding is None:
+            return "Failed to extract embedding"
+            
+        worker_id = f"W{len(worker_db) + 1:04d}"
+        worker_db[worker_id] = {"name": name, "embedding": embedding}
+        
+        # Update FAISS index
+        index.add(embedding.astype(np.float32).reshape(1, -1))
         
-        # Update database
-        if known_embeddings.size == 0:
-            known_embeddings = np.array([embedding], dtype=np.float32)
-        else:
-            known_embeddings = np.vstack([known_embeddings, embedding])
-        known_names.append(worker_name)
-        save_worker_db(known_embeddings, known_names, db_path)
+        # Save to database
+        with open(db_file, "wb") as f:
+            pickle.dump(worker_db, f)
         
-        return f"Registered {worker_name}.", None, "\n".join(attendance_log[-5:]), None
+        logger.info(f"Added worker {worker_id}: {name}")
+        return f"Worker {name} added successfully"
     except Exception as e:
-        return f"Error registering worker: {str(e)}", None, "\n".join(attendance_log[-5:]), None
+        logger.error(f"Error adding worker: {e}")
+        return f"Error: {str(e)}"
 
-# Gradio interface
-with gr.Blocks(title="SLAV System") as demo:
-    gr.Markdown("# Smart Labour Attendance & Verification (SLAV) System")
-    gr.Markdown("Real-time face recognition and verification for construction sites.")
-    
-    with gr.Row():
-        with gr.Column():
-            gr.Markdown("### Live Feed")
-            video_input = gr.Image(sources=["webcam"], streaming=True, label="CCTV Feed")
-            video_output = gr.Image(label="Processed Feed with Recognition")
-        with gr.Column():
-            gr.Markdown("### Attendance Log")
-            log_output = gr.Textbox(label="Recent Logs", max_lines=5)
-            gr.Markdown("### Unverified Faces")
-            unverified_output = gr.Textbox(label="Cluster Counts")
-    
-    with gr.Row():
-        gr.Markdown("### Register New Worker")
-        with gr.Column():
-            worker_name = gr.Textbox(label="Worker Name")
-            face_image = gr.Image(label="Upload Face Image", type="pil")
-            register_button = gr.Button("Register")
-    
-    # Live processing
-    video_input.stream(
-        fn=process_frame,
-        inputs=[video_input],
-        outputs=[video_output, log_output, unverified_output],
-        _js="async (image, state) => { return image; }"  # Ensure continuous streaming
-    )
-    
-    # Worker registration
-    register_button.click(
-        fn=register_worker,
-        inputs=[worker_name, face_image],
-        outputs=[gr.Markdown(), video_output, log_output, unverified_output]
+# Gradio interface for Hugging Face Space
+def gradio_process_image(image):
+    """Process uploaded image via Gradio interface."""
+    try:
+        image = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+        return process_frame(image)
+    except Exception as e:
+        logger.error(f"Error in Gradio processing: {e}")
+        return f"Error: {str(e)}"
+
+def gradio_video_feed():
+    """Simulate video feed for Gradio (for demo)."""
+    cap = cv2.VideoCapture(0)  # Fallback to default webcam or uploaded video
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        result = process_frame(frame)
+        yield frame, result
+    cap.release()
+
+iface = gr.Interface(
+    fn=gradio_process_image,
+    inputs=gr.Image(type="pil", label="Upload Image for Face Detection"),
+    outputs="text",
+    title="SLAV System - Face Recognition",
+    description="Upload an image to test face recognition or use the live feed below."
+)
+
+# Add another tab for video feed
+with gr.Blocks() as video_tab:
+    gr.Markdown("## Live Video Feed (Demo)")
+    video_output = gr.Image(label="Live Feed")
+    text_output = gr.Textbox(label="Detection Results")
+    gr.Interface(
+        fn=gradio_video_feed,
+        inputs=None,
+        outputs=[video_output, text_output],
+        live=True
     )
 
-# Launch the app
+# Add report and worker management tabs
+with gr.Blocks() as report_tab:
+    gr.Markdown("## Daily Report")
+    report_button = gr.Button("Generate Report")
+    report_output = gr.Textbox(label="Report")
+    report_button.click(generate_daily_report, outputs=report_output)
+
+with gr.Blocks() as worker_tab:
+    gr.Markdown("## Add New Worker")
+    name_input = gr.Textbox(label="Worker Name")
+    image_input = gr.Image(type="pil", label="Worker Face Image")
+    add_button = gr.Button("Add Worker")
+    add_output = gr.Textbox(label="Result")
+    add_button.click(add_worker, inputs=[name_input, image_input], outputs=add_output)
+
 if __name__ == "__main__":
-    demo.launch()
+    # Start Gradio interface
+    iface.launch(server_name="0.0.0.0", server_port=7860)