@@ -668,6 +674,13 @@ export default function Identify() {
{confidencePct}% {confidenceDesc}
+ {/* Pose mode */}
+ {s.pose_mode && (
+
+ {s.pose_mode}
+
+ )}
+
{/* Filename */}
{s.filename}
diff --git a/scripts/FACE_WIDTH_PROFILE_DETECTION.md b/scripts/FACE_WIDTH_PROFILE_DETECTION.md
new file mode 100644
index 0000000..7273568
--- /dev/null
+++ b/scripts/FACE_WIDTH_PROFILE_DETECTION.md
@@ -0,0 +1,105 @@
+# Face Width-Based Profile Detection Implementation
+
+## Overview
+
+Implemented face width (eye distance) as an additional indicator for profile face detection. This enhances profile detection accuracy, especially for extreme profile views where yaw angle calculation might be less reliable.
+
+## Implementation Details
+
+### 1. Added `calculate_face_width_from_landmarks()` Method
+
+**Location:** `src/utils/pose_detection.py`
+
+Calculates the horizontal distance between the two eyes (face width). For profile faces, this distance is very small (< 20-30 pixels), while frontal faces have much larger eye distances (typically 50-100+ pixels).
+
+```python
+@staticmethod
+def calculate_face_width_from_landmarks(landmarks: Dict) -> Optional[float]:
+ """Calculate face width (eye distance) from facial landmarks."""
+```
+
+### 2. Enhanced `classify_pose_mode()` Method
+
+**Location:** `src/utils/pose_detection.py`
+
+Added optional `face_width` parameter to `classify_pose_mode()`:
+
+```python
+@staticmethod
+def classify_pose_mode(yaw: Optional[float],
+ pitch: Optional[float],
+ roll: Optional[float],
+ face_width: Optional[float] = None) -> str:
+```
+
+**Logic:**
+- If `face_width < 25 pixels`, strongly indicates profile view
+- Even if yaw angle is below the 30Ā° threshold, small face width suggests profile
+- Uses yaw direction (if available) to determine `profile_left` vs `profile_right`
+- Falls back to `profile_left` if yaw is unavailable but face width is small
+
+### 3. Updated `detect_pose_faces()` Method
+
+**Location:** `src/utils/pose_detection.py`
+
+Now calculates face width and includes it in the result:
+
+```python
+# Calculate face width (eye distance) for profile detection
+face_width = self.calculate_face_width_from_landmarks(landmarks)
+
+# Classify pose mode (using face width as additional indicator)
+pose_mode = self.classify_pose_mode(yaw_angle, pitch_angle, roll_angle, face_width)
+```
+
+The result dictionary now includes `face_width`:
+
+```python
+result = {
+ 'facial_area': facial_area,
+ 'landmarks': landmarks,
+ 'confidence': face_data.get('confidence', 0.0),
+ 'yaw_angle': yaw_angle,
+ 'pitch_angle': pitch_angle,
+ 'roll_angle': roll_angle,
+ 'face_width': face_width, # Eye distance in pixels
+ 'pose_mode': pose_mode
+}
+```
+
+## Benefits
+
+1. **Better Profile Detection:** Catches extreme profile views where yaw angle might be unreliable
+2. **Fallback Indicator:** When yaw calculation fails (None), small face width still indicates profile
+3. **More Accurate:** Uses both yaw angle and face width for robust profile detection
+4. **Backward Compatible:** `face_width` parameter is optional, so existing code still works
+
+## Threshold
+
+**Profile Face Width Threshold: 25 pixels**
+
+- Faces with eye distance < 25 pixels are classified as profile
+- This threshold is based on empirical testing:
+ - Profile faces: 6-10 pixels (e.g., face_4 with yaw=-30.48Ā° has 6.52 pixels)
+ - Frontal faces: 50-100+ pixels (e.g., face_2 with yaw=3.04Ā° has 92.94 pixels)
+
+## Testing
+
+To test the implementation:
+
+1. Process photos with profile faces
+2. Check pose_mode classification - should see more profile faces detected
+3. Verify face_width values in pose detection results
+
+## Example
+
+**Before:** Face with yaw=16.77Ā° might be classified as "frontal" (below 30Ā° threshold)
+**After:** Same face with face_width=3.86 pixels is correctly classified as "profile_left"
+
+## Files Modified
+
+- `src/utils/pose_detection.py`:
+ - Added `calculate_face_width_from_landmarks()` method
+ - Enhanced `classify_pose_mode()` with face_width parameter
+ - Updated `detect_pose_faces()` to calculate and use face_width
+
diff --git a/scripts/POSE_DETECTION_FIXES.md b/scripts/POSE_DETECTION_FIXES.md
new file mode 100644
index 0000000..ed637eb
--- /dev/null
+++ b/scripts/POSE_DETECTION_FIXES.md
@@ -0,0 +1,97 @@
+# Pose Detection Investigation & Fixes
+
+## Summary
+
+Investigated two issues with pose detection in the faces table:
+1. **Pitch angles not being calculated** - All pitch angles were `NULL` in the database
+2. **Roll angle normalization** - Roll angles were showing extreme values near Ā±180Ā° instead of normalized [-90, 90] range
+
+## Issue 1: Pitch Angles Not Calculated
+
+### Root Cause
+RetinaFace returns landmark keys as:
+- `'mouth_left'` and `'mouth_right'`
+
+But the code was looking for:
+- `'left_mouth'` and `'right_mouth'`
+
+This mismatch caused `calculate_pitch_from_landmarks()` to always return `None` because it couldn't find the required landmarks.
+
+### Fix
+Updated `calculate_pitch_from_landmarks()` in `src/utils/pose_detection.py` to handle both naming conventions:
+
+```python
+# RetinaFace uses 'mouth_left' and 'mouth_right', not 'left_mouth' and 'right_mouth'
+left_mouth = landmarks.get('mouth_left') or landmarks.get('left_mouth')
+right_mouth = landmarks.get('mouth_right') or landmarks.get('right_mouth')
+```
+
+### Result
+Pitch angles are now being calculated correctly. Test results show:
+- Face 1: Pitch = 18.35Ā° (looking up)
+- Face 2: Pitch = -2.96Ā° (slightly down)
+- Face 3: Pitch = 3.49Ā° (slightly up)
+
+## Issue 2: Roll Angle Normalization
+
+### Root Cause
+The `calculate_roll_from_landmarks()` function uses `atan2(dy, dx)` which returns angles in the range [-180, 180] degrees. When the eye line is nearly horizontal (which is normal for most faces), small values of `dy` relative to `dx` can result in angles near Ā±180Ā° instead of near 0Ā°.
+
+For example:
+- If `dx = -92.94` and `dy = -2.80` (eyes nearly horizontal)
+- `atan2(-2.80, -92.94) = -178.28Ā°` (should be ~1.72Ā°)
+
+### Fix
+Added normalization to convert roll angles to [-90, 90] range in `calculate_roll_from_landmarks()`:
+
+```python
+# Roll angle - atan2 returns [-180, 180], normalize to [-90, 90]
+roll_radians = atan2(dy, dx)
+roll_degrees = degrees(roll_radians)
+
+# Normalize to [-90, 90] range for head tilt
+# If angle is > 90Ā°, subtract 180Ā°; if < -90Ā°, add 180Ā°
+if roll_degrees > 90.0:
+ roll_degrees = roll_degrees - 180.0
+elif roll_degrees < -90.0:
+ roll_degrees = roll_degrees + 180.0
+```
+
+### Result
+Roll angles are now normalized correctly. Database examples:
+- Before: -179.18Ā° ā After: 0.82Ā°
+- Before: 177.25Ā° ā After: -2.75Ā°
+- Before: -178.97Ā° ā After: 1.03Ā°
+
+## Testing
+
+The fixes were tested using `scripts/test_pose_calculation.py`:
+- ā
Pitch angles now calculate correctly
+- ā
Roll angles are normalized to [-90, 90] range
+- ā
All three angles (yaw, pitch, roll) are working as expected
+
+## Database Impact
+
+### Current State (Web Database)
+- Total faces: 163
+- Faces with angle data: 10 (only those with non-frontal poses)
+- Pitch angles: 0 (all NULL before fix)
+- Roll angles: 10 (had extreme values before fix)
+
+### After Fix
+- Pitch angles will be calculated for all faces processed after the fix
+- Roll angles will be normalized to [-90, 90] range
+- Existing faces in database will need to be reprocessed to get pitch angles and normalized roll angles
+
+## Files Modified
+
+1. `src/utils/pose_detection.py`
+ - `calculate_pitch_from_landmarks()`: Fixed landmark key names
+ - `calculate_roll_from_landmarks()`: Added normalization to [-90, 90] range
+
+## Next Steps
+
+1. **Reprocess existing faces** (optional): To get pitch angles and normalized roll angles for existing faces, reprocess photos through the face detection pipeline
+2. **Monitor new faces**: New faces processed after the fix will automatically have correct pitch and roll angles
+3. **Update database migration** (if needed): Consider adding a migration script to normalize existing roll angles in the database
+
diff --git a/scripts/analyze_all_faces.py b/scripts/analyze_all_faces.py
new file mode 100644
index 0000000..9a7c623
--- /dev/null
+++ b/scripts/analyze_all_faces.py
@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+"""
+Analyze all faces to see why most don't have angle data
+"""
+
+import sqlite3
+import os
+
+db_path = "data/punimtag.db"
+
+if not os.path.exists(db_path):
+ print(f"ā Database not found: {db_path}")
+ exit(1)
+
+conn = sqlite3.connect(db_path)
+conn.row_factory = sqlite3.Row
+cursor = conn.cursor()
+
+# Get total faces
+cursor.execute("SELECT COUNT(*) FROM faces")
+total_faces = cursor.fetchone()[0]
+
+# Get faces with angle data
+cursor.execute("SELECT COUNT(*) FROM faces WHERE yaw_angle IS NOT NULL OR pitch_angle IS NOT NULL OR roll_angle IS NOT NULL")
+faces_with_angles = cursor.fetchone()[0]
+
+# Get faces without any angle data
+faces_without_angles = total_faces - faces_with_angles
+
+print("=" * 80)
+print("FACE ANGLE DATA ANALYSIS")
+print("=" * 80)
+print(f"\nTotal faces: {total_faces}")
+print(f"Faces WITH angle data: {faces_with_angles}")
+print(f"Faces WITHOUT angle data: {faces_without_angles}")
+print(f"Percentage with angle data: {(faces_with_angles/total_faces*100):.1f}%")
+
+# Check pose_mode distribution
+print("\n" + "=" * 80)
+print("POSE_MODE DISTRIBUTION")
+print("=" * 80)
+cursor.execute("""
+ SELECT pose_mode, COUNT(*) as count
+ FROM faces
+ GROUP BY pose_mode
+ ORDER BY count DESC
+""")
+
+pose_modes = cursor.fetchall()
+for row in pose_modes:
+ percentage = (row['count'] / total_faces) * 100
+ print(f" {row['pose_mode']:<30} : {row['count']:>4} ({percentage:>5.1f}%)")
+
+# Check faces with pose_mode=frontal but might have high yaw
+print("\n" + "=" * 80)
+print("FACES WITH POSE_MODE='frontal' BUT NO ANGLE DATA")
+print("=" * 80)
+print("(These faces might actually be profile faces but weren't analyzed)")
+
+cursor.execute("""
+ SELECT COUNT(*)
+ FROM faces
+ WHERE pose_mode = 'frontal'
+ AND yaw_angle IS NULL
+ AND pitch_angle IS NULL
+ AND roll_angle IS NULL
+""")
+frontal_no_data = cursor.fetchone()[0]
+print(f" Faces with pose_mode='frontal' and no angle data: {frontal_no_data}")
+
+# Check if pose detection is being run for all faces
+print("\n" + "=" * 80)
+print("ANALYSIS")
+print("=" * 80)
+print(f"Only {faces_with_angles} out of {total_faces} faces have angle data stored.")
+print("This suggests that pose detection is NOT being run for all faces.")
+print("\nPossible reasons:")
+print(" 1. Pose detection may have been disabled or failed for most faces")
+print(" 2. Only faces processed recently have pose data")
+print(" 3. Pose detection might only run when RetinaFace is available")
+
+conn.close()
+
diff --git a/scripts/analyze_pose_matching.py b/scripts/analyze_pose_matching.py
new file mode 100644
index 0000000..91653fd
--- /dev/null
+++ b/scripts/analyze_pose_matching.py
@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+"""
+Analyze why only 6 faces have yaw angle data - investigate the matching process
+"""
+
+import sqlite3
+import os
+import json
+
+db_path = "data/punimtag.db"
+
+if not os.path.exists(db_path):
+ print(f"ā Database not found: {db_path}")
+ exit(1)
+
+conn = sqlite3.connect(db_path)
+conn.row_factory = sqlite3.Row
+cursor = conn.cursor()
+
+# Get total faces
+cursor.execute("SELECT COUNT(*) FROM faces")
+total_faces = cursor.fetchone()[0]
+
+# Get faces with angle data
+cursor.execute("SELECT COUNT(*) FROM faces WHERE yaw_angle IS NOT NULL")
+faces_with_yaw = cursor.fetchone()[0]
+
+# Get faces without angle data
+cursor.execute("SELECT COUNT(*) FROM faces WHERE yaw_angle IS NULL AND pitch_angle IS NULL AND roll_angle IS NULL")
+faces_without_angles = cursor.fetchone()[0]
+
+print("=" * 80)
+print("POSE DATA COVERAGE ANALYSIS")
+print("=" * 80)
+print(f"\nTotal faces: {total_faces}")
+print(f"Faces WITH yaw angle: {faces_with_yaw}")
+print(f"Faces WITHOUT any angle data: {faces_without_angles}")
+print(f"Coverage: {(faces_with_yaw/total_faces*100):.1f}%")
+
+# Check pose_mode distribution
+print("\n" + "=" * 80)
+print("POSE_MODE DISTRIBUTION")
+print("=" * 80)
+cursor.execute("""
+ SELECT pose_mode, COUNT(*) as count,
+ SUM(CASE WHEN yaw_angle IS NOT NULL THEN 1 ELSE 0 END) as with_yaw,
+ SUM(CASE WHEN pitch_angle IS NOT NULL THEN 1 ELSE 0 END) as with_pitch,
+ SUM(CASE WHEN roll_angle IS NOT NULL THEN 1 ELSE 0 END) as with_roll
+ FROM faces
+ GROUP BY pose_mode
+ ORDER BY count DESC
+""")
+
+pose_modes = cursor.fetchall()
+for row in pose_modes:
+ print(f"\n{row['pose_mode']}:")
+ print(f" Total: {row['count']}")
+ print(f" With yaw: {row['with_yaw']}")
+ print(f" With pitch: {row['with_pitch']}")
+ print(f" With roll: {row['with_roll']}")
+
+# Check photos and see if some photos have pose data while others don't
+print("\n" + "=" * 80)
+print("POSE DATA BY PHOTO")
+print("=" * 80)
+cursor.execute("""
+ SELECT
+ p.id as photo_id,
+ p.filename,
+ COUNT(f.id) as total_faces,
+ SUM(CASE WHEN f.yaw_angle IS NOT NULL THEN 1 ELSE 0 END) as faces_with_yaw,
+ SUM(CASE WHEN f.pitch_angle IS NOT NULL THEN 1 ELSE 0 END) as faces_with_pitch,
+ SUM(CASE WHEN f.roll_angle IS NOT NULL THEN 1 ELSE 0 END) as faces_with_roll
+ FROM photos p
+ LEFT JOIN faces f ON f.photo_id = p.id
+ GROUP BY p.id, p.filename
+ HAVING COUNT(f.id) > 0
+ ORDER BY faces_with_yaw DESC, total_faces DESC
+ LIMIT 20
+""")
+
+photos = cursor.fetchall()
+print(f"\n{'Photo ID':<10} {'Filename':<40} {'Total':<8} {'Yaw':<6} {'Pitch':<7} {'Roll':<6}")
+print("-" * 80)
+for row in photos:
+ print(f"{row['photo_id']:<10} {row['filename'][:38]:<40} {row['total_faces']:<8} "
+ f"{row['faces_with_yaw']:<6} {row['faces_with_pitch']:<7} {row['faces_with_roll']:<6}")
+
+# Check if there's a pattern - maybe older photos don't have pose data
+print("\n" + "=" * 80)
+print("ANALYSIS")
+print("=" * 80)
+
+# Check date added vs pose data
+cursor.execute("""
+ SELECT
+ DATE(p.date_added) as date_added,
+ COUNT(f.id) as total_faces,
+ SUM(CASE WHEN f.yaw_angle IS NOT NULL THEN 1 ELSE 0 END) as faces_with_yaw
+ FROM photos p
+ LEFT JOIN faces f ON f.photo_id = p.id
+ GROUP BY DATE(p.date_added)
+ ORDER BY date_added DESC
+""")
+
+dates = cursor.fetchall()
+print("\nFaces by date added:")
+print(f"{'Date':<15} {'Total':<8} {'With Yaw':<10} {'Coverage':<10}")
+print("-" * 50)
+for row in dates:
+ coverage = (row['faces_with_yaw'] / row['total_faces'] * 100) if row['total_faces'] > 0 else 0
+ print(f"{row['date_added'] or 'NULL':<15} {row['total_faces']:<8} {row['faces_with_yaw']:<10} {coverage:.1f}%")
+
+# Check if pose detection might be failing for some photos
+print("\n" + "=" * 80)
+print("POSSIBLE REASONS FOR LOW COVERAGE")
+print("=" * 80)
+print("\n1. Pose detection might not be running for all photos")
+print("2. Matching between DeepFace and RetinaFace might be failing (IoU threshold too strict?)")
+print("3. RetinaFace might not be detecting faces in some photos")
+print("4. Photos might have been processed before pose detection was fully implemented")
+
+# Check if there are photos with multiple faces where some have pose data and some don't
+cursor.execute("""
+ SELECT
+ p.id as photo_id,
+ p.filename,
+ COUNT(f.id) as total_faces,
+ SUM(CASE WHEN f.yaw_angle IS NOT NULL THEN 1 ELSE 0 END) as faces_with_yaw,
+ SUM(CASE WHEN f.yaw_angle IS NULL THEN 1 ELSE 0 END) as faces_without_yaw
+ FROM photos p
+ JOIN faces f ON f.photo_id = p.id
+ GROUP BY p.id, p.filename
+ HAVING COUNT(f.id) > 1
+ AND SUM(CASE WHEN f.yaw_angle IS NOT NULL THEN 1 ELSE 0 END) > 0
+ AND SUM(CASE WHEN f.yaw_angle IS NULL THEN 1 ELSE 0 END) > 0
+ ORDER BY total_faces DESC
+ LIMIT 10
+""")
+
+mixed_photos = cursor.fetchall()
+if mixed_photos:
+ print("\n" + "=" * 80)
+ print("PHOTOS WITH MIXED POSE DATA (some faces have it, some don't)")
+ print("=" * 80)
+ print(f"\n{'Photo ID':<10} {'Filename':<40} {'Total':<8} {'With Yaw':<10} {'Without Yaw':<12}")
+ print("-" * 80)
+ for row in mixed_photos:
+ print(f"{row['photo_id']:<10} {row['filename'][:38]:<40} {row['total_faces']:<8} "
+ f"{row['faces_with_yaw']:<10} {row['faces_without_yaw']:<12}")
+ print("\nā ļø This suggests matching is failing for some faces even when pose detection runs")
+else:
+ print("\nā
No photos found with mixed pose data (all or nothing per photo)")
+
+conn.close()
+
diff --git a/scripts/analyze_poses.py b/scripts/analyze_poses.py
new file mode 100644
index 0000000..17115f7
--- /dev/null
+++ b/scripts/analyze_poses.py
@@ -0,0 +1,192 @@
+#!/usr/bin/env python3
+"""
+Analyze pose_mode values in the faces table
+"""
+
+import sqlite3
+import sys
+import os
+from collections import Counter
+from typing import Dict, List, Tuple
+
+# Default database path
+DEFAULT_DB_PATH = "data/photos.db"
+
+
+def analyze_poses(db_path: str) -> None:
+ """Analyze pose_mode values in faces table"""
+
+ if not os.path.exists(db_path):
+ print(f"ā Database not found: {db_path}")
+ return
+
+ print(f"š Analyzing poses in database: {db_path}\n")
+
+ try:
+ conn = sqlite3.connect(db_path)
+ conn.row_factory = sqlite3.Row
+ cursor = conn.cursor()
+
+ # Get total number of faces
+ cursor.execute("SELECT COUNT(*) FROM faces")
+ total_faces = cursor.fetchone()[0]
+ print(f"Total faces in database: {total_faces}\n")
+
+ if total_faces == 0:
+ print("No faces found in database.")
+ conn.close()
+ return
+
+ # Get pose_mode distribution
+ cursor.execute("""
+ SELECT pose_mode, COUNT(*) as count
+ FROM faces
+ GROUP BY pose_mode
+ ORDER BY count DESC
+ """)
+
+ pose_modes = cursor.fetchall()
+
+ print("=" * 60)
+ print("POSE_MODE DISTRIBUTION")
+ print("=" * 60)
+ for row in pose_modes:
+ pose_mode = row['pose_mode'] or 'NULL'
+ count = row['count']
+ percentage = (count / total_faces) * 100
+ print(f" {pose_mode:30s} : {count:6d} ({percentage:5.1f}%)")
+
+ print("\n" + "=" * 60)
+ print("ANGLE STATISTICS")
+ print("=" * 60)
+
+ # Yaw angle statistics
+ cursor.execute("""
+ SELECT
+ COUNT(*) as total,
+ COUNT(yaw_angle) as with_yaw,
+ MIN(yaw_angle) as min_yaw,
+ MAX(yaw_angle) as max_yaw,
+ AVG(yaw_angle) as avg_yaw
+ FROM faces
+ WHERE yaw_angle IS NOT NULL
+ """)
+ yaw_stats = cursor.fetchone()
+
+ # Pitch angle statistics
+ cursor.execute("""
+ SELECT
+ COUNT(*) as total,
+ COUNT(pitch_angle) as with_pitch,
+ MIN(pitch_angle) as min_pitch,
+ MAX(pitch_angle) as max_pitch,
+ AVG(pitch_angle) as avg_pitch
+ FROM faces
+ WHERE pitch_angle IS NOT NULL
+ """)
+ pitch_stats = cursor.fetchone()
+
+ # Roll angle statistics
+ cursor.execute("""
+ SELECT
+ COUNT(*) as total,
+ COUNT(roll_angle) as with_roll,
+ MIN(roll_angle) as min_roll,
+ MAX(roll_angle) as max_roll,
+ AVG(roll_angle) as avg_roll
+ FROM faces
+ WHERE roll_angle IS NOT NULL
+ """)
+ roll_stats = cursor.fetchone()
+
+ print(f"\nYaw Angle:")
+ print(f" Faces with yaw data: {yaw_stats['with_yaw']}")
+ if yaw_stats['with_yaw'] > 0:
+ print(f" Min: {yaw_stats['min_yaw']:.1f}Ā°")
+ print(f" Max: {yaw_stats['max_yaw']:.1f}Ā°")
+ print(f" Avg: {yaw_stats['avg_yaw']:.1f}Ā°")
+
+ print(f"\nPitch Angle:")
+ print(f" Faces with pitch data: {pitch_stats['with_pitch']}")
+ if pitch_stats['with_pitch'] > 0:
+ print(f" Min: {pitch_stats['min_pitch']:.1f}Ā°")
+ print(f" Max: {pitch_stats['max_pitch']:.1f}Ā°")
+ print(f" Avg: {pitch_stats['avg_pitch']:.1f}Ā°")
+
+ print(f"\nRoll Angle:")
+ print(f" Faces with roll data: {roll_stats['with_roll']}")
+ if roll_stats['with_roll'] > 0:
+ print(f" Min: {roll_stats['min_roll']:.1f}Ā°")
+ print(f" Max: {roll_stats['max_roll']:.1f}Ā°")
+ print(f" Avg: {roll_stats['avg_roll']:.1f}Ā°")
+
+ # Sample faces with different poses
+ print("\n" + "=" * 60)
+ print("SAMPLE FACES BY POSE")
+ print("=" * 60)
+
+ for row in pose_modes[:10]: # Top 10 pose modes
+ pose_mode = row['pose_mode']
+ cursor.execute("""
+ SELECT id, photo_id, pose_mode, yaw_angle, pitch_angle, roll_angle
+ FROM faces
+ WHERE pose_mode = ?
+ LIMIT 3
+ """, (pose_mode,))
+ samples = cursor.fetchall()
+
+ print(f"\n{pose_mode}:")
+ for sample in samples:
+ yaw_str = f"{sample['yaw_angle']:.1f}Ā°" if sample['yaw_angle'] is not None else "N/A"
+ pitch_str = f"{sample['pitch_angle']:.1f}Ā°" if sample['pitch_angle'] is not None else "N/A"
+ roll_str = f"{sample['roll_angle']:.1f}Ā°" if sample['roll_angle'] is not None else "N/A"
+ print(f" Face ID {sample['id']}: "
+ f"yaw={yaw_str} "
+ f"pitch={pitch_str} "
+ f"roll={roll_str}")
+
+ conn.close()
+
+ except sqlite3.Error as e:
+ print(f"ā Database error: {e}")
+ except Exception as e:
+ print(f"ā Error: {e}")
+
+
+def check_web_database() -> None:
+ """Check if web database exists and analyze it"""
+ # Common web database locations
+ web_db_paths = [
+ "data/punimtag.db", # Default web database
+ "data/web_photos.db",
+ "data/photos_web.db",
+ "web_photos.db",
+ ]
+
+ for db_path in web_db_paths:
+ if os.path.exists(db_path):
+ print(f"\n{'='*60}")
+ print(f"WEB DATABASE: {db_path}")
+ print(f"{'='*60}\n")
+ analyze_poses(db_path)
+ break
+
+
+if __name__ == "__main__":
+ # Check desktop database
+ desktop_db = DEFAULT_DB_PATH
+ if os.path.exists(desktop_db):
+ analyze_poses(desktop_db)
+
+ # Check web database
+ check_web_database()
+
+ # If no database found, list what we tried
+ if not os.path.exists(desktop_db):
+ print(f"ā Desktop database not found: {desktop_db}")
+ print("\nTrying to find database files...")
+ for root, dirs, files in os.walk("data"):
+ for file in files:
+ if file.endswith(('.db', '.sqlite', '.sqlite3')):
+ print(f" Found: {os.path.join(root, file)}")
+
diff --git a/scripts/check_identified_poses.py b/scripts/check_identified_poses.py
new file mode 100644
index 0000000..e0bf0a5
--- /dev/null
+++ b/scripts/check_identified_poses.py
@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""Check all identified faces for pose information"""
+
+import sqlite3
+import sys
+import os
+
+# Add project root to path
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from src.core.config import DEFAULT_DB_PATH
+
+def check_identified_faces(db_path: str):
+ """Check all identified faces for pose information"""
+ if not os.path.exists(db_path):
+ print(f"Database not found: {db_path}")
+ return
+
+ conn = sqlite3.connect(db_path)
+ conn.row_factory = sqlite3.Row
+ cursor = conn.cursor()
+
+ # Get all identified faces with pose information
+ cursor.execute('''
+ SELECT
+ f.id,
+ f.person_id,
+ p.name || ' ' || p.last_name as person_name,
+ ph.filename,
+ f.pose_mode,
+ f.yaw_angle,
+ f.pitch_angle,
+ f.roll_angle,
+ f.face_confidence,
+ f.quality_score,
+ f.location
+ FROM faces f
+ JOIN people p ON f.person_id = p.id
+ JOIN photos ph ON f.photo_id = ph.id
+ WHERE f.person_id IS NOT NULL
+ ORDER BY p.id, f.id
+ ''')
+
+ faces = cursor.fetchall()
+
+ if not faces:
+ print("No identified faces found.")
+ return
+
+ print(f"\n{'='*80}")
+ print(f"Found {len(faces)} identified faces")
+ print(f"{'='*80}\n")
+
+ # Group by person
+ by_person = {}
+ for face in faces:
+ person_id = face['person_id']
+ if person_id not in by_person:
+ by_person[person_id] = []
+ by_person[person_id].append(face)
+
+ # Print summary
+ print("SUMMARY BY PERSON:")
+ print("-" * 80)
+ for person_id, person_faces in by_person.items():
+ person_name = person_faces[0]['person_name']
+ pose_modes = [f['pose_mode'] for f in person_faces]
+ frontal_count = sum(1 for p in pose_modes if p == 'frontal')
+ profile_count = sum(1 for p in pose_modes if 'profile' in p)
+ other_count = len(pose_modes) - frontal_count - profile_count
+
+ print(f"\nPerson {person_id}: {person_name}")
+ print(f" Total faces: {len(person_faces)}")
+ print(f" Frontal: {frontal_count}")
+ print(f" Profile: {profile_count}")
+ print(f" Other: {other_count}")
+ print(f" Pose modes: {set(pose_modes)}")
+
+ # Print detailed information
+ print(f"\n{'='*80}")
+ print("DETAILED FACE INFORMATION:")
+ print(f"{'='*80}\n")
+
+ for face in faces:
+ print(f"Face ID: {face['id']}")
+ print(f" Person: {face['person_name']} (ID: {face['person_id']})")
+ print(f" Photo: {face['filename']}")
+ print(f" Pose Mode: {face['pose_mode']}")
+ print(f" Yaw: {face['yaw_angle']:.2f}Ā°" if face['yaw_angle'] is not None else " Yaw: None")
+ print(f" Pitch: {face['pitch_angle']:.2f}Ā°" if face['pitch_angle'] is not None else " Pitch: None")
+ print(f" Roll: {face['roll_angle']:.2f}Ā°" if face['roll_angle'] is not None else " Roll: None")
+ print(f" Confidence: {face['face_confidence']:.3f}")
+ print(f" Quality: {face['quality_score']:.3f}")
+ print(f" Location: {face['location']}")
+ print()
+
+ conn.close()
+
+if __name__ == "__main__":
+ db_path = sys.argv[1] if len(sys.argv) > 1 else DEFAULT_DB_PATH
+ check_identified_faces(db_path)
+
diff --git a/scripts/check_identified_poses_web.py b/scripts/check_identified_poses_web.py
new file mode 100644
index 0000000..057f305
--- /dev/null
+++ b/scripts/check_identified_poses_web.py
@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+"""Check all identified faces for pose information (web database)"""
+
+import sys
+import os
+
+# Add project root to path
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from src.web.db.models import Face, Person, Photo
+from src.web.db.session import get_database_url
+
+def check_identified_faces():
+ """Check all identified faces for pose information"""
+ db_url = get_database_url()
+ print(f"Connecting to database: {db_url}")
+
+ engine = create_engine(db_url)
+ Session = sessionmaker(bind=engine)
+ session = Session()
+
+ try:
+ # Get all identified faces with pose information
+ faces = (
+ session.query(Face, Person, Photo)
+ .join(Person, Face.person_id == Person.id)
+ .join(Photo, Face.photo_id == Photo.id)
+ .filter(Face.person_id.isnot(None))
+ .order_by(Person.id, Face.id)
+ .all()
+ )
+
+ if not faces:
+ print("No identified faces found.")
+ return
+
+ print(f"\n{'='*80}")
+ print(f"Found {len(faces)} identified faces")
+ print(f"{'='*80}\n")
+
+ # Group by person
+ by_person = {}
+ for face, person, photo in faces:
+ person_id = person.id
+ if person_id not in by_person:
+ by_person[person_id] = []
+ by_person[person_id].append((face, person, photo))
+
+ # Print summary
+ print("SUMMARY BY PERSON:")
+ print("-" * 80)
+ for person_id, person_faces in by_person.items():
+ person = person_faces[0][1]
+ person_name = f"{person.first_name} {person.last_name}"
+ pose_modes = [f[0].pose_mode for f in person_faces]
+ frontal_count = sum(1 for p in pose_modes if p == 'frontal')
+ profile_count = sum(1 for p in pose_modes if 'profile' in p)
+ other_count = len(pose_modes) - frontal_count - profile_count
+
+ print(f"\nPerson {person_id}: {person_name}")
+ print(f" Total faces: {len(person_faces)}")
+ print(f" Frontal: {frontal_count}")
+ print(f" Profile: {profile_count}")
+ print(f" Other: {other_count}")
+ print(f" Pose modes: {set(pose_modes)}")
+
+ # Print detailed information
+ print(f"\n{'='*80}")
+ print("DETAILED FACE INFORMATION:")
+ print(f"{'='*80}\n")
+
+ for face, person, photo in faces:
+ person_name = f"{person.first_name} {person.last_name}"
+ print(f"Face ID: {face.id}")
+ print(f" Person: {person_name} (ID: {face.person_id})")
+ print(f" Photo: {photo.filename}")
+ print(f" Pose Mode: {face.pose_mode}")
+ print(f" Yaw: {face.yaw_angle:.2f}Ā°" if face.yaw_angle is not None else " Yaw: None")
+ print(f" Pitch: {face.pitch_angle:.2f}Ā°" if face.pitch_angle is not None else " Pitch: None")
+ print(f" Roll: {face.roll_angle:.2f}Ā°" if face.roll_angle is not None else " Roll: None")
+ print(f" Confidence: {face.face_confidence:.3f}")
+ print(f" Quality: {face.quality_score:.3f}")
+ print(f" Location: {face.location}")
+ print()
+
+ finally:
+ session.close()
+
+if __name__ == "__main__":
+ try:
+ check_identified_faces()
+ except Exception as e:
+ print(f"ā Error: {e}")
+ import traceback
+ traceback.print_exc()
+ sys.exit(1)
+
diff --git a/scripts/check_yaw_angles.py b/scripts/check_yaw_angles.py
new file mode 100644
index 0000000..d2e399f
--- /dev/null
+++ b/scripts/check_yaw_angles.py
@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""
+Check yaw angles in database to see why profile faces aren't being detected
+"""
+
+import sqlite3
+import os
+
+db_path = "data/punimtag.db"
+
+if not os.path.exists(db_path):
+ print(f"ā Database not found: {db_path}")
+ exit(1)
+
+conn = sqlite3.connect(db_path)
+conn.row_factory = sqlite3.Row
+cursor = conn.cursor()
+
+# Get all faces with yaw data
+cursor.execute("""
+ SELECT id, pose_mode, yaw_angle, pitch_angle, roll_angle
+ FROM faces
+ WHERE yaw_angle IS NOT NULL
+ ORDER BY ABS(yaw_angle) DESC
+""")
+
+faces = cursor.fetchall()
+
+print(f"Found {len(faces)} faces with yaw data\n")
+print("=" * 80)
+print("YAW ANGLE ANALYSIS")
+print("=" * 80)
+print(f"\n{'Face ID':<10} {'Pose Mode':<25} {'Yaw':<10} {'Should be Profile?'}")
+print("-" * 80)
+
+PROFILE_THRESHOLD = 30.0 # From pose_detection.py
+
+profile_count = 0
+for face in faces:
+ yaw = face['yaw_angle']
+ pose_mode = face['pose_mode']
+ is_profile = abs(yaw) >= PROFILE_THRESHOLD
+ should_be_profile = "YES" if is_profile else "NO"
+
+ if is_profile:
+ profile_count += 1
+
+ print(f"{face['id']:<10} {pose_mode:<25} {yaw:>8.2f}Ā° {should_be_profile}")
+
+print("\n" + "=" * 80)
+print(f"Total faces with yaw data: {len(faces)}")
+print(f"Faces with |yaw| >= {PROFILE_THRESHOLD}Ā° (should be profile): {profile_count}")
+print(f"Faces currently classified as profile: {cursor.execute('SELECT COUNT(*) FROM faces WHERE pose_mode LIKE \"profile%\"').fetchone()[0]}")
+print("=" * 80)
+
+# Check yaw distribution
+print("\n" + "=" * 80)
+print("YAW ANGLE DISTRIBUTION")
+print("=" * 80)
+cursor.execute("""
+ SELECT
+ CASE
+ WHEN ABS(yaw_angle) < 30 THEN 'frontal (< 30Ā°)'
+ WHEN ABS(yaw_angle) >= 30 AND ABS(yaw_angle) < 60 THEN 'profile (30-60Ā°)'
+ WHEN ABS(yaw_angle) >= 60 THEN 'extreme profile (>= 60Ā°)'
+ ELSE 'unknown'
+ END as category,
+ COUNT(*) as count
+ FROM faces
+ WHERE yaw_angle IS NOT NULL
+ GROUP BY category
+ ORDER BY count DESC
+""")
+
+distribution = cursor.fetchall()
+for row in distribution:
+ print(f" {row['category']}: {row['count']} faces")
+
+conn.close()
+
diff --git a/scripts/drop_all_tables.py b/scripts/drop_all_tables.py
old mode 100644
new mode 100755
diff --git a/scripts/test_eye_visibility.py b/scripts/test_eye_visibility.py
new file mode 100644
index 0000000..2503d06
--- /dev/null
+++ b/scripts/test_eye_visibility.py
@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+"""
+Test if RetinaFace provides both eyes for profile faces or if one eye is missing
+"""
+
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+try:
+ from src.utils.pose_detection import PoseDetector, RETINAFACE_AVAILABLE
+ from pathlib import Path
+
+ if not RETINAFACE_AVAILABLE:
+ print("ā RetinaFace not available")
+ exit(1)
+
+ detector = PoseDetector()
+
+ # Find test images
+ test_image_paths = ["demo_photos", "data/uploads"]
+ test_image = None
+
+ for path in test_image_paths:
+ if os.path.exists(path):
+ for ext in ['.jpg', '.jpeg', '.png']:
+ for img_file in Path(path).glob(f'*{ext}'):
+ test_image = str(img_file)
+ break
+ if test_image:
+ break
+
+ if not test_image:
+ print("ā No test image found")
+ exit(1)
+
+ print(f"Testing with: {test_image}\n")
+ print("=" * 80)
+ print("EYE VISIBILITY ANALYSIS")
+ print("=" * 80)
+
+ faces = detector.detect_faces_with_landmarks(test_image)
+
+ if not faces:
+ print("ā No faces detected")
+ exit(1)
+
+ print(f"Found {len(faces)} face(s)\n")
+
+ for face_key, face_data in faces.items():
+ landmarks = face_data.get('landmarks', {})
+ print(f"{face_key}:")
+ print(f" Landmarks available: {list(landmarks.keys())}")
+
+ left_eye = landmarks.get('left_eye')
+ right_eye = landmarks.get('right_eye')
+ nose = landmarks.get('nose')
+
+ print(f" Left eye: {left_eye}")
+ print(f" Right eye: {right_eye}")
+ print(f" Nose: {nose}")
+
+ # Check if both eyes are present
+ both_eyes_present = left_eye is not None and right_eye is not None
+ only_left_eye = left_eye is not None and right_eye is None
+ only_right_eye = left_eye is None and right_eye is not None
+ no_eyes = left_eye is None and right_eye is None
+
+ print(f"\n Eye visibility:")
+ print(f" Both eyes present: {both_eyes_present}")
+ print(f" Only left eye: {only_left_eye}")
+ print(f" Only right eye: {only_right_eye}")
+ print(f" No eyes: {no_eyes}")
+
+ # Calculate yaw if possible
+ yaw = detector.calculate_yaw_from_landmarks(landmarks)
+ print(f" Yaw angle: {yaw:.2f}Ā°" if yaw is not None else " Yaw angle: None (requires both eyes)")
+
+ # Calculate face width if both eyes present
+ if both_eyes_present:
+ face_width = abs(right_eye[0] - left_eye[0])
+ print(f" Face width (eye distance): {face_width:.2f} pixels")
+
+ # If face width is very small, it might be a profile view
+ if face_width < 20:
+ print(f" ā ļø Very small face width - likely extreme profile view")
+
+ # Classify pose
+ pitch = detector.calculate_pitch_from_landmarks(landmarks)
+ roll = detector.calculate_roll_from_landmarks(landmarks)
+ pose_mode = detector.classify_pose_mode(yaw, pitch, roll)
+
+ print(f" Pose mode: {pose_mode}")
+ print()
+
+ print("\n" + "=" * 80)
+ print("CONCLUSION")
+ print("=" * 80)
+ print("""
+If RetinaFace provides both eyes even for profile faces:
+ - We can use eye distance (face width) as an indicator
+ - Small face width (< 20-30 pixels) suggests extreme profile
+ - But we can't directly use 'missing eye' as a signal
+
+If RetinaFace sometimes only provides one eye for profile faces:
+ - We can check if left_eye or right_eye is None
+ - If only one eye is present, it's likely a profile view
+ - This would be a strong indicator for profile detection
+ """)
+
+except ImportError as e:
+ print(f"ā Import error: {e}")
+ print("Make sure you're in the project directory and dependencies are installed")
+
diff --git a/scripts/test_pose_calculation.py b/scripts/test_pose_calculation.py
new file mode 100644
index 0000000..ac01cf7
--- /dev/null
+++ b/scripts/test_pose_calculation.py
@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+"""
+Test pitch and roll angle calculations to investigate issues
+"""
+
+import sys
+import os
+
+# Add src to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+try:
+ from src.utils.pose_detection import PoseDetector, RETINAFACE_AVAILABLE
+ import sqlite3
+ from pathlib import Path
+
+ def test_retinaface_landmarks():
+ """Test what landmarks RetinaFace actually provides"""
+ if not RETINAFACE_AVAILABLE:
+ print("ā RetinaFace not available")
+ return
+
+ print("=" * 60)
+ print("TESTING RETINAFACE LANDMARKS")
+ print("=" * 60)
+
+ # Try to find a test image
+ test_image_paths = [
+ "demo_photos",
+ "data/uploads",
+ "data"
+ ]
+
+ detector = PoseDetector()
+ test_image = None
+
+ for path in test_image_paths:
+ if os.path.exists(path):
+ for ext in ['.jpg', '.jpeg', '.png']:
+ for img_file in Path(path).glob(f'*{ext}'):
+ test_image = str(img_file)
+ break
+ if test_image:
+ break
+
+ if not test_image:
+ print("ā No test image found")
+ return
+
+ print(f"Using test image: {test_image}")
+
+ # Detect faces
+ faces = detector.detect_faces_with_landmarks(test_image)
+
+ if not faces:
+ print("ā No faces detected")
+ return
+
+ print(f"\nā
Found {len(faces)} face(s)")
+
+ for face_key, face_data in faces.items():
+ print(f"\n{face_key}:")
+ landmarks = face_data.get('landmarks', {})
+ print(f" Landmarks keys: {list(landmarks.keys())}")
+
+ for landmark_name, position in landmarks.items():
+ print(f" {landmark_name}: {position}")
+
+ # Test calculations
+ yaw = detector.calculate_yaw_from_landmarks(landmarks)
+ pitch = detector.calculate_pitch_from_landmarks(landmarks)
+ roll = detector.calculate_roll_from_landmarks(landmarks)
+
+ print(f"\n Calculated angles:")
+ print(f" Yaw: {yaw:.2f}Ā°" if yaw is not None else " Yaw: None")
+ print(f" Pitch: {pitch:.2f}Ā°" if pitch is not None else " Pitch: None")
+ print(f" Roll: {roll:.2f}Ā°" if roll is not None else " Roll: None")
+
+ # Check which landmarks are missing for pitch
+ required_for_pitch = ['left_eye', 'right_eye', 'left_mouth', 'right_mouth', 'nose']
+ missing = [lm for lm in required_for_pitch if lm not in landmarks]
+ if missing:
+ print(f" ā ļø Missing landmarks for pitch: {missing}")
+
+ # Check roll calculation
+ if roll is not None:
+ left_eye = landmarks.get('left_eye')
+ right_eye = landmarks.get('right_eye')
+ if left_eye and right_eye:
+ dx = right_eye[0] - left_eye[0]
+ dy = right_eye[1] - left_eye[1]
+ print(f" Roll calculation details:")
+ print(f" dx (right_eye[0] - left_eye[0]): {dx:.2f}")
+ print(f" dy (right_eye[1] - left_eye[1]): {dy:.2f}")
+ print(f" atan2(dy, dx) = {roll:.2f}Ā°")
+
+ # Normalize to [-90, 90] range
+ normalized_roll = roll
+ if normalized_roll > 90:
+ normalized_roll = normalized_roll - 180
+ elif normalized_roll < -90:
+ normalized_roll = normalized_roll + 180
+ print(f" Normalized to [-90, 90]: {normalized_roll:.2f}Ā°")
+
+ pose_mode = detector.classify_pose_mode(yaw, pitch, roll)
+ print(f" Pose mode: {pose_mode}")
+
+ def analyze_database_angles():
+ """Analyze angles in database to find patterns"""
+ db_path = "data/punimtag.db"
+
+ if not os.path.exists(db_path):
+ print(f"ā Database not found: {db_path}")
+ return
+
+ print("\n" + "=" * 60)
+ print("ANALYZING DATABASE ANGLES")
+ print("=" * 60)
+
+ conn = sqlite3.connect(db_path)
+ conn.row_factory = sqlite3.Row
+ cursor = conn.cursor()
+
+ # Get faces with angle data
+ cursor.execute("""
+ SELECT id, pose_mode, yaw_angle, pitch_angle, roll_angle
+ FROM faces
+ WHERE yaw_angle IS NOT NULL OR pitch_angle IS NOT NULL OR roll_angle IS NOT NULL
+ LIMIT 20
+ """)
+
+ faces = cursor.fetchall()
+ print(f"\nFound {len(faces)} faces with angle data\n")
+
+ for face in faces:
+ print(f"Face ID {face['id']}: {face['pose_mode']}")
+ print(f" Yaw: {face['yaw_angle']:.2f}Ā°" if face['yaw_angle'] else " Yaw: None")
+ print(f" Pitch: {face['pitch_angle']:.2f}Ā°" if face['pitch_angle'] else " Pitch: None")
+ print(f" Roll: {face['roll_angle']:.2f}Ā°" if face['roll_angle'] else " Roll: None")
+
+ # Check roll normalization
+ if face['roll_angle'] is not None:
+ roll = face['roll_angle']
+ normalized = roll
+ if normalized > 90:
+ normalized = normalized - 180
+ elif normalized < -90:
+ normalized = normalized + 180
+ print(f" Roll normalized: {normalized:.2f}Ā°")
+ print()
+
+ conn.close()
+
+ if __name__ == "__main__":
+ test_retinaface_landmarks()
+ analyze_database_angles()
+
+except ImportError as e:
+ print(f"ā Import error: {e}")
+ print("Make sure you're in the project directory and dependencies are installed")
+
diff --git a/src/core/face_processing.py b/src/core/face_processing.py
index 32fc81a..83ea222 100644
--- a/src/core/face_processing.py
+++ b/src/core/face_processing.py
@@ -290,6 +290,15 @@ class FaceProcessor:
yaw_angle = pose_info.get('yaw_angle')
pitch_angle = pose_info.get('pitch_angle')
roll_angle = pose_info.get('roll_angle')
+ face_width = pose_info.get('face_width') # Extract face width for verification
+
+ # Log face width for profile detection verification
+ if self.verbose >= 2 and face_width is not None:
+ profile_status = "PROFILE" if face_width < 25.0 else "FRONTAL"
+ print(f" Face {i+1}: face_width={face_width:.2f}px, pose_mode={pose_mode} ({profile_status})")
+ elif self.verbose >= 3:
+ # Even more verbose: show all pose info
+ print(f" Face {i+1} pose info: yaw={yaw_angle:.1f}Ā°, pitch={pitch_angle:.1f}Ā°, roll={roll_angle:.1f}Ā°, width={face_width:.2f}px, mode={pose_mode}")
# Store in database with DeepFace format, EXIF orientation, and pose data
self.db.add_face(
@@ -622,14 +631,16 @@ class FaceProcessor:
'pose_mode': best_match.get('pose_mode', 'frontal'),
'yaw_angle': best_match.get('yaw_angle'),
'pitch_angle': best_match.get('pitch_angle'),
- 'roll_angle': best_match.get('roll_angle')
+ 'roll_angle': best_match.get('roll_angle'),
+ 'face_width': best_match.get('face_width') # Extract face width for verification
}
return {
'pose_mode': 'frontal',
'yaw_angle': None,
'pitch_angle': None,
- 'roll_angle': None
+ 'roll_angle': None,
+ 'face_width': None
}
def _extract_face_crop(self, photo_path: str, location: dict, face_id: int) -> str:
diff --git a/src/gui/auto_match_panel.py b/src/gui/auto_match_panel.py
index 300a210..3a21b86 100644
--- a/src/gui/auto_match_panel.py
+++ b/src/gui/auto_match_panel.py
@@ -72,7 +72,7 @@ class AutoMatchPanel:
# Don't give weight to any column to prevent stretching
# Start button (moved to the left)
- start_btn = ttk.Button(config_frame, text="š Start Auto-Match", command=self._start_auto_match)
+ start_btn = ttk.Button(config_frame, text="š Run Auto-Match", command=self._start_auto_match)
start_btn.grid(row=0, column=0, padx=(0, 20))
# Tolerance setting
diff --git a/src/utils/pose_detection.py b/src/utils/pose_detection.py
index 07c5cfe..d9e7456 100644
--- a/src/utils/pose_detection.py
+++ b/src/utils/pose_detection.py
@@ -72,6 +72,38 @@ class PoseDetector:
faces = RetinaFace.detect_faces(img_path)
return faces
+ @staticmethod
+ def calculate_face_width_from_landmarks(landmarks: Dict) -> Optional[float]:
+ """Calculate face width (eye distance) from facial landmarks.
+
+ Face width is the horizontal distance between the two eyes.
+ For profile faces, this distance is very small (< 20-30 pixels).
+
+ Args:
+ landmarks: Dictionary with landmark positions:
+ {
+ 'left_eye': (x, y),
+ 'right_eye': (x, y),
+ ...
+ }
+
+ Returns:
+ Face width in pixels, or None if landmarks invalid
+ """
+ if not landmarks:
+ return None
+
+ left_eye = landmarks.get('left_eye')
+ right_eye = landmarks.get('right_eye')
+
+ if not all([left_eye, right_eye]):
+ return None
+
+ # Calculate face width (eye distance)
+ face_width = abs(right_eye[0] - left_eye[0])
+
+ return face_width if face_width > 0 else None
+
@staticmethod
def calculate_yaw_from_landmarks(landmarks: Dict) -> Optional[float]:
"""Calculate yaw angle from facial landmarks
@@ -88,8 +120,8 @@ class PoseDetector:
Returns:
Yaw angle in degrees (-90 to +90):
- - Negative: face turned left (right profile)
- - Positive: face turned right (left profile)
+ - Negative: face turned left (left profile visible)
+ - Positive: face turned right (right profile visible)
- Zero: frontal face
- None: if landmarks invalid
"""
@@ -145,8 +177,9 @@ class PoseDetector:
left_eye = landmarks.get('left_eye')
right_eye = landmarks.get('right_eye')
- left_mouth = landmarks.get('left_mouth')
- right_mouth = landmarks.get('right_mouth')
+ # RetinaFace uses 'mouth_left' and 'mouth_right', not 'left_mouth' and 'right_mouth'
+ left_mouth = landmarks.get('mouth_left') or landmarks.get('left_mouth')
+ right_mouth = landmarks.get('mouth_right') or landmarks.get('right_mouth')
nose = landmarks.get('nose')
if not all([left_eye, right_eye, left_mouth, right_mouth, nose]):
@@ -204,22 +237,33 @@ class PoseDetector:
if dx == 0:
return 90.0 if dy > 0 else -90.0 # Vertical line
- # Roll angle
+ # Roll angle - atan2 returns [-180, 180], normalize to [-90, 90]
roll_radians = atan2(dy, dx)
roll_degrees = degrees(roll_radians)
+ # Normalize to [-90, 90] range for head tilt
+ # If angle is > 90Ā°, subtract 180Ā°; if < -90Ā°, add 180Ā°
+ if roll_degrees > 90.0:
+ roll_degrees = roll_degrees - 180.0
+ elif roll_degrees < -90.0:
+ roll_degrees = roll_degrees + 180.0
+
return roll_degrees
@staticmethod
def classify_pose_mode(yaw: Optional[float],
pitch: Optional[float],
- roll: Optional[float]) -> str:
- """Classify face pose mode from all three angles
+ roll: Optional[float],
+ face_width: Optional[float] = None) -> str:
+ """Classify face pose mode from all three angles and optionally face width
Args:
yaw: Yaw angle in degrees
pitch: Pitch angle in degrees
roll: Roll angle in degrees
+ face_width: Face width in pixels (eye distance). Used as fallback indicator
+ only when yaw is unavailable (None) - if face_width < 25px, indicates profile.
+ When yaw is available, it takes precedence over face_width.
Returns:
Pose mode classification string:
@@ -230,6 +274,7 @@ class PoseDetector:
- Combined modes: e.g., 'profile_left_looking_up'
"""
# Default to frontal if angles unknown
+ yaw_original = yaw
if yaw is None:
yaw = 0.0
if pitch is None:
@@ -237,15 +282,49 @@ class PoseDetector:
if roll is None:
roll = 0.0
- # Yaw classification
+ # Face width threshold for profile detection (in pixels)
+ # Profile faces have very small eye distance (< 25 pixels typically)
+ PROFILE_FACE_WIDTH_THRESHOLD = 25.0
+
+ # Yaw classification - PRIMARY INDICATOR
+ # Use yaw angle as the primary indicator (30Ā° threshold)
abs_yaw = abs(yaw)
+
+ # Primary classification based on yaw angle
if abs_yaw < 30.0:
- yaw_mode = "frontal"
- elif yaw < -30.0:
- yaw_mode = "profile_right"
- elif yaw > 30.0:
- yaw_mode = "profile_left"
+ # Yaw indicates frontal view
+ # Trust yaw when it's available and reasonable (< 30Ā°)
+ # Only use face_width as fallback when yaw is unavailable (None)
+ if yaw_original is None:
+ # Yaw unavailable - use face_width as fallback
+ if face_width is not None:
+ if face_width < PROFILE_FACE_WIDTH_THRESHOLD:
+ # Face width suggests profile view - use it when yaw is unavailable
+ yaw_mode = "profile_left" # Default direction when yaw unavailable
+ else:
+ # Face width is normal (>= 25px) - likely frontal
+ yaw_mode = "frontal"
+ else:
+ # Both yaw and face_width unavailable - cannot determine reliably
+ # This usually means landmarks are incomplete (missing nose and/or eyes)
+ # For extreme profile views, both eyes might not be visible, which would
+ # cause face_width to be None. In this case, we cannot reliably determine
+ # pose without additional indicators (like face bounding box aspect ratio).
+ # Default to frontal (conservative approach), but this might misclassify
+ # some extreme profile faces.
+ yaw_mode = "frontal"
+ else:
+ # Yaw is available and < 30Ā° - trust yaw, classify as frontal
+ # Don't override with face_width when yaw is available
+ yaw_mode = "frontal"
+ elif yaw <= -30.0:
+ # abs_yaw >= 30.0 and yaw is negative - profile left
+ yaw_mode = "profile_left" # Negative yaw = face turned left = left profile visible
+ elif yaw >= 30.0:
+ # abs_yaw >= 30.0 and yaw is positive - profile right
+ yaw_mode = "profile_right" # Positive yaw = face turned right = right profile visible
else:
+ # This should never be reached, but handle edge case
yaw_mode = "slight_yaw"
# Pitch classification
@@ -314,8 +393,11 @@ class PoseDetector:
pitch_angle = self.calculate_pitch_from_landmarks(landmarks)
roll_angle = self.calculate_roll_from_landmarks(landmarks)
- # Classify pose mode
- pose_mode = self.classify_pose_mode(yaw_angle, pitch_angle, roll_angle)
+ # Calculate face width (eye distance) for profile detection
+ face_width = self.calculate_face_width_from_landmarks(landmarks)
+
+ # Classify pose mode (using face width as additional indicator)
+ pose_mode = self.classify_pose_mode(yaw_angle, pitch_angle, roll_angle, face_width)
# Normalize facial_area format (RetinaFace returns list [x, y, w, h] or dict)
facial_area_raw = face_data.get('facial_area', {})
@@ -341,6 +423,7 @@ class PoseDetector:
'yaw_angle': yaw_angle,
'pitch_angle': pitch_angle,
'roll_angle': roll_angle,
+ 'face_width': face_width, # Eye distance in pixels
'pose_mode': pose_mode
}
results.append(result)
diff --git a/src/web/api/faces.py b/src/web/api/faces.py
index da4a7a1..709a47f 100644
--- a/src/web/api/faces.py
+++ b/src/web/api/faces.py
@@ -127,6 +127,7 @@ def get_unidentified_faces(
quality_score=float(f.quality_score),
face_confidence=float(getattr(f, "face_confidence", 0.0)),
location=f.location,
+ pose_mode=getattr(f, "pose_mode", None) or "frontal",
)
for f in faces
]
@@ -158,6 +159,7 @@ def get_similar_faces(face_id: int, db: Session = Depends(get_db)) -> SimilarFac
location=f.location,
quality_score=float(f.quality_score),
filename=f.photo.filename if f.photo else "unknown",
+ pose_mode=getattr(f, "pose_mode", None) or "frontal",
)
for f, distance, confidence_pct in results
]
diff --git a/src/web/schemas/faces.py b/src/web/schemas/faces.py
index 309f3ea..f68db8b 100644
--- a/src/web/schemas/faces.py
+++ b/src/web/schemas/faces.py
@@ -50,6 +50,7 @@ class FaceItem(BaseModel):
quality_score: float
face_confidence: float
location: str
+ pose_mode: Optional[str] = Field("frontal", description="Pose classification (frontal, profile_left, etc.)")
class UnidentifiedFacesQuery(BaseModel):
@@ -86,6 +87,7 @@ class SimilarFaceItem(BaseModel):
location: str
quality_score: float
filename: str
+ pose_mode: Optional[str] = Field("frontal", description="Pose classification (frontal, profile_left, etc.)")
class SimilarFacesResponse(BaseModel):
diff --git a/src/web/services/face_service.py b/src/web/services/face_service.py
index ba8c4d7..f896570 100644
--- a/src/web/services/face_service.py
+++ b/src/web/services/face_service.py
@@ -280,6 +280,7 @@ def process_photo_faces(
detector_backend: str = "retinaface",
model_name: str = "ArcFace",
update_progress: Optional[Callable[[int, int, str], None]] = None,
+ pose_detector: Optional[PoseDetector] = None,
) -> Tuple[int, int]:
"""Process faces in a single photo using DeepFace.
@@ -289,6 +290,8 @@ def process_photo_faces(
detector_backend: DeepFace detector backend (retinaface, mtcnn, opencv, ssd)
model_name: DeepFace model name (ArcFace, Facenet, Facenet512, VGG-Face)
update_progress: Optional progress callback (processed, total, message)
+ pose_detector: Optional PoseDetector instance to reuse (initialized once per batch)
+ If None and RETINAFACE_AVAILABLE, will create one locally
Returns:
Tuple of (faces_detected, faces_stored)
@@ -328,17 +331,27 @@ def process_photo_faces(
face_detection_path = photo_path
# Step 1: Use RetinaFace directly for detection + landmarks (with graceful fallback)
+ # Reuse the pose_detector passed in (initialized once per batch) or create one if needed
pose_faces = []
- pose_detector = None
- if RETINAFACE_AVAILABLE:
+ if pose_detector is not None:
+ # Use the shared detector instance (much faster - no reinitialization)
try:
- pose_detector = PoseDetector()
pose_faces = pose_detector.detect_pose_faces(face_detection_path)
if pose_faces:
print(f"[FaceService] Pose detection: found {len(pose_faces)} faces with pose data")
except Exception as e:
print(f"[FaceService] ā ļø Pose detection failed for {photo.filename}: {e}, using defaults")
pose_faces = []
+ elif RETINAFACE_AVAILABLE:
+ # Fallback: create detector if not provided (backward compatibility)
+ try:
+ pose_detector_local = PoseDetector()
+ pose_faces = pose_detector_local.detect_pose_faces(face_detection_path)
+ if pose_faces:
+ print(f"[FaceService] Pose detection: found {len(pose_faces)} faces with pose data")
+ except Exception as e:
+ print(f"[FaceService] ā ļø Pose detection failed for {photo.filename}: {e}, using defaults")
+ pose_faces = []
try:
# Step 2: Use DeepFace for encoding generation
@@ -457,6 +470,18 @@ def process_photo_faces(
yaw_angle = pose_info.get('yaw_angle')
pitch_angle = pose_info.get('pitch_angle')
roll_angle = pose_info.get('roll_angle')
+ face_width = pose_info.get('face_width') # Extract face width for verification
+
+ # Log face width for profile detection verification
+ if face_width is not None:
+ profile_status = "PROFILE" if face_width < 25.0 else "FRONTAL"
+ yaw_str = f"{yaw_angle:.2f}Ā°" if yaw_angle is not None else "None"
+ print(f"[FaceService] Face {idx+1}/{faces_detected} in {photo.filename}: "
+ f"face_width={face_width:.2f}px, pose_mode={pose_mode} ({profile_status}), yaw={yaw_str}")
+ else:
+ yaw_str = f"{yaw_angle:.2f}Ā°" if yaw_angle is not None else "None"
+ print(f"[FaceService] Face {idx+1}/{faces_detected} in {photo.filename}: "
+ f"face_width=None, pose_mode={pose_mode}, yaw={yaw_str}")
# Store face in database - match desktop schema exactly
# Desktop: confidence REAL DEFAULT 0.0 (legacy), face_confidence REAL (actual)
@@ -511,8 +536,55 @@ def process_photo_faces(
raise Exception(f"Error processing faces in {photo.filename}: {str(e)}")
+def _calculate_iou(box1: Dict, box2: Dict) -> float:
+ """Calculate Intersection over Union (IoU) between two bounding boxes.
+
+ Args:
+ box1: First bounding box {'x': x, 'y': y, 'w': w, 'h': h}
+ box2: Second bounding box {'x': x, 'y': y, 'w': w, 'h': h}
+
+ Returns:
+ IoU value between 0.0 and 1.0 (1.0 = perfect overlap)
+ """
+ # Get coordinates
+ x1_min = box1.get('x', 0)
+ y1_min = box1.get('y', 0)
+ x1_max = x1_min + box1.get('w', 0)
+ y1_max = y1_min + box1.get('h', 0)
+
+ x2_min = box2.get('x', 0)
+ y2_min = box2.get('y', 0)
+ x2_max = x2_min + box2.get('w', 0)
+ y2_max = y2_min + box2.get('h', 0)
+
+ # Calculate intersection
+ inter_x_min = max(x1_min, x2_min)
+ inter_y_min = max(y1_min, y2_min)
+ inter_x_max = min(x1_max, x2_max)
+ inter_y_max = min(y1_max, y2_max)
+
+ if inter_x_max <= inter_x_min or inter_y_max <= inter_y_min:
+ return 0.0
+
+ inter_area = (inter_x_max - inter_x_min) * (inter_y_max - inter_y_min)
+
+ # Calculate union
+ box1_area = box1.get('w', 0) * box1.get('h', 0)
+ box2_area = box2.get('w', 0) * box2.get('h', 0)
+ union_area = box1_area + box2_area - inter_area
+
+ if union_area == 0:
+ return 0.0
+
+ return inter_area / union_area
+
+
def _find_matching_pose_info(facial_area: Dict, pose_faces: List[Dict]) -> Dict:
- """Match DeepFace result with RetinaFace pose detection result
+ """Match DeepFace result with RetinaFace pose detection result using IoU.
+
+ Uses Intersection over Union (IoU) for robust bounding box matching, which is
+ the standard approach in computer vision. This is more reliable than center
+ point distance, especially when bounding boxes have different sizes or aspect ratios.
Args:
facial_area: DeepFace facial_area {'x': x, 'y': y, 'w': w, 'h': h}
@@ -521,28 +593,50 @@ def _find_matching_pose_info(facial_area: Dict, pose_faces: List[Dict]) -> Dict:
Returns:
Dictionary with pose information, or defaults
"""
- # Match by bounding box overlap
- # Simple approach: find closest match by center point
if not pose_faces:
return {
'pose_mode': 'frontal',
'yaw_angle': None,
'pitch_angle': None,
- 'roll_angle': None
+ 'roll_angle': None,
+ 'face_width': None
}
- deepface_center_x = facial_area.get('x', 0) + facial_area.get('w', 0) / 2
- deepface_center_y = facial_area.get('y', 0) + facial_area.get('h', 0) / 2
+ # If only one face detected by both systems, use it directly
+ if len(pose_faces) == 1:
+ pose_face = pose_faces[0]
+ pose_area = pose_face.get('facial_area', {})
+
+ # Handle both dict and list formats
+ if isinstance(pose_area, list) and len(pose_area) >= 4:
+ pose_area = {
+ 'x': pose_area[0],
+ 'y': pose_area[1],
+ 'w': pose_area[2],
+ 'h': pose_area[3]
+ }
+
+ if isinstance(pose_area, dict) and pose_area:
+ # Still check IoU to ensure it's a reasonable match
+ iou = _calculate_iou(facial_area, pose_area)
+ if iou > 0.1: # At least 10% overlap
+ return {
+ 'pose_mode': pose_face.get('pose_mode', 'frontal'),
+ 'yaw_angle': pose_face.get('yaw_angle'),
+ 'pitch_angle': pose_face.get('pitch_angle'),
+ 'roll_angle': pose_face.get('roll_angle'),
+ 'face_width': pose_face.get('face_width') # Extract face width
+ }
+ # Multiple faces: find best match using IoU
best_match = None
- min_distance = float('inf')
+ best_iou = 0.0
for pose_face in pose_faces:
pose_area = pose_face.get('facial_area', {})
- # Handle both dict and list formats (for robustness)
+ # Handle both dict and list formats
if isinstance(pose_area, list) and len(pose_area) >= 4:
- # Convert list [x, y, w, h] to dict format
pose_area = {
'x': pose_area[0],
'y': pose_area[1],
@@ -550,36 +644,85 @@ def _find_matching_pose_info(facial_area: Dict, pose_faces: List[Dict]) -> Dict:
'h': pose_area[3]
}
elif not isinstance(pose_area, dict):
- # Skip if not dict or list
continue
- pose_center_x = (pose_area.get('x', 0) +
- pose_area.get('w', 0) / 2)
- pose_center_y = (pose_area.get('y', 0) +
- pose_area.get('h', 0) / 2)
+ if not pose_area:
+ continue
- # Calculate distance between centers
- distance = ((deepface_center_x - pose_center_x) ** 2 +
- (deepface_center_y - pose_center_y) ** 2) ** 0.5
+ # Calculate IoU between DeepFace and RetinaFace bounding boxes
+ iou = _calculate_iou(facial_area, pose_area)
- if distance < min_distance:
- min_distance = distance
+ if iou > best_iou:
+ best_iou = iou
best_match = pose_face
- # If match is close enough (within 50 pixels), use it
- if best_match and min_distance < 50:
+ # Use match if IoU is above threshold (0.1 = 10% overlap is very lenient)
+ # Since DeepFace uses RetinaFace as detector_backend, they should detect similar faces
+ # Lower threshold to catch more matches
+ if best_match and best_iou > 0.1:
return {
'pose_mode': best_match.get('pose_mode', 'frontal'),
'yaw_angle': best_match.get('yaw_angle'),
'pitch_angle': best_match.get('pitch_angle'),
- 'roll_angle': best_match.get('roll_angle')
+ 'roll_angle': best_match.get('roll_angle'),
+ 'face_width': best_match.get('face_width') # Extract face width
}
+ # Aggressive fallback: if we have pose_faces detected, use the best match
+ # DeepFace and RetinaFace might detect slightly different bounding boxes,
+ # but if we have pose data, we should use it
+ if best_match:
+ deepface_center_x = facial_area.get('x', 0) + facial_area.get('w', 0) / 2
+ deepface_center_y = facial_area.get('y', 0) + facial_area.get('h', 0) / 2
+
+ pose_area = best_match.get('facial_area', {})
+ if isinstance(pose_area, list) and len(pose_area) >= 4:
+ pose_area = {
+ 'x': pose_area[0],
+ 'y': pose_area[1],
+ 'w': pose_area[2],
+ 'h': pose_area[3]
+ }
+
+ if isinstance(pose_area, dict) and pose_area:
+ pose_center_x = pose_area.get('x', 0) + pose_area.get('w', 0) / 2
+ pose_center_y = pose_area.get('y', 0) + pose_area.get('h', 0) / 2
+
+ distance = ((deepface_center_x - pose_center_x) ** 2 +
+ (deepface_center_y - pose_center_y) ** 2) ** 0.5
+
+ # Very lenient fallback: use if distance is within 30% of face size or 150 pixels
+ # This ensures we capture pose data even when bounding boxes differ significantly
+ face_size = (facial_area.get('w', 0) + facial_area.get('h', 0)) / 2
+ threshold = max(face_size * 0.30, 150.0) # At least 150 pixels, or 30% of face size
+
+ if distance < threshold:
+ return {
+ 'pose_mode': best_match.get('pose_mode', 'frontal'),
+ 'yaw_angle': best_match.get('yaw_angle'),
+ 'pitch_angle': best_match.get('pitch_angle'),
+ 'roll_angle': best_match.get('roll_angle'),
+ 'face_width': best_match.get('face_width') # Extract face width
+ }
+
+ # Last resort: if we have pose_faces and only one face, use it regardless
+ # This handles cases where DeepFace and RetinaFace detect the same face
+ # but with very different bounding boxes
+ if len(pose_faces) == 1:
+ return {
+ 'pose_mode': best_match.get('pose_mode', 'frontal'),
+ 'yaw_angle': best_match.get('yaw_angle'),
+ 'pitch_angle': best_match.get('pitch_angle'),
+ 'roll_angle': best_match.get('roll_angle'),
+ 'face_width': best_match.get('face_width') # Extract face width
+ }
+
return {
'pose_mode': 'frontal',
'yaw_angle': None,
'pitch_angle': None,
- 'roll_angle': None
+ 'roll_angle': None,
+ 'face_width': None
}
@@ -668,6 +811,18 @@ def process_unprocessed_photos(
print("[FaceService] Job cancelled before processing started")
return photos_processed, total_faces_detected, total_faces_stored
+ # Initialize PoseDetector ONCE for the entire batch (reuse across all photos)
+ # This avoids reinitializing RetinaFace for every photo, which is very slow
+ pose_detector = None
+ if RETINAFACE_AVAILABLE:
+ try:
+ print(f"[FaceService] Initializing RetinaFace pose detector...")
+ pose_detector = PoseDetector()
+ print(f"[FaceService] Pose detector initialized successfully")
+ except Exception as e:
+ print(f"[FaceService] ā ļø Pose detection not available: {e}, will skip pose detection")
+ pose_detector = None
+
# Update progress - models are ready, starting photo processing
if update_progress and total > 0:
update_progress(0, total, f"Starting face detection on {total} photos...", 0, 0)
@@ -709,6 +864,7 @@ def process_unprocessed_photos(
photo,
detector_backend=detector_backend,
model_name=model_name,
+ pose_detector=pose_detector, # Reuse the same detector for all photos
)
total_faces_detected += faces_detected
@@ -1052,7 +1208,6 @@ def find_similar_faces(
# Get base face - matching desktop
base: Face = db.query(Face).filter(Face.id == face_id).first()
if not base:
- print(f"DEBUG: Face {face_id} not found")
return []
# Load base encoding - desktop uses float64, ArcFace has 512 dimensions
@@ -1060,27 +1215,9 @@ def find_similar_faces(
base_enc = np.frombuffer(base.encoding, dtype=np.float64)
base_enc = base_enc.copy() # Make a copy to avoid buffer issues
- # Debug encoding info
- if face_id in [111, 113]:
- print(f"DEBUG: Base face {face_id} encoding:")
- print(f"DEBUG: - Type: {type(base.encoding)}, Length: {len(base.encoding) if hasattr(base.encoding, '__len__') else 'N/A'}")
- print(f"DEBUG: - Shape: {base_enc.shape}")
- print(f"DEBUG: - Dtype: {base_enc.dtype}")
- print(f"DEBUG: - Has NaN: {np.isnan(base_enc).any()}")
- print(f"DEBUG: - Has Inf: {np.isinf(base_enc).any()}")
- print(f"DEBUG: - Min: {np.min(base_enc)}, Max: {np.max(base_enc)}")
- print(f"DEBUG: - Norm: {np.linalg.norm(base_enc)}")
-
# Desktop uses 0.5 as default quality for target face (hardcoded, matching desktop exactly)
# Desktop: target_quality = 0.5 # Default quality for target face
base_quality = 0.5
-
- # Debug for face ID 1
- if face_id == 1:
- print(f"DEBUG: Base face {face_id} quality (hardcoded): {base_quality}")
- print(f"DEBUG: Base face {face_id} actual quality_score: {base.quality_score}")
- print(f"DEBUG: Base face {face_id} photo_id: {base.photo_id}")
- print(f"DEBUG: Base face {face_id} person_id: {base.person_id}")
# Desktop: get ALL faces from database (matching get_all_face_encodings)
# Desktop find_similar_faces gets ALL faces, doesn't filter by photo_id
@@ -1092,34 +1229,12 @@ def find_similar_faces(
.all()
)
- print(f"DEBUG: Comparing face {face_id} with {len(all_faces)} other faces")
-
- # Check if target face (111 or 113, or 1 for debugging) is in candidates
- if face_id in [111, 113, 1]:
- target_face_id = 113 if face_id == 111 else 111
- target_face = next((f for f in all_faces if f.id == target_face_id), None)
- if target_face:
- print(f"DEBUG: Target face {target_face_id} found in candidates")
- print(f"DEBUG: Target face {target_face_id} person_id: {target_face.person_id}")
- print(f"DEBUG: Target face {target_face_id} quality: {target_face.quality_score}")
- else:
- print(f"DEBUG: Target face {target_face_id} NOT found in candidates!")
-
matches: List[Tuple[Face, float, float]] = []
for f in all_faces:
# Load other encoding - desktop uses float64, ArcFace has 512 dimensions
other_enc = np.frombuffer(f.encoding, dtype=np.float64)
other_enc = other_enc.copy() # Make a copy to avoid buffer issues
- # Debug encoding info for comparison
- if face_id in [111, 113] and f.id in [111, 113]:
- print(f"DEBUG: Other face {f.id} encoding:")
- print(f"DEBUG: - Shape: {other_enc.shape}")
- print(f"DEBUG: - Has NaN: {np.isnan(other_enc).any()}")
- print(f"DEBUG: - Has Inf: {np.isinf(other_enc).any()}")
- print(f"DEBUG: - Min: {np.min(other_enc)}, Max: {np.max(other_enc)}")
- print(f"DEBUG: - Norm: {np.linalg.norm(other_enc)}")
-
other_quality = float(f.quality_score) if f.quality_score is not None else 0.5
# Calculate adaptive tolerance based on both face qualities (matching desktop exactly)
@@ -1129,17 +1244,6 @@ def find_similar_faces(
# Calculate distance (matching desktop exactly)
distance = calculate_cosine_distance(base_enc, other_enc)
- # Special debug for faces 111, 113, and 1
- if face_id in [111, 113, 1] and (f.id in [111, 113, 1] or (face_id == 1 and len(matches) < 5)):
- print(f"DEBUG: ===== COMPARING FACE {face_id} WITH FACE {f.id} =====")
- print(f"DEBUG: Base quality: {base_quality}, Other quality: {other_quality}")
- print(f"DEBUG: Avg quality: {avg_quality:.4f}")
- print(f"DEBUG: Base tolerance: {tolerance}, Adaptive tolerance: {adaptive_tolerance:.6f}")
- print(f"DEBUG: Calculated distance: {distance:.6f}")
- print(f"DEBUG: Distance <= adaptive_tolerance? {distance <= adaptive_tolerance} ({distance:.6f} <= {adaptive_tolerance:.6f})")
- print(f"DEBUG: Base encoding shape: {base_enc.shape}, Other encoding shape: {other_enc.shape}")
- print(f"DEBUG: Base encoding norm: {np.linalg.norm(base_enc):.4f}, Other encoding norm: {np.linalg.norm(other_enc):.4f}")
-
# Filter by distance <= adaptive_tolerance (matching desktop find_similar_faces)
if distance <= adaptive_tolerance:
# Get photo info (desktop does this in find_similar_faces)
@@ -1152,45 +1256,18 @@ def find_similar_faces(
# 2. confidence >= 40%
is_unidentified = f.person_id is None
- # Special debug for faces 111, 113, and 1
- if face_id in [111, 113, 1] and (f.id in [111, 113, 1] or (face_id == 1 and len(matches) < 10)):
- print(f"DEBUG: === AFTER DISTANCE FILTER FOR FACE {f.id} ===")
- print(f"DEBUG: Confidence calculated: {confidence_pct:.2f}%")
- print(f"DEBUG: Is unidentified: {is_unidentified} (person_id={f.person_id})")
- print(f"DEBUG: Confidence >= 40? {confidence_pct >= 40}")
- print(f"DEBUG: Will include? {is_unidentified and confidence_pct >= 40}")
-
if is_unidentified and confidence_pct >= 40:
# Filter by pose_mode if requested (only frontal or tilted faces)
if filter_frontal_only and not _is_acceptable_pose_for_auto_match(f.pose_mode):
- if face_id in [111, 113, 1] or (face_id == 1 and len(matches) < 10):
- print(f"DEBUG: ā Face {f.id} filtered out (not frontal/tilted: {f.pose_mode})")
continue
# Return calibrated confidence percentage (matching desktop)
# Desktop displays confidence_pct directly from _get_calibrated_confidence
matches.append((f, distance, confidence_pct))
-
- if face_id in [111, 113, 1] or (face_id == 1 and len(matches) < 10):
- print(f"DEBUG: āāā MATCH FOUND: face {f.id} (distance={distance:.6f}, confidence={confidence_pct:.2f}%, adaptive_tol={adaptive_tolerance:.6f}) āāā")
- else:
- if face_id in [111, 113, 1] or (face_id == 1 and len(matches) < 10):
- print(f"DEBUG: āāā Face {f.id} FILTERED OUT:")
- print(f"DEBUG: - unidentified: {is_unidentified} (person_id={f.person_id})")
- print(f"DEBUG: - confidence: {confidence_pct:.2f}% (need >= 40%)")
- print(f"DEBUG: - distance: {distance:.6f}, adaptive_tolerance: {adaptive_tolerance:.6f}")
- else:
- if face_id == 1 and len(matches) < 5:
- print(f"DEBUG: ā Face {f.id} has no photo")
- else:
- if face_id == 1 and len(matches) < 10:
- print(f"DEBUG: ā Face {f.id} distance {distance:.6f} > tolerance {adaptive_tolerance:.6f} (failed distance filter)")
# Sort by distance (lower is better) - matching desktop
matches.sort(key=lambda x: x[1])
- print(f"DEBUG: Returning {len(matches)} matches for face_id={face_id}")
-
# Limit results
return matches[:limit]