Fix webcam browser mode, face dedup by person, confidence field, video proxy, upsert faces

app.py

@@ -2395,9 +2395,39 @@ def serve_minio_image(bucket, object_path):
 
 @app.route('/api/v3/video/compressed/<video_id>', methods=['GET'])
 def serve_compressed_video_v3(video_id):
-    """NEW: Simple working compressed video endpoint with local fallback"""
+    """Serve compressed video — proxy from MinIO/B2 to avoid CORS/redirect issues with <video> tags"""
     logger.info(f"🆕 V3 Request to serve compressed video: {video_id}")
     
+    # Helper to stream a MinIO object through Flask (avoids CORS redirect problems)
+    def _stream_from_minio(minio_client, bucket, obj_path, content_length=None):
+        """Stream MinIO object as a Flask response with proper video headers."""
+        try:
+            resp_obj = minio_client.get_object(bucket, obj_path)
+            content_length = content_length or resp_obj.headers.get('Content-Length', '')
+            
+            def generate():
+                try:
+                    for chunk in resp_obj.stream(32 * 1024):  # 32 KB chunks
+                        yield chunk
+                finally:
+                    resp_obj.close()
+                    resp_obj.release_conn()
+            
+            headers = {
+                'Content-Type': 'video/mp4',
+                'Content-Disposition': f'inline; filename="compressed_{video_id}.mp4"',
+                'Accept-Ranges': 'bytes',
+                'Access-Control-Allow-Origin': '*',
+                'Cache-Control': 'public, max-age=3600',
+            }
+            if content_length:
+                headers['Content-Length'] = str(content_length)
+            
+            return Response(generate(), mimetype='video/mp4', headers=headers)
+        except Exception as e:
+            logger.warning(f"Failed to stream {bucket}/{obj_path}: {e}")
+            return None
+    
     # 1. Try MinIO if database is enabled
     if DATABASE_ENABLED:
         try:
@@ -2413,38 +2443,14 @@ def serve_compressed_video_v3(video_id):
                 # Standard path where compressed videos should be
                 minio_path = f"compressed/{video_id}/video.mp4"
                 
-                logger.info(f"🆕 Attempting to generate presigned URL for MinIO: {bucket}/{minio_path}")
+                logger.info(f"🆕 Streaming compressed video from MinIO: {bucket}/{minio_path}")
                 
                 # Check if object exists first
                 stat = minio_client.stat_object(bucket, minio_path)
                 
-                # Generate presigned URL (valid for 1 hour)
-                from datetime import timedelta
-                presigned_url = minio_client.presigned_get_object(
-                    bucket, 
-                    minio_path, 
-                    expires=timedelta(hours=1),
-                    response_headers={
-                        'response-content-disposition': f'inline; filename="compressed_{video_id}.mp4"',
-                        'response-content-type': 'video/mp4'
-                    }
-                )
-                
-                # Fix for Docker vs Localhost networking issues
-                # If running locally but MinIO is in docker/internal network, URL might be unreachabled
-                # We assume if request comes to localhost, MinIO is also on localhost
-                if 'localhost' in request.host or '127.0.0.1' in request.host:
-                   # Replace internal hostname (like 'minio') with localhost if present in URL
-                   # This is a heuristic fix for common dev setups
-                   # Extract port from presigned URL keys
-                   parsed_url = urllib.parse.urlparse(presigned_url)
-                   if parsed_url.hostname not in ['localhost', '127.0.0.1']:
-                       new_netloc = parsed_url.netloc.replace(parsed_url.hostname, 'localhost')
-                       presigned_url = parsed_url._replace(netloc=new_netloc).geturl()
-                       logger.info(f"🔄 Adjusted presigned URL for localhost: {presigned_url}")
-                
-                logger.info(f"🆕 Redirecting to presigned URL for video: {video_id}")
-                return redirect(presigned_url, code=302)
+                stream_resp = _stream_from_minio(minio_client, bucket, minio_path, stat.size)
+                if stream_resp:
+                    return stream_resp
 
             else:
                 logger.warning(f"🆕 Video record not found in DB for: {video_id}")
