matrice-analytics 0.1.2__py3-none-any.whl

matrice_analytics/post_processing/face_reg/face_recognition_client.py

@@ -0,0 +1,339 @@
+#!/usr/bin/env python3
+"""
+Facial Recognition API - Python Client for Post-Processing
+
+This client handles vector search and enrollment operations for face recognition
+in the post-processing pipeline using Matrice Session.
+"""
+
+import os
+import base64
+import logging
+import httpx
+from typing import List, Dict, Any, Optional
+from datetime import datetime, timezone
+
+# Import matrice session
+try:
+    from  matrice_common.session import Session
+    HAS_MATRICE_SESSION = True
+except ImportError:
+    HAS_MATRICE_SESSION = False
+    logging.warning("Matrice session not available")
+
+
+class FacialRecognitionClient:
+    """
+    Simplified Face Recognition Client using Matrice Session.
+    All API calls are made through the Matrice session RPC interface.
+    """
+
+    def __init__(self, account_number: str = "", access_key: str = "", secret_key: str = "", 
+                 project_id: str = "", server_id: str = "", session=None):
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+        self.server_id = server_id
+        if not self.server_id:
+            raise ValueError("Server ID is required for Face Recognition Client")
+
+        # Use existing session if provided, otherwise create new one
+        if session is not None:
+            self.session = session
+            # Get project_id from session or parameter
+            self.project_id = getattr(session, 'project_id', '') or project_id or os.getenv("MATRICE_PROJECT_ID", "")
+            self.logger.info("Using existing Matrice session for face recognition client")
+        else:
+            # Initialize credentials from environment if not provided
+            self.account_number = account_number or os.getenv("MATRICE_ACCOUNT_NUMBER", "")
+            self.access_key = access_key or os.getenv("MATRICE_ACCESS_KEY_ID", "")
+            self.secret_key = secret_key or os.getenv("MATRICE_SECRET_ACCESS_KEY", "")
+            self.project_id = project_id or os.getenv("MATRICE_PROJECT_ID", "")
+
+            # Initialize Matrice session
+            if not HAS_MATRICE_SESSION:
+                raise ImportError("Matrice session is required for Face Recognition Client")
+
+            # if not all([self.account_number, self.access_key, self.secret_key]):
+            #     raise ValueError("Missing required credentials: account_number, access_key, secret_key")
+
+            try:
+                self.session = Session(
+                    account_number=self.account_number,
+                    access_key=self.access_key,
+                    secret_key=self.secret_key,
+                    project_id=self.project_id,
+                )
+                self.logger.info("Initialized new Matrice session for face recognition client")
+            except Exception as e:
+                self.logger.error(f"Failed to initialize Matrice session: {e}", exc_info=True)
+                raise
+
+    async def enroll_staff(self, staff_data: Dict[str, Any], image_paths: List[str]) -> Dict[str, Any]:
+        """
+        Enroll a new staff member with face images
+        
+        Args:
+            staff_data: Dictionary containing staff information (staffId, firstName, lastName, etc.)
+            image_paths: List of file paths to face images
+            
+        Returns:
+            Dict containing enrollment response
+        """
+        # Convert images to base64
+        base64_images = []
+        for image_path in image_paths:
+            try:
+                with open(image_path, "rb") as image_file:
+                    base64_image = base64.b64encode(image_file.read()).decode('utf-8')
+                    base64_images.append(base64_image)
+            except Exception as e:
+                self.logger.error(f"Error reading image {image_path}: {e}", exc_info=True)
+                return {"success": False, "error": f"Failed to read image: {e}"}
+
+        return await self.enroll_staff_base64(staff_data, base64_images)
+
+    async def enroll_staff_base64(self, staff_data: Dict[str, Any], base64_images: List[str]) -> Dict[str, Any]:
+        """Enroll staff with base64 encoded images"""
+
+        # Prepare enrollment request
+        enrollment_request = {
+            "staff_info": staff_data,
+            "images": base64_images
+        }
+
+        # Use Matrice session for async RPC call
+        response = await self.session.rpc.async_send_request(
+            method="POST",
+            path=f"/v1/actions/facial_recognition/staff/enroll?serverID={self.server_id}",
+            payload=enrollment_request
+        )
+        return self._handle_response(response)
+
+    async def search_similar_faces(self, face_embedding: List[float], 
+                           threshold: float = 0.3, limit: int = 10, 
+                           collection: str = "staff_enrollment",
+                           location: str = "",
+                           timestamp: str = "") -> Dict[str, Any]:
+        """
+        Search for staff members by face embedding vector
+        
+        Args:
+            face_embedding: Face embedding vector
+            collection: Vector collection name
+            threshold: Similarity threshold (0.0 to 1.0)
+            limit: Maximum number of results to return
+            location: Location identifier for logging
+            timestamp: Current timestamp in ISO format
+            
+        Returns:
+            Dict containing search results with detectionType (known/unknown)
+        """
+        search_request = {
+            "embedding": face_embedding,
+            "collection": collection,
+            "threshold": threshold,
+            "limit": limit,
+            "location": location,
+            "timestamp": timestamp
+        }
+
+        # Use Matrice session for async RPC call
+        response = await self.session.rpc.async_send_request(
+            method="POST",
+            path=f"/v1/actions/facial_recognition/search/similar?serverID={self.server_id}",
+            payload=search_request
+        )
+        return self._handle_response(response)
+
+    async def get_staff_details(self, staff_id: str) -> Dict[str, Any]:
+        """Get full staff details by staff ID"""
+
+        # Use Matrice session for async RPC call
+        response = await self.session.rpc.async_send_request(
+            method="GET",
+            path=f"/v1/actions/facial_recognition/staff/{staff_id}?serverID={self.server_id}",
+            payload={}
+        )
+        return self._handle_response(response)
+
+    async def store_people_activity(self, 
+                                  staff_id: str,
+                                  detection_type: str,
+                                  bbox: List[float],
+                                  location: str,
+                                  employee_id: Optional[str] = None,
+                                  timestamp: str = datetime.now(timezone.utc).isoformat(),
+                                  ) -> str:
+        """
+        Store people activity data and return response with potential upload URLs
+        
+        Args:
+            staff_id: Staff identifier (empty for unknown faces)
+            detection_type: Type of detection (known, unknown, empty)
+            bbox: Bounding box coordinates [x1, y1, x2, y2]
+            location: Location identifier
+            employee_id: Employee ID (for unknown faces, this will be generated)
+            timestamp: Timestamp in ISO format
+            
+        Returns:
+            Dict containing response data including uploadUrl and employeeId for unknown faces,
+            or None if the request failed
+        """
+        activity_request = {
+            "staff_id": staff_id,
+            "type": detection_type,
+            "timestamp": timestamp,
+            "bbox": bbox,
+            "location": location,
+        }
+
+        # Add optional fields if provided
+        if detection_type == "unknown":
+            if employee_id:
+                activity_request["anonymous_id"] = employee_id
+        elif detection_type == "known" and employee_id:
+            activity_request["employee_id"] = employee_id
+        response = await self.session.rpc.async_send_request(
+            method="POST",
+            path=f"/v1/actions/facial_recognition/store_people_activity?serverID={self.server_id}",
+            payload=activity_request
+        )
+        handled_response = self._handle_response(response)
+        if handled_response.get("success", False):
+            data = handled_response.get("data", {})
+            self.logger.debug(f"Successfully stored {detection_type} activity")
+            if not data:
+                self.logger.warning("No data returned form store people activity")
+                return None
+            return data
+        else:
+            self.logger.error(f"Failed to store {detection_type} activity: {handled_response.get('error', 'Unknown error')}")
+            return None
+
+    async def update_staff_images(self, image_url: str, employee_id: str) -> Dict[str, Any]:
+        """Update staff images with uploaded image URL"""
+
+        update_request = {
+            "imageUrl": image_url,
+            "employeeId": employee_id
+        }
+
+        # Use Matrice session for async RPC call
+        response = await self.session.rpc.async_send_request(
+            method="PUT",
+            path=f"/v1/actions/facial_recognition/update_staff_images?serverID={self.server_id}",
+            payload=update_request
+        )
+        return self._handle_response(response)
+
+    async def upload_image_to_url(self, image_bytes: bytes, upload_url: str) -> bool:
+        """Upload image bytes to the provided URL"""
+        try:
+            # Upload the image to the signed URL using async httpx
+            headers = {'Content-Type': 'image/jpeg'}
+            async with httpx.AsyncClient() as client:
+                response = await client.put(upload_url, content=image_bytes, headers=headers)
+
+            if response.status_code in [200, 201]:
+                self.logger.debug(f"Successfully uploaded image to URL")
+                return True
+            else:
+                self.logger.error(f"Failed to upload image: {response.status_code} - {response.text}")
+                return False
+
+        except Exception as e:
+            self.logger.error(f"Error uploading image to URL: {e}", exc_info=True)
+            return False
+
+    async def shutdown_service(self, action_record_id: Optional[str] = None) -> Dict[str, Any]:
+        """Gracefully shutdown the service"""
+
+        payload = {} if not action_record_id else {"actionRecordId": action_record_id}
+
+        # Use Matrice session for async RPC call
+        response = await self.session.rpc.async_send_request(
+            method="DELETE",
+            path=f"/v1/actions/facial_recognition/shutdown?serverID={self.server_id}",
+            payload=payload
+        )
+        return self._handle_response(response)
+
+    async def get_all_staff_embeddings(self) -> Dict[str, Any]:
+        """Get all staff embeddings"""
+
+        payload = {}
+
+        # Use Matrice session for async RPC call
+        response = await self.session.rpc.async_send_request(
+            method="GET",
+            path=f"/v1/actions/facial_recognition/get_all_staff_embeddings?serverID={self.server_id}",
+            payload=payload,
+        )
+        return self._handle_response(response)
+    
+    async def enroll_unknown_person(self, embedding: List[float], image_source: str = None, timestamp: str = None, location: str = None, employee_id: str = None) -> Dict[str, Any]:
+        """Enroll an unknown person"""
+
+        payload = {
+            "embedding": embedding
+        }
+        
+        if image_source:
+            payload["imageSource"] = image_source
+        if timestamp:
+            payload["timestamp"] = timestamp
+        else:
+            payload["timestamp"] = datetime.now(timezone.utc).isoformat()
+        if location:
+            payload["location"] = location
+        if employee_id:
+            payload["employeeId"] = employee_id
+
+        # Use Matrice session for async RPC call
+        response = await self.session.rpc.async_send_request(
+            method="POST",
+            path=f"/v1/actions/facial_recognition/enroll_unknown_person?serverID={self.server_id}",
+            payload=payload,
+        )
+        return self._handle_response(response)
+
+    async def health_check(self) -> Dict[str, Any]:
+        """Check if the facial recognition service is healthy"""
+
+        # Use Matrice session for async RPC call
+        response = await self.session.rpc.async_send_request(
+            method="GET",
+            path=f"/v1/actions/facial_recognition/health?serverID={self.server_id}",
+            payload={}
+        )
+        return self._handle_response(response)
+
+    def _handle_response(self, response: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle RPC response and errors"""
+        try:
+            if response.get("success", True):
+                return response
+            else:
+                error_msg = response.get("error", "Unknown RPC error")
+                self.logger.error(f"RPC Error: {error_msg}", exc_info=True)
+                return {"success": False, "error": error_msg}
+        except Exception as e:
+            self.logger.error(f"Error handling RPC response: {e}", exc_info=True)
+            return {"success": False, "error": f"Response handling error: {e}"}
+
+
+# Factory function for easy initialization
+def create_face_client(account_number: str = None, access_key: str = None, 
+                      secret_key: str = None, project_id: str = None, 
+                      server_id: str = "", session=None) -> FacialRecognitionClient:
+    """Create a facial recognition client with automatic credential detection"""
+    return FacialRecognitionClient(
+        account_number=account_number,
+        access_key=access_key,
+        secret_key=secret_key,
+        project_id=project_id,
+        server_id=server_id,
+        session=session
+    )

matrice_analytics/post_processing/face_reg/people_activity_logging.py

@@ -0,0 +1,283 @@
+import asyncio
+import logging
+import time
+import threading
+from typing import Dict, Optional, Set
+import numpy as np
+import cv2
+from datetime import datetime, timezone
+from .face_recognition_client import FacialRecognitionClient
+
+
+class PeopleActivityLogging:
+    """Background logging system for face recognition activity"""
+
+    def __init__(self, face_client: FacialRecognitionClient = None):
+        self.face_client = face_client
+        self.logger = logging.getLogger(__name__)
+
+        # Queue for processing detections in background
+        self.activity_queue = asyncio.Queue()
+
+        # Thread for background processing
+        self.processing_thread = None
+        self.is_running = False
+
+        # Empty detection tracking
+        self.last_detection_time = time.time()
+        self.empty_detection_logged = False
+        self.empty_detection_threshold = 10.0  # 10 seconds
+
+        # Storage for unknown faces (for debugging/backup)
+        self.unknown_faces_storage = {}
+
+        # Employee ID tracking with timestamps to prevent duplicate logging
+        # TODO: Make this use track_id or similarity check instead of employee_id for better deduplication
+        self.recent_employee_detections: Dict[str, float] = {}
+        self.employee_detection_threshold = 10.0  # 10 seconds
+
+        # Start background processing
+        self.start_background_processing()
+
+    def start_background_processing(self):
+        """Start the background processing thread"""
+        if not self.is_running:
+            self.is_running = True
+            self.processing_thread = threading.Thread(
+                target=self._run_async_loop, daemon=True
+            )
+            self.processing_thread.start()
+            self.logger.info("Started PeopleActivityLogging background processing")
+
+    def stop_background_processing(self):
+        """Stop the background processing thread"""
+        self.is_running = False
+        if self.processing_thread:
+            self.processing_thread.join(timeout=5.0)
+            self.logger.info("Stopped PeopleActivityLogging background processing")
+
+    def _run_async_loop(self):
+        """Run the async event loop in the background thread"""
+        try:
+            # Create new event loop for this thread
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            loop.run_until_complete(self._process_activity_queue())
+        except Exception as e:
+            self.logger.error(f"Error in background processing loop: {e}", exc_info=True)
+        finally:
+            try:
+                loop.close()
+            except:
+                pass
+
+    async def _process_activity_queue(self):
+        """Process activity queue continuously"""
+        while self.is_running:
+            try:
+                # Process queued detections with timeout
+                try:
+                    activity_data = await asyncio.wait_for(
+                        self.activity_queue.get(), timeout=20
+                    )
+                    await self._process_activity(activity_data)
+                    self.activity_queue.task_done()
+                except asyncio.TimeoutError:
+                    # Continue loop to check for empty detections
+                    continue
+
+            except Exception as e:
+                self.logger.error(f"Error processing activity queue: {e}", exc_info=True)
+                await asyncio.sleep(1.0)
+
+    async def enqueue_detection(
+        self,
+        detection: Dict,
+        current_frame: Optional[np.ndarray] = None,
+        location: str = "",
+    ):
+        """Enqueue a detection for background processing"""
+        try:
+            activity_data = {
+                "detection_type": detection["recognition_status"],  # known, unknown
+                "detection": detection,
+                "current_frame": current_frame,
+                "location": location,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "employee_id": detection.get("employee_id", None),
+                "staff_id": detection.get("person_id")
+            }
+            if detection["recognition_status"] not in ["known", "unknown"]:
+                self.logger.warning(
+                    f"Invalid detection status: {detection['recognition_status']}"
+                )
+                return
+            if not detection.get("employee_id", None):
+                self.logger.warning(
+                    f"No employee_id found for detection: {detection}"
+                )
+                return
+            if not detection.get("person_id", None):
+                self.logger.warning(
+                    f"No person_id found for detection: {detection}"
+                )
+                return
+
+            bbox = detection.get("bounding_box", {})
+            bbox_list = [
+                bbox.get("xmin", 0),
+                bbox.get("ymin", 0),
+                bbox.get("xmax", 0),
+                bbox.get("ymax", 0),
+            ]
+            activity_data["bbox"] = bbox_list
+            # Update last detection time
+            self.last_detection_time = time.time()
+            self.empty_detection_logged = False
+
+            await self.activity_queue.put(activity_data)
+        except Exception as e:
+            self.logger.error(f"Error enqueueing detection: {e}", exc_info=True)
+
+    def _should_log_detection(self, employee_id: str) -> bool:
+        """
+        Check if detection should be logged based on employee ID and time threshold.
+        Only log if employee_id was not detected in the past 10 seconds.
+        
+        TODO: Make this use track_id or similarity check instead of just employee_id in 10 secs window
+        for better deduplication across different detection sessions.
+        """
+        current_time = time.time()
+        
+        # Clean up old entries (older than threshold)
+        expired_keys = [
+            emp_id for emp_id, timestamp in self.recent_employee_detections.items()
+            if current_time - timestamp > self.employee_detection_threshold
+        ]
+        for emp_id in expired_keys:
+            del self.recent_employee_detections[emp_id]
+        
+        # Check if employee was recently detected
+        if employee_id in self.recent_employee_detections:
+            last_detection = self.recent_employee_detections[employee_id]
+            if current_time - last_detection < self.employee_detection_threshold:
+                self.logger.debug(f"Skipping logging for employee {employee_id} - detected {current_time - last_detection:.1f}s ago")
+                return False
+        
+        # Update detection time for this employee
+        self.recent_employee_detections[employee_id] = current_time
+        return True
+
+    async def _process_activity(self, activity_data: Dict):
+        """Process activity data - handle all face detections and uploads"""
+        detection_type = activity_data["detection_type"]
+        current_frame = activity_data["current_frame"]
+        bbox = activity_data["bbox"]
+        employee_id = activity_data["employee_id"]
+        location = activity_data["location"]
+        staff_id = activity_data["staff_id"]
+        timestamp = activity_data["timestamp"]
+        
+        try:
+            if not self.face_client:
+                return
+
+            # Check if we should log this detection (avoid duplicates within time window)
+            if not self._should_log_detection(employee_id):
+                return None
+
+            # Store activity data
+            self.logger.info(f"Storing activity data for employee {employee_id}")
+            upload_url = await self.face_client.store_people_activity(
+                staff_id=staff_id,
+                detection_type=detection_type,
+                bbox=bbox,
+                location=location,
+                employee_id=employee_id,
+                timestamp=timestamp,
+            )
+
+            if upload_url:
+                self.logger.debug("Successfully stored activity log and fetched upload URL")
+                await self._upload_frame(current_frame, upload_url, employee_id)
+            else:
+                self.logger.warning("Failed to store activity log")
+
+            return upload_url
+        except Exception as e:
+            self.logger.error(f"Error storing activity log: {e}", exc_info=True)
+
+
+    async def _upload_frame(self, current_frame: np.ndarray, upload_url: str, employee_id: str):
+        _, buffer = cv2.imencode(".jpg", current_frame)
+        frame_bytes = buffer.tobytes()
+
+        upload_success = await self.face_client.upload_image_to_url(
+            frame_bytes, upload_url
+        )
+
+        if upload_success:
+            self.logger.info(f"Successfully uploaded whole frame for employee {employee_id}")
+        else:
+            self.logger.warning("Failed to upload whole frame")
+
+    async def _should_log_activity(self, activity_data: Dict) -> bool:
+        """Check if activity should be logged"""
+        detection_type = activity_data["detection_type"]
+        if detection_type == "known":
+            return True
+        return False
+
+    def _crop_face_from_frame(self, frame: np.ndarray, bounding_box: Dict) -> bytes:
+        """
+        Crop face from frame using bounding box and return as bytes
+
+        Args:
+            frame: Original frame as numpy array
+            bounding_box: Dict with x1, y1, x2, y2 coordinates
+
+        Returns:
+            bytes: Cropped face image as JPEG bytes
+        """
+        try:
+            # Extract coordinates - handle different bounding box formats
+            x1 = int(bounding_box.get("xmin", bounding_box.get("x1", 0)))
+            y1 = int(bounding_box.get("ymin", bounding_box.get("y1", 0)))
+            x2 = int(bounding_box.get("xmax", bounding_box.get("x2", 0)))
+            y2 = int(bounding_box.get("ymax", bounding_box.get("y2", 0)))
+
+            # Ensure coordinates are within frame bounds
+            h, w = frame.shape[:2]
+            x1, y1 = max(0, x1), max(0, y1)
+            x2, y2 = min(w, x2), min(h, y2)
+
+            # Validate coordinates
+            if x2 <= x1 or y2 <= y1:
+                self.logger.warning("Invalid bounding box coordinates")
+                return b""
+
+            # Crop the face
+            cropped_face = frame[y1:y2, x1:x2]
+
+            # Convert to JPEG bytes
+            _, buffer = cv2.imencode(".jpg", cropped_face)
+            return buffer.tobytes()
+
+        except Exception as e:
+            self.logger.error(f"Error cropping face from frame: {e}", exc_info=True)
+            return b""
+
+    def get_unknown_faces_storage(self) -> Dict[str, bytes]:
+        """Get stored unknown face images as bytes"""
+        return self.unknown_faces_storage.copy()
+
+    def clear_unknown_faces_storage(self) -> None:
+        """Clear stored unknown face images"""
+        self.unknown_faces_storage.clear()
+
+    def __del__(self):
+        """Cleanup when object is destroyed"""
+        try:
+            self.stop_background_processing()
+        except:
+            pass