Update services/vision.py

services/vision.py

@@ -1,13 +1,14 @@
 import cv2
 import os
 import time
+import base64
 from deepface import DeepFace
 from core.config import DETECTOR, MODELS, THRESHOLDS, MIN_FACE_AREA, REQUIRED_AVERAGE_CONFIDENCE
 
 def process_frame_synchronous(frame):
     """
-    The Smart-Hard Pipeline:
-    Calculates weighted average across models and returns failure details.
+    The Visual-Hard Pipeline:
+    Identifies faces and returns base64 crops for debugging.
     """
     report = []
     pipeline_status = {"detected": 0, "identified": 0}
@@ -19,58 +20,64 @@ def process_frame_synchronous(frame):
         for face_obj in raw_faces:
             region = face_obj.get('facial_area', {})
             w, h = region.get('w', 0), region.get('h', 0)
-            
-            if (w * h) < MIN_FACE_AREA:
-                continue
-                
             x, y = region.get('x', 0), region.get('y', 0)
-            cropped_face = frame[y:y+h, x:x+w]
-            if cropped_face.size == 0: continue
-
-            predictions = {}
-            confidences = {}
             
-            for model in MODELS:
-                results = DeepFace.find(img_path=cropped_face, db_path="faces_db", model_name=model, 
-                                        enforce_detection=False, detector_backend="skip", 
-                                        distance_metric="cosine", silent=True)
-                
-                if len(results) > 0 and not results[0].empty:
-                    df = results[0].sort_values(by="distance")
-                    best_match = df.iloc[0]
-                    dist = best_match["distance"]
-                    
-                    # Convert distance to confidence (0.0 distance = 100%)
-                    conf = round((1.0 - dist) * 100, 1)
-                    name = os.path.basename(best_match['identity']).split('.')[0]
+            # Prepare face data structure
+            face_info = {
+                "status": "unknown", 
+                "name": "Unknown", 
+                "score": 0,
+                "box": {"x": x, "y": y, "w": w, "h": h},
+                "crop_b64": ""
+            }
+
+            # Generate Debug Crop
+            if w > 0 and h > 0 and x >= 0 and y >= 0:
+                cropped_face = frame[y:y+h, x:x+w]
+                if cropped_face.size != 0:
+                    # Encode crop to base64 so user can see it in browser
+                    _, buffer = cv2.imencode('.jpg', cropped_face)
+                    face_info["crop_b64"] = "data:image/jpeg;base64," + base64.b64encode(buffer).decode('utf-8')
                     
-                    predictions[model] = name
-                    confidences[model] = conf
-                else:
-                    predictions[model] = "Unknown"
-                    confidences[model] = 0.0
+                    # Quality Gate
+                    if (w * h) >= MIN_FACE_AREA:
+                        # Recognition Logic
+                        predictions = {}
+                        confidences = {}
+                        for model in MODELS:
+                            results = DeepFace.find(img_path=cropped_face, db_path="faces_db", model_name=model, 
+                                                    enforce_detection=False, detector_backend="skip", 
+                                                    distance_metric="cosine", silent=True)
+                            
+                            if len(results) > 0 and not results[0].empty:
+                                df = results[0].sort_values(by="distance")
+                                best_match = df.iloc[0]
+                                conf = round((1.0 - best_match["distance"]) * 100, 1)
+                                predictions[model] = os.path.basename(best_match['identity']).split('.')[0]
+                                confidences[model] = conf
+                            else:
+                                predictions[model] = "Unknown"
+                                confidences[model] = 0.0
 
-            # --- SMART CONSENSUS LOGIC ---
-            # 1. Check if they agree on the NAME
-            all_names = [n for n in predictions.values() if n != "Unknown"]
-            unique_names = set(all_names)
-            
-            avg_conf = sum(confidences.values()) / len(MODELS)
+                        all_names = [n for n in predictions.values() if n != "Unknown"]
+                        unique_names = set(all_names)
+                        avg_conf = sum(confidences.values()) / len(MODELS)
+                        
+                        if len(unique_names) == 1 and avg_conf >= REQUIRED_AVERAGE_CONFIDENCE:
+                            face_info["status"] = "match"
+                            face_info["name"] = all_names[0]
+                            face_info["score"] = avg_conf
+                            pipeline_status["identified"] += 1
+                        else:
+                            face_info["status"] = "fail"
+                            if unique_names: face_info["name"] = list(unique_names)[0]
+                            face_info["score"] = avg_conf
             
-            if len(unique_names) == 1 and avg_conf >= REQUIRED_AVERAGE_CONFIDENCE:
-                confirmed_name = all_names[0]
-                report.append({"status": "match", "name": confirmed_name, "score": avg_conf})
-                pipeline_status["identified"] += 1
-            else:
-                # Failure Report: Tell the user WHO we thought it was and WHAT the score was
-                best_guess = "Unknown"
-                if unique_names: best_guess = list(unique_names)[0]
-                report.append({"status": "fail", "name": best_guess, "score": avg_conf})
+            report.append(face_info)
 
         return report, pipeline_status
 
-    except ValueError:
-        return [], pipeline_status
+    except ValueError: return [], pipeline_status
     except Exception as e:
         print(f"🔴 Critical Pipeline Error: {e}")
         return [], pipeline_status