@@ -2462,32 +2468,15 @@ def serve_compressed_video_v3(video_id):
                     original_path = video_record['minio_object_key']
                     bucket = video_record.get('minio_bucket', 'detectifai-videos')
                     
-                    logger.info(f"🆕 Attempting original video from MinIO: {bucket}/{original_path}")
+                    logger.info(f"🆕 Streaming original video from MinIO: {bucket}/{original_path}")
                     
                     # Check if original exists
                     stat = minio_client.stat_object(bucket, original_path)
                     
-                    # Generate presigned URL for original
-                    from datetime import timedelta
-                    presigned_url = minio_client.presigned_get_object(
-                        bucket, 
-                        original_path, 
-                        expires=timedelta(hours=1),
-                        response_headers={
-                            'response-content-disposition': f'inline; filename="video_{video_id}.mp4"',
-                            'response-content-type': 'video/mp4'
-                        }
-                    )
-                    
-                    # Fix for localhost
-                    if 'localhost' in request.host or '127.0.0.1' in request.host:
-                        parsed_url = urllib.parse.urlparse(presigned_url)
-                        if parsed_url.hostname not in ['localhost', '127.0.0.1']:
-                            new_netloc = parsed_url.netloc.replace(parsed_url.hostname, 'localhost')
-                            presigned_url = parsed_url._replace(netloc=new_netloc).geturl()
-                    
-                    logger.info(f"✅ Redirecting to ORIGINAL video for: {video_id}")
-                    return redirect(presigned_url, code=302)
+                    # Stream through Flask proxy
+                    stream_resp = _stream_from_minio(minio_client, bucket, original_path, stat.size)
+                    if stream_resp:
+                        return stream_resp
                     
             except Exception as original_e:
                 logger.warning(f"🆕 Original video fallback also failed: {original_e}")
@@ -3637,6 +3626,7 @@ def start_live_stream():
         camera_id = data.get('camera_id', 'webcam_01')
         camera_index = data.get('camera_index', 0)  # 0 = default webcam
         stream_url = data.get('stream_url', '').strip()  # RTSP/HTTP stream URL
+        source_type = data.get('source_type', '')  # 'browser_webcam' or 'url'
         
         from live_stream_processor import get_live_processor
         
@@ -3649,14 +3639,22 @@ def start_live_stream():
             }), 400
         
         # Store source info on processor — actual processing happens in feed endpoint
-        processor.camera_index = camera_index
-        processor.stream_url = stream_url if stream_url else None
+        processor.source_type = source_type  # Track source type
+        if source_type == 'browser_webcam':
+            # Browser webcam: frames arrive via /api/live/process-frame, no server camera needed
+            processor.camera_index = -1  # Sentinel: do NOT open any camera
+            processor.stream_url = None
+            logger.info(f"Browser webcam mode for {camera_id} — frames via /api/live/process-frame")
+        else:
+            processor.camera_index = camera_index
+            processor.stream_url = stream_url if stream_url else None
         
         return jsonify({
             'success': True,
             'camera_id': camera_id,
+            'source_type': source_type,
             'stream_url': stream_url or None,
-            'message': 'Live stream ready' + (f' (URL: {stream_url})' if stream_url else ''),
+            'message': 'Live stream ready' + (' (browser webcam)' if source_type == 'browser_webcam' else f' (URL: {stream_url})' if stream_url else ''),
             'video_feed_url': f'/api/live/feed/{camera_id}'
         })
         
@@ -3721,9 +3719,27 @@ def live_video_feed(camera_id):
         from live_stream_processor import get_live_processor
         
         processor = get_live_processor(camera_id)
