Upload hf_job_gaze.py with huggingface_hub

hf_job_gaze.py

@@ -56,20 +56,88 @@ def init_gaze_estimator(device='cuda'):
     return pipeline
 
 
-def estimate_gaze_batch(pipeline, image_bgr, bboxes):
-    """Run L2CS once and match results to bboxes"""
+def make_square_bbox_with_padding(bbox, img_width, img_height, padding=0.15):
+    """Convert bbox to square with padding for gaze estimation"""
+    x1, y1, x2, y2 = bbox
+    w = x2 - x1
+    h = y2 - y1
+    
+    # Make square
+    size = max(w, h)
+    cx = (x1 + x2) / 2
+    cy = (y1 + y2) / 2
+    
+    # Add padding
+    size = size * (1 + padding)
+    
+    # Get square bbox
+    x1_sq = max(0, int(cx - size / 2))
+    y1_sq = max(0, int(cy - size / 2))
+    x2_sq = min(img_width, int(cx + size / 2))
+    y2_sq = min(img_height, int(cy + size / 2))
+    
+    return [x1_sq, y1_sq, x2_sq, y2_sq]
+
+
+def has_valid_face(keypoints_2d, keypoints_3d, img_width, img_height):
+    """Check if human has a valid, visible face"""
+    if keypoints_2d is None or keypoints_3d is None:
+        return False
+    
+    kpts2d_arr = np.array(keypoints_2d)
+    kpts3d_arr = np.array(keypoints_3d)
+    
+    if len(kpts2d_arr) < 3 or len(kpts3d_arr) < 3:
+        return False
+    
+    # Check face keypoints (nose, left eye, right eye)
+    nose_2d = kpts2d_arr[0]
+    left_eye_2d = kpts2d_arr[1]
+    right_eye_2d = kpts2d_arr[2]
+    nose_3d = kpts3d_arr[0]
+    left_eye_3d = kpts3d_arr[1]
+    right_eye_3d = kpts3d_arr[2]
+    
+    # Check 3D keypoints are valid (not at origin)
+    keypoints_valid_3d = (np.linalg.norm(nose_3d) > 1e-6 and 
+                         np.linalg.norm(left_eye_3d) > 1e-6 and 
+                         np.linalg.norm(right_eye_3d) > 1e-6)
+    
+    if not keypoints_valid_3d:
+        return False
+    
+    # Check 2D keypoints are within image bounds
+    for kp in [nose_2d, left_eye_2d, right_eye_2d]:
+        if (kp[0] < 0 or kp[0] >= img_width or 
+            kp[1] < 0 or kp[1] >= img_height):
+            return False
+    
+    return True
+
+
+def estimate_gaze_batch(pipeline, image_bgr, bboxes, img_width, img_height):
+    """Run L2CS once on full image and match results to face bboxes"""
     try:
+        # Convert bboxes to square with padding
+        square_bboxes = []
+        for bbox in bboxes:
+            if bbox is not None:
+                square_bbox = make_square_bbox_with_padding(bbox, img_width, img_height, padding=0.15)
+                square_bboxes.append(square_bbox)
+            else:
+                square_bboxes.append(None)
+        
         detections = pipeline.step(image_bgr)
         if not detections:
             return [None] * len(bboxes)
         
         results = []
-        for bbox in bboxes:
-            if bbox is None:
+        for square_bbox in square_bboxes:
+            if square_bbox is None:
                 results.append(None)
                 continue
             
-            x1, y1, x2, y2 = bbox
+            x1, y1, x2, y2 = square_bbox
             bbox_center = np.array([(x1 + x2) / 2, (y1 + y2) / 2])
             
             best_result = None
@@ -110,6 +178,7 @@ def process_batch(batch, sam3d_dataset):
     
     for idx, image_pil in enumerate(images):
         image_id = Path(image_paths[idx]).stem if image_paths[idx] else f'img_{idx:06d}'
+        img_width, img_height = image_pil.size
         
         # Find corresponding SAM3D data
         sam3d_row = sam3d_dataset.filter(lambda x: x['image_id'] == image_id).take(1)
@@ -128,37 +197,21 @@ def process_batch(batch, sam3d_dataset):
         image_rgb = np.array(image_pil.convert('RGB'))
         image_bgr = cv2.cvtColor(image_rgb, cv2.COLOR_RGB2BGR)
         
-        # Collect bboxes for valid faces
+        # Collect bboxes for valid faces only
         bboxes = []
         for human in humans_data:
             bbox = human.get('bbox')
             kpts2d = human.get('keypoints_2d')
             kpts3d = human.get('keypoints_3d')
             
-            if bbox is None or kpts2d is None or kpts3d is None:
-                bboxes.append(None)
-                continue
-            
-            kpts3d_arr = np.array(kpts3d)
-            if len(kpts3d_arr) < 3:
-                bboxes.append(None)
-                continue
-            
-            # Check face keypoints valid
-            nose_3d = kpts3d_arr[0]
-            left_eye_3d = kpts3d_arr[1]
-            right_eye_3d = kpts3d_arr[2]
-            
-            if (np.linalg.norm(nose_3d) < 1e-6 or 
-                np.linalg.norm(left_eye_3d) < 1e-6 or 
-                np.linalg.norm(right_eye_3d) < 1e-6):
+            # Check if this human has a valid, visible face
+            if has_valid_face(kpts2d, kpts3d, img_width, img_height) and bbox is not None:
+                bboxes.append(bbox)
+            else:
                 bboxes.append(None)
-                continue
-            
-            bboxes.append(bbox)
         
-        # Estimate gaze for all faces in one pass
-        gaze_results = estimate_gaze_batch(gaze_pipeline, image_bgr, bboxes)
+        # Estimate gaze for all valid faces in one pass
+        gaze_results = estimate_gaze_batch(gaze_pipeline, image_bgr, bboxes, img_width, img_height)
         
         results_list.append({
             'image_id': image_id,