fix: face detection models directory conflict and profile support

faceless_processing.py

@@ -24,7 +24,8 @@ def _download_assets_globally():
         os.makedirs(cascade_dir, exist_ok=True)
         xml_urls = {
             'haarcascade_frontalface_default.xml': 'https://raw.githubusercontent.com/opencv/opencv/master/data/haarcascades/haarcascade_frontalface_default.xml',
-            'haarcascade_frontalface_alt2.xml': 'https://raw.githubusercontent.com/opencv/opencv/master/data/haarcascades/haarcascade_frontalface_alt2.xml'
+            'haarcascade_frontalface_alt2.xml': 'https://raw.githubusercontent.com/opencv/opencv/master/data/haarcascades/haarcascade_frontalface_alt2.xml',
+            'haarcascade_profileface.xml': 'https://raw.githubusercontent.com/opencv/opencv/master/data/haarcascades/haarcascade_profileface.xml'
         }
         for name, url in xml_urls.items():
             path = os.path.join(cascade_dir, name)
@@ -78,16 +79,16 @@ class LineartConfig:
     min_silhouette_area: float = 200.0     # drop tiny isolated blobs from the silhouette (px²)
 
     # Silhouette outline
-    silhouette_line_thickness: int = 3   # outer contour stroke width (px); match interior for uniform look
+    silhouette_line_thickness: int = 4   # outer contour stroke width (px); match interior for uniform look
 
     # Edge detection
-    canny_low: int = 40
-    canny_high: int = 110
+    canny_low: int = 35
+    canny_high: int = 85
     bilateral_d: int = 11
     bilateral_sigma_color: int = 80
     bilateral_sigma_space: int = 80
     gaussian_ksize: int = 9
-    min_contour_perimeter: float = 50.0    # filters out short noisy lines
+    min_contour_perimeter: float = 25.0    # filters out short noisy lines
     interior_line_thickness: int = 3        # thickness of interior detail lines (>=1)
 
     # Face detection
@@ -97,11 +98,11 @@ class LineartConfig:
     face_max_y_ratio: float = 0.6          # ignore faces below 60% image height
     face_nms_iou_thresh: float = 0.4
 
-    # Face erase ellipse (ratios relative to face bbox) — smaller = more conservative
+    # Face erase ellipse (ratios relative to face bbox) — fallback parameters
     face_cx_ratio: float = 0.5
-    face_cy_ratio: float = 0.45
-    face_rx_ratio: float = 0.35            # reduced from 0.40 to avoid erasing neck/ears
-    face_ry_ratio: float = 0.38            # reduced from 0.42 to avoid erasing chin/neck
+    face_cy_ratio: float = 0.50
+    face_rx_ratio: float = 0.44            # adjusted for better fallback erasure
+    face_ry_ratio: float = 0.46
     face_erase_blur: int = 8
     face_erase_threshold: int = 130        # higher = sharper face mask edge, less spill
 
@@ -131,46 +132,87 @@ def _nms_faces(faces: list, iou_thresh: float) -> list:
 
 def detect_faces(rgb: np.ndarray, cfg: LineartConfig) -> list:
     """Detect faces and filter out false positives in lower body."""
-    h = rgb.shape[0]
-    gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)
+    h, w = rgb.shape[:2]
     faces = []
 
+    # 1. MediaPipe face detection (highly robust for profile/side/tilted faces)
+    try:
+        import mediapipe as mp
+        model_path = cfg.mediapipe_model_path
+        if not model_path or not os.path.exists(model_path):
+            model_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "models")
+            model_path = os.path.join(model_dir, "face_landmarker.task")
+        
+        if os.path.exists(model_path):
+            num_faces = 6
+            with _LANDMARKER_LOCK:
+                landmarker = get_landmarker(model_path, num_faces=num_faces)
+                mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=rgb)
+                mp_result = landmarker.detect(mp_image)
+                
+                if mp_result.face_landmarks:
+                    for face_lms in mp_result.face_landmarks:
+                        xs = [lm.x * w for lm in face_lms]
+                        ys = [lm.y * h for lm in face_lms]
+                        min_x, max_x = min(xs), max(xs)
+                        min_y, max_y = min(ys), max(ys)
+                        
+                        bw = max_x - min_x
+                        bh = max_y - min_y
+                        
+                        pad_x = bw * 0.15
+                        pad_y = bh * 0.15
+                        
+                        fx = int(max(0, min_x - pad_x))
+                        fy = int(max(0, min_y - pad_y))
+                        fw = int(min(w - fx, bw + 2 * pad_x))
+                        fh = int(min(h - fy, bh + 2 * pad_y))
+                        
+                        faces.append([fx, fy, fw, fh])
+    except Exception as mp_err:
+        print(f"[AI] MediaPipe face detection failed in detect_faces: {mp_err}")
+
+    # 2. Haar Cascades (frontal and profile)
     try:
-        # Load local classifiers from downloaded folder
+        gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)
+        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+        gray_eq = clahe.apply(gray)
+        
         cascade_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "cascades")
         path_default = os.path.join(cascade_dir, 'haarcascade_frontalface_default.xml')
         path_alt = os.path.join(cascade_dir, 'haarcascade_frontalface_alt2.xml')
+        path_profile = os.path.join(cascade_dir, 'haarcascade_profileface.xml')
         
         classifiers = []
         if os.path.exists(path_default):
             classifiers.append(cv2.CascadeClassifier(path_default))
         if os.path.exists(path_alt):
             classifiers.append(cv2.CascadeClassifier(path_alt))
+        if os.path.exists(path_profile):
+            classifiers.append(cv2.CascadeClassifier(path_profile))
             
-        # Fallback to cv2 data directory if local files are missing
         if not classifiers or all(c.empty() for c in classifiers):
             classifiers = [
                 cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'),
-                cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_alt2.xml')
+                cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_alt2.xml'),
+                cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_profileface.xml')
             ]
-            
         for cascade in classifiers:
             if cascade and not cascade.empty():
-                detected = cascade.detectMultiScale(
-                    gray,
-                    scaleFactor=cfg.face_scale_factor,
-                    minNeighbors=cfg.face_min_neighbors,
-                    minSize=cfg.face_min_size
-                )
-                if len(detected) > 0:
-                    faces.extend(detected.tolist())
+                for img_gray in [gray, gray_eq]:
+                    detected = cascade.detectMultiScale(
+                        img_gray,
+                        scaleFactor=cfg.face_scale_factor,
+                        minNeighbors=cfg.face_min_neighbors,
+                        minSize=cfg.face_min_size
+                    )
+                    if len(detected) > 0:
+                        faces.extend(detected.tolist())
     except Exception as e:
-        print(f"[AI] Face detection failed or cascades unavailable: {e}")
+        print(f"[AI] Haar Cascade face detection failed: {e}")
 
-    # Remove detections in lower body (false positives)
+    # 3. Filter and Deduplicate
     faces = [f for f in faces if f[1] < h * cfg.face_max_y_ratio]
-
-    # Remove duplicates
     faces = _nms_faces(faces, cfg.face_nms_iou_thresh)
     return faces
 
@@ -192,35 +234,72 @@ def build_subject_mask(rgb: np.ndarray, cfg: LineartConfig, alpha_channel: Optio
 def build_silhouette(subject_mask: np.ndarray, cfg: LineartConfig) -> np.ndarray:
     """Draw the subject silhouette as a smooth, solid-stroke contour."""
     mask = subject_mask.copy()
-
-    # Smooth the mask boundary to eliminate staircase jaggies before tracing
-    if cfg.mask_smooth_ksize > 1:
-        # Use a larger kernel (at least 15) for beautiful organic curves
-        k = max(15, cfg.mask_smooth_ksize if cfg.mask_smooth_ksize % 2 == 1 else cfg.mask_smooth_ksize + 1)
-        mask = cv2.GaussianBlur(mask, (k, k), 0)
-        _, mask = cv2.threshold(mask, cfg.mask_smooth_threshold, 255, cv2.THRESH_BINARY)
+    h, w = mask.shape[:2]
+    # Dynamic proportional smoothing based on image size to eliminate jaggies completely
+    k = int(max(w, h) * 0.035)
+    if k % 2 == 0:
+        k += 1
+    k = max(25, k)
+    mask = cv2.GaussianBlur(mask, (k, k), 0)
+    _, mask = cv2.threshold(mask, cfg.mask_smooth_threshold, 255, cv2.THRESH_BINARY)
 
     contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_TC89_KCOS)
     silhouette = np.zeros_like(subject_mask)
     for cnt in contours:
         if cv2.contourArea(cnt) >= cfg.min_silhouette_area:
-            # Smooth contour slightly without polygonal blockiness
             eps = 0.0012 * cv2.arcLength(cnt, True)
             smooth = cv2.approxPolyDP(cnt, eps, True)
-            cv2.drawContours(silhouette, [smooth], -1, 255, cfg.silhouette_line_thickness)
+            cv2.drawContours(silhouette, [smooth], -1, 255, cfg.silhouette_line_thickness, lineType=cv2.LINE_AA)
     return silhouette
 
 
-def build_face_erase_mask(faces: list, shape: Tuple[int, int], cfg: LineartConfig) -> np.ndarray:
-    """Build a soft binary mask covering face interior regions."""
-    h, w = shape
+def build_face_erase_mask(rgb: np.ndarray, faces: list, cfg: LineartConfig) -> np.ndarray:
+    """Build a soft binary mask covering face interior regions using MediaPipe polygon or fallback ellipse."""
+    h, w = rgb.shape[:2]
     mask = np.zeros((h, w), dtype=np.uint8)