+        source_type = getattr(processor, 'source_type', '')
         camera_index = getattr(processor, 'camera_index', 0)
         stream_url = getattr(processor, 'stream_url', None)
         
+        # Browser webcam mode: frames arrive via /api/live/process-frame, don't open camera
+        if source_type == 'browser_webcam' or camera_index == -1:
+            logger.info(f"📹 Browser webcam mode — feed endpoint not used (frames via process-frame)")
+            # Return a single "waiting" frame so the request completes gracefully
+            import cv2
+            import numpy as np
+            placeholder = np.zeros((480, 640, 3), dtype=np.uint8)
+            cv2.putText(placeholder, 'Browser Webcam Active', (120, 230), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 255, 0), 2)
+            cv2.putText(placeholder, 'Frames via /api/live/process-frame', (80, 270), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (200, 200, 200), 1)
+            ret, buffer = cv2.imencode('.jpg', placeholder)
+            frame_bytes = buffer.tobytes() if ret else b''
+            return Response(
+                b'--frame\r\nContent-Type: image/jpeg\r\n\r\n' + frame_bytes + b'\r\n',
+                mimetype='multipart/x-mixed-replace; boundary=frame',
+                headers={'Cache-Control': 'no-cache', 'Access-Control-Allow-Origin': '*'}
+            )
+        
         logger.info(f"📹 Video feed requested for camera {camera_id} (index {camera_index}, url={stream_url})")
         logger.info(f"📹 Processor is_processing: {processor.is_processing}")
         

database_video_service.py

@@ -557,16 +557,21 @@ class DatabaseIntegratedVideoService:
                                         logger.debug(traceback.format_exc())
                                     
                                     # Clean up temp file AFTER MongoDB save (not before)
-                                    # Save to MongoDB
+                                    # Save to MongoDB (upsert to avoid duplicates — facial_recognition.py may have already saved this face_id)
                                     try:
                                         # Ensure face_image_path is a string (not None) for schema validation
                                         if not face_data.get('face_image_path'):
                                             face_data['face_image_path'] = ''  # Empty string is valid
                                         
                                         faces_collection = self.db_manager.db.detected_faces
-                                        faces_collection.insert_one(face_data)
+                                        # Use update_one with upsert to prevent double-inserts for the same face_id
+                                        faces_collection.update_one(
+                                            {'face_id': face_data['face_id'], 'video_id': face_data.get('video_id', '')},
+                                            {'$set': face_data},
+                                            upsert=True
+                                        )
                                         face_results.append(face_data)
-                                        logger.info(f"✅ Saved face to MongoDB: {face_data['face_id']}")
+                                        logger.info(f"✅ Saved face to MongoDB (upsert): {face_data['face_id']}")
                                     except Exception as e:
                                         logger.error(f"Failed to save face to MongoDB: {e}")
                                         import traceback

report_generation/data_collector.py

@@ -392,13 +392,13 @@ class DataCollector:
                         )
 
                 face = {
-                    'face_id': str(doc.get('_id', doc.get('face_id', ''))),
+                    'face_id': doc.get('face_id', str(doc.get('_id', ''))),  # Use actual face_id, not MongoDB _id
                     'video_id': doc.get('video_id'),
                     'timestamp': datetime.utcfromtimestamp(doc.get('timestamp')) if isinstance(doc.get('timestamp'), (int, float)) else doc.get('timestamp'),
                     'frame_number': doc.get('frame_number', 0),
-                    'confidence': doc.get('confidence', 0),
-                    'bbox': doc.get('bbox', {}),
-                    'person_id': doc.get('person_id'),
+                    'confidence': doc.get('confidence_score', doc.get('confidence', 0)),  # confidence_score is the field name in DB
+                    'bbox': doc.get('bbox', doc.get('bounding_boxes', {})),
+                    'person_id': doc.get('person_name') or doc.get('person_id'),  # person_name is the actual field
                     'crop_path': crop_path if include_crops else None,
                     'minio_path': minio_object_key or face_image_path,
                     'crop_url': crop_url

report_generation/report_builder.py

@@ -453,29 +453,53 @@ class ReportGenerator:
             content_parts.append("**No keyframes were captured for this video.**\n")
         
         # --- Face Detections subsection ---
-        # Deduplicate faces: group by face_id, keep first occurrence per person
+        # Deduplicate faces by PERSON IDENTITY (person_id/person_name), not just face_id.
+        # face_id includes a UUID that differs per detection; same person may have
+        # multiple face_ids if FAISS didn't match them. Grouping by person_name or
+        # by the face_id prefix (person name part) gives true dedup.
         if faces:
-            seen_face_ids = {}  # face_id -> first face dict
+            person_groups = {}  # dedup_key -> {'face': first_face_dict, 'count': N}
             for f in faces:
+                pid = f.get('person_id') or ''
                 fid = f.get('face_id', '')
-                # Extract base identity from face_id
-                # face_id format: face_{person}_{event}_{type}_{ts}_{idx}_{uuid}
-                # Same person re-detected keeps the same face_id
-                if fid and fid not in seen_face_ids:
-                    seen_face_ids[fid] = f
+                
+                # Build a dedup key:
+                # 1) Named person → use person name  (e.g. "ahmed")
+                # 2) Unknown person → extract prefix from face_id (face_{name}_event...)
+                #    Two unknowns at different times are treated as separate persons
+                #    UNLESS they share the same face_id (FAISS matched them).
+                if pid and pid.lower() not in ('unidentified', 'unknown', ''):
+                    dedup_key = pid.strip().lower()
+                elif fid:
+                    # Extract person-name portion: face_{name}_event_...
+                    # e.g. face_unknown_event_obj_detection_1_000030_00_d127574f
+                    parts = fid.split('_event_')
+                    dedup_key = parts[0] if len(parts) > 1 else fid
+                    # Further: collapse all "face_unknown" into unique entries by full face_id
+                    if dedup_key == 'face_unknown':
+                        dedup_key = fid  # keep separate — can't know if same person
+                else:
+                    dedup_key = f"anon_{id(f)}"  # fallback, unique per entry
+                
+                if dedup_key not in person_groups:
+                    person_groups[dedup_key] = {'face': f, 'count': 1}
+                else:
+                    person_groups[dedup_key]['count'] += 1
+                    # Keep the one with the image/crop_url if the first one didn't have it
+                    if not person_groups[dedup_key]['face'].get('crop_url') and f.get('crop_url'):
+                        person_groups[dedup_key]['face'] = f
 
-            unique_faces = list(seen_face_ids.values())
-            content_parts.append(f"\n### Face Detections ({len(unique_faces)} unique person(s) from {len(faces)} detections)\n")
-            for i, f in enumerate(unique_faces[:10], 1):
+            unique_persons = list(person_groups.values())
+            content_parts.append(f"\n### Face Detections ({len(unique_persons)} unique person(s) from {len(faces)} detections)\n")
+            for i, pg in enumerate(unique_persons[:10], 1):
+                f = pg['face']
+                appearances = pg['count']
                 ts = f.get('timestamp')
                 ts_str = ts.strftime('%H:%M:%S') if hasattr(ts, 'strftime') else str(ts or 'Unknown')
                 conf = f.get('confidence', 0)
                 person_id = f.get('person_id') or 'Unidentified'
                 url = f.get('crop_url')
                 
-                # Count how many times this face_id appears
-                fid = f.get('face_id', '')
-                appearances = sum(1 for x in faces if x.get('face_id') == fid)
                 appearance_text = f", seen {appearances}x" if appearances > 1 else ""
                 
                 content_parts.append(f"**Person {i}** — First seen at {ts_str} (confidence: {conf:.2f}, ID: {person_id}{appearance_text})")