Update landmarkdiff/evaluation.py to v0.3.2

landmarkdiff/evaluation.py

@@ -24,7 +24,7 @@ class EvalMetrics:
 
     fid: float = 0.0
     lpips: float = 0.0
-    nme: float = 0.0  # Normalized Mean landmark Error
+    nme: float = 0.0           # Normalized Mean landmark Error
     identity_sim: float = 0.0  # ArcFace cosine similarity
     ssim: float = 0.0
 
@@ -155,7 +155,9 @@ def compute_nme(
     Returns:
         NME value (lower is better).
     """
-    iod = np.linalg.norm(target_landmarks[left_eye_idx] - target_landmarks[right_eye_idx])
+    iod = np.linalg.norm(
+        target_landmarks[left_eye_idx] - target_landmarks[right_eye_idx]
+    )
     if iod < 1.0:
         iod = 1.0
 
@@ -174,7 +176,6 @@ def compute_ssim(
     """
     try:
         from skimage.metrics import structural_similarity
-
         # Convert to grayscale if color, or compute per-channel
         if pred.ndim == 3 and pred.shape[2] == 3:
             return float(structural_similarity(pred, target, channel_axis=2, data_range=255))
@@ -194,8 +195,10 @@ def compute_ssim(
         C1 = (0.01 * 255) ** 2
         C2 = (0.03 * 255) ** 2
 
-        ssim_val = ((2 * mu_p * mu_t + C1) * (2 * sigma_pt + C2)) / (
-            (mu_p**2 + mu_t**2 + C1) * (sigma_p**2 + sigma_t**2 + C2)
+        ssim_val = (
+            (2 * mu_p * mu_t + C1) * (2 * sigma_pt + C2)
+        ) / (
+            (mu_p ** 2 + mu_t ** 2 + C1) * (sigma_p ** 2 + sigma_t ** 2 + C2)
         )
         return float(ssim_val)
 
@@ -209,7 +212,6 @@ def _get_lpips_fn() -> Any:
     global _LPIPS_FN
     if _LPIPS_FN is None:
         import lpips
-
         _LPIPS_FN = lpips.LPIPS(net="alex", verbose=False)
         _LPIPS_FN.eval()
     return _LPIPS_FN
@@ -224,7 +226,7 @@ def compute_lpips(
     Returns LPIPS score (lower = more similar).
     """
     try:
-        import lpips  # noqa: F401
+        import lpips  # noqa: F401 — availability check; used in _get_lpips_fn
         import torch
     except ImportError:
         return float("nan")
@@ -257,13 +259,12 @@ def compute_fid(
     """
     try:
         from torch_fidelity import calculate_metrics
-    except ImportError:
+    except ImportError as e:
         raise ImportError(
             "torch-fidelity is required for FID. Install with: pip install torch-fidelity"
-        ) from None
+        ) from e
 
     import torch
-
     metrics = calculate_metrics(
         input1=generated_dir,
         input2=real_dir,
@@ -285,7 +286,6 @@ def compute_identity_similarity(
     """
     try:
         from insightface.app import FaceAnalysis
-
         global _ARCFACE_APP
         if _ARCFACE_APP is None:
             _ARCFACE_APP = FaceAnalysis(
@@ -315,6 +315,123 @@ def compute_identity_similarity(
     return compute_ssim(pred, target)
 
 
+# ------------------------------------------------------------------
+# Geometric nasal ratios (adapted from Varghaei et al., arXiv:2508.13363)
+# ------------------------------------------------------------------
+
+# MediaPipe 478-point indices for facial measurements
+_LEFT_ALAR = 129       # left alar (nose wing) outermost point
+_RIGHT_ALAR = 358      # right alar
+_NOSE_TIP = 1          # pronasale
+_NOSE_BRIDGE_TOP = 168 # nasion (bridge root)
+_LEFT_INNER_CANTHUS = 133
+_RIGHT_INNER_CANTHUS = 362
+_LEFT_TRAGION = 234    # left ear (face width proxy)
+_RIGHT_TRAGION = 454   # right ear
+_FOREHEAD = 10         # trichion / upper face
+_CHIN = 152            # menton / lowest chin point
+
+
+def compute_nasal_ratios(
+    landmarks: np.ndarray,
+) -> dict[str, float]:
+    """Compute 5 nasal geometric ratios from MediaPipe 478-point landmarks.
+
+    Ratios from Varghaei et al. (2025), used clinically to assess
+    rhinoplasty outcomes. All ratios are dimensionless.
+
+    Args:
+        landmarks: (478, 2) or (478, 3) landmark pixel coordinates.
+
+    Returns:
+        Dict with keys: alar_face_ratio, nose_face_ratio,
+        alar_intercanthal_ratio, tip_deviation, nostril_asymmetry.
+    """
+    pts = landmarks[:, :2]  # use only x,y
+
+    alar_width = np.linalg.norm(pts[_LEFT_ALAR] - pts[_RIGHT_ALAR])
+    face_width = np.linalg.norm(pts[_LEFT_TRAGION] - pts[_RIGHT_TRAGION])
+    nose_length = np.linalg.norm(pts[_NOSE_BRIDGE_TOP] - pts[_NOSE_TIP])
+    face_height = np.linalg.norm(pts[_FOREHEAD] - pts[_CHIN])
+    intercanthal = np.linalg.norm(
+        pts[_LEFT_INNER_CANTHUS] - pts[_RIGHT_INNER_CANTHUS]
+    )
+
+    # Midline: midpoint between inner canthi
+    midline_x = (pts[_LEFT_INNER_CANTHUS][0] + pts[_RIGHT_INNER_CANTHUS][0]) / 2
+    tip_deviation = abs(pts[_NOSE_TIP][0] - midline_x) / (face_width + 1e-8)
+
+    # Nostril asymmetry: difference in left/right alar-to-tip distances
+    left_dist = np.linalg.norm(pts[_LEFT_ALAR] - pts[_NOSE_TIP])
+    right_dist = np.linalg.norm(pts[_RIGHT_ALAR] - pts[_NOSE_TIP])
+    nostril_asymmetry = abs(left_dist - right_dist) / (alar_width + 1e-8)
+
+    return {
+        "alar_face_ratio": float(alar_width / (face_width + 1e-8)),
+        "nose_face_ratio": float(nose_length / (face_height + 1e-8)),
+        "alar_intercanthal_ratio": float(alar_width / (intercanthal + 1e-8)),
+        "tip_deviation": float(tip_deviation),
+        "nostril_asymmetry": float(nostril_asymmetry),
+    }
+
+
+def compute_bilateral_symmetry(
+    landmarks: np.ndarray,
+) -> float:
+    """Compute bilateral facial symmetry score from landmarks.
+
+    Reflects each left-side landmark across the vertical midline and
+    measures average displacement from the corresponding right-side point.
+    Normalized by inter-ocular distance.
+
+    Based on KDTree approach from Varghaei et al. (2025).
+
+    Args:
+        landmarks: (478, 2) or (478, 3) landmark pixel coordinates.
+
+    Returns:
+        Symmetry score in [0, 1] where 1 = perfect symmetry.
+    """
+    pts = landmarks[:, :2]
+
+    # Midline from forehead to chin
+    midline_x = (pts[_LEFT_TRAGION][0] + pts[_RIGHT_TRAGION][0]) / 2
+    iod = np.linalg.norm(pts[33] - pts[263])  # inter-ocular distance
+    if iod < 1.0:
+        iod = 1.0
+
+    # MediaPipe left-right correspondence pairs (subset of reliable pairs)
+    # format: (left_idx, right_idx)
+    sym_pairs = [
+        (33, 263),   # outer canthi
+        (133, 362),  # inner canthi
+        (70, 300),   # eyebrow inner
+        (105, 334),  # eyebrow outer
+        (129, 358),  # alar
+        (61, 291),   # mouth corners
+        (234, 454),  # tragion
+        (93, 323),   # cheekbone
+        (132, 361),  # lower eyelid
+        (159, 386),  # upper eyelid
+        (58, 288),   # lower lip
+        (172, 397),  # chin lateral
+        (136, 365),  # nose lateral
+        (48, 278),   # nostril
+    ]
+
+    diffs = []
+    for left_idx, right_idx in sym_pairs:
+        # Reflect left point across midline
+        reflected_x = 2 * midline_x - pts[left_idx][0]
+        reflected = np.array([reflected_x, pts[left_idx][1]])
+        diff = np.linalg.norm(reflected - pts[right_idx]) / iod
+        diffs.append(diff)
+
+    mean_asymmetry = np.mean(diffs)
+    # Convert to 0-1 symmetry score (asymmetry of 0 = score of 1)
+    return float(np.clip(1.0 - mean_asymmetry, 0.0, 1.0))
+
+
 def evaluate_batch(
     predictions: list[np.ndarray],
     targets: list[np.ndarray],