-    for (fx, fy, fw, fh) in faces:
-        cx = int(fx + fw * cfg.face_cx_ratio)
-        cy = int(fy + fh * cfg.face_cy_ratio)
-        rx = int(fw * cfg.face_rx_ratio)
-        ry = int(fh * cfg.face_ry_ratio)
-        cv2.ellipse(mask, (cx, cy), (rx, ry), 0, 0, 360, 255, -1)
+    
+    # 1. Exact polygon face erasure using MediaPipe FACE_OVAL landmarks (100% covers mouth/smile/eyes/nose exactly)
+    has_mp_erase = False
+    try:
+        import mediapipe as mp
+        model_path = cfg.mediapipe_model_path
+        if not model_path or not os.path.exists(model_path):
+            model_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "models")
+            model_path = os.path.join(model_dir, "face_landmarker.task")
+            
+        if os.path.exists(model_path):
+            num_faces = 6
+            with _LANDMARKER_LOCK:
+                landmarker = get_landmarker(model_path, num_faces=num_faces)
+                mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=rgb)
+                mp_result = landmarker.detect(mp_image)
+                
+                if mp_result.face_landmarks:
+                    FACE_OVAL = [10, 338, 297, 332, 284, 251, 389, 356, 454, 323, 361, 288,
+                                 397, 365, 379, 378, 400, 377, 152, 148, 176, 149, 150, 136,
+                                 172, 58, 132, 93, 234, 127, 162, 21, 54, 103, 67, 109]
+                    for face_lms in mp_result.face_landmarks:
+                        pts = []
+                        for idx in FACE_OVAL:
+                            lm = face_lms[idx]
+                            px = int(lm.x * w)
+                            py = int(lm.y * h)
+                            pts.append([px, py])
+                        pts_np = np.array(pts, np.int32).reshape((-1, 1, 2))
+                        cv2.fillPoly(mask, [pts_np], 255)
+                    has_mp_erase = True
+    except Exception as mp_err:
+        print(f"[AI] MediaPipe face contour polygon erase failed: {mp_err}")
+
+    # 2. Bounding-box Ellipse Fallback (if MediaPipe fails or finds no faces)
+    if not has_mp_erase or not np.any(mask):
+        for (fx, fy, fw, fh) in faces:
+            cx = int(fx + fw * cfg.face_cx_ratio)
+            cy = int(fy + fh * cfg.face_cy_ratio)
+            rx = int(fw * cfg.face_rx_ratio)
+            ry = int(fh * cfg.face_ry_ratio)
+            cv2.ellipse(mask, (cx, cy), (rx, ry), 0, 0, 360, 255, -1, lineType=cv2.LINE_AA)
+            
     soft = np.array(Image.fromarray(mask).filter(ImageFilter.GaussianBlur(cfg.face_erase_blur)))
     return (soft > cfg.face_erase_threshold).astype(np.uint8) * 255
 
@@ -259,10 +338,11 @@ def build_interior_edges(rgb: np.ndarray, subject_mask: np.ndarray, cfg: Lineart
 
 _LANDMARKER_LOCK = threading.Lock()
 _LANDMARKER_CACHE = None
+_LANDMARKER_NUM_FACES = None
 
-def get_landmarker(model_path):
-    global _LANDMARKER_CACHE
-    if _LANDMARKER_CACHE is None:
+def get_landmarker(model_path, num_faces: int = 1):
+    global _LANDMARKER_CACHE, _LANDMARKER_NUM_FACES
+    if _LANDMARKER_CACHE is None or _LANDMARKER_NUM_FACES != num_faces:
         import mediapipe as mp
         from mediapipe.tasks import python
         from mediapipe.tasks.python import vision
@@ -272,9 +352,13 @@ def get_landmarker(model_path):
             base_options=base_options,
             output_face_blendshapes=False,
             output_facial_transformation_matrixes=False,
-            num_faces=1
+            num_faces=num_faces,
+            min_face_detection_confidence=0.2,
+            min_face_presence_confidence=0.2,
+            min_tracking_confidence=0.2,
         )
         _LANDMARKER_CACHE = vision.FaceLandmarker.create_from_options(options)
+        _LANDMARKER_NUM_FACES = num_faces
     return _LANDMARKER_CACHE
 
 
@@ -425,7 +509,7 @@ def make_faceless_lineart(
     interior = build_interior_edges(rgb, subject_mask, cfg)
 
     # 5. Erase face details (keep silhouette outline of head shape)
-    face_erase = build_face_erase_mask(faces, (h, w), cfg)
+    face_erase = build_face_erase_mask(rgb, faces, cfg)
     interior_clean = cv2.bitwise_and(interior, cv2.bitwise_not(face_erase))
 
     # 6. Combine