Update faceless_processing.py

faceless_processing.py

@@ -10,13 +10,6 @@ import urllib.request
 from rembg import remove, new_session
 import threading
 
-try:
-    from scipy.interpolate import splprep, splev
-    _SCIPY_AVAILABLE = True
-except ImportError:
-    _SCIPY_AVAILABLE = False
-    print("[AI] scipy not available — falling back to approxPolyDP for silhouette smoothing")
-
 try:
     _SESSION_ISNET = new_session("isnet-general-use")
 except Exception as e:
@@ -75,68 +68,42 @@ class LineartConfig:
     transparency_threshold: float = 0.03
     detect_eyebrows: bool = True
 
+
     # Subject mask
-    white_bg_threshold: int = 245
+    white_bg_threshold: int = 245          # pixels above this = background (raised to avoid erasing light subjects)
     mask_close_iterations: int = 4
     mask_open_iterations: int = 1
-    mask_smooth_ksize: int = 5
-    mask_smooth_threshold: int = 128
-    min_silhouette_area: float = 200.0
+    mask_smooth_ksize: int = 5             # GaussianBlur kernel before silhouette (must be odd; 0 = disabled)
+    mask_smooth_threshold: int = 128       # re-binarize after blur
+    min_silhouette_area: float = 200.0     # drop tiny isolated blobs from the silhouette (px²)
 
-    # Silhouette outline — thicker for embroidery visibility
-    silhouette_line_thickness: int = 4     # bold outer contour
+    # Silhouette outline
+    silhouette_line_thickness: int = 3   # outer contour stroke width (px); match interior for uniform look
 
-    # Edge detection — single pass, balanced for body/clothing details
-    canny_low: int = 40                    # slight lower to recover chin/jaw line
-    canny_high: int = 130
+    # Edge detection
+    canny_low: int = 40
+    canny_high: int = 110
     bilateral_d: int = 11
-    bilateral_sigma_color: int = 110
-    bilateral_sigma_space: int = 110
-    gaussian_ksize: int = 11
-    min_contour_perimeter: float = 65.0
-    interior_line_thickness: int = 3
-
-    # Secondary detail pass — keep OFF
-    enable_detail_pass: bool = False
-    detail_canny_low: int = 15
-    detail_canny_high: int = 55
-    detail_gaussian_ksize: int = 5
-    detail_min_perimeter: float = 30.0
-    detail_bilateral_d: int = 7
-    detail_bilateral_sigma: int = 60
-
-    # Embroidery stitch feasibility
-    min_embroidery_stitch_px: int = 25
+    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
+    interior_line_thickness: int = 3        # thickness of interior detail lines (>=1)
 
     # Face detection
     face_scale_factor: float = 1.05
     face_min_neighbors: int = 3
-    face_min_size: Tuple[int, int] = (20, 20)
-    face_max_y_ratio: float = 0.65
-    face_nms_iou_thresh: float = 0.35
-    face_max_count: int = 6
-
-    # Face erase ellipse — covers ONLY eyes/nose/mouth zone.
-    # Face bbox from OpenCV Haar cascade (forehead=0% → chin=100%):
-    #   Eyebrows:  ~20–30%  ← must NOT be erased
-    #   Eyes:      ~30–40%
-    #   Nose:      ~45–60%
-    #   Mouth:     ~60–70%
-    #   Chin:      ~80–100% ← must NOT be erased
-    # cy=0.46, ry=0.19 → erases from 27% to 65% → eyebrows above, chin below.
-    face_cx_ratio: float = 0.50
-    face_cy_ratio: float = 0.46          # center = eye-to-mouth midpoint
-    face_rx_ratio: float = 0.27          # moderate width
-    face_ry_ratio: float = 0.19          # short: 46-19=27% top, 46+19=65% bottom
-    face_erase_blur: int = 5             # tight blur → won't spill onto eyebrows/chin
-    face_erase_threshold: int = 90       # lower → harder edge
-
-    # MediaPipe face landmarker: max faces
-    mediapipe_num_faces: int = 6
-
-    # Eyebrow drawing — thick and bold for embroidery visibility
-    eyebrow_thickness: int = 5           # thick stroke
-    eyebrow_dilate: int = 2              # extra dilation for bolder lines
+    face_min_size: Tuple[int, int] = (25, 25)
+    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_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_erase_blur: int = 8
+    face_erase_threshold: int = 130        # higher = sharper face mask edge, less spill
 
 
 def _nms_faces(faces: list, iou_thresh: float) -> list:
@@ -163,15 +130,13 @@ def _nms_faces(faces: list, iou_thresh: float) -> list:
 
 
 def detect_faces(rgb: np.ndarray, cfg: LineartConfig) -> list:
-    """Detect up to cfg.face_max_count faces using dual Haar cascade + CLAHE preprocessing."""
+    """Detect faces and filter out false positives in lower body."""
     h = rgb.shape[0]
     gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)
-    # CLAHE equalisation improves detection on uneven lighting / dark photos
-    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
-    gray_eq = clahe.apply(gray)
     faces = []
 
     try:
+        # Load local classifiers from downloaded folder
         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')
@@ -182,6 +147,7 @@ def detect_faces(rgb: np.ndarray, cfg: LineartConfig) -> list:
         if os.path.exists(path_alt):
             classifiers.append(cv2.CascadeClassifier(path_alt))
             
+        # 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'),
@@ -190,16 +156,14 @@ def detect_faces(rgb: np.ndarray, cfg: LineartConfig) -> list:
             
         for cascade in classifiers:
             if cascade and not cascade.empty():
-                # Run on both raw and CLAHE-equalised gray for better recall
-                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())
+                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())
     except Exception as e:
         print(f"[AI] Face detection failed or cascades unavailable: {e}")
 
@@ -208,13 +172,6 @@ def detect_faces(rgb: np.ndarray, cfg: LineartConfig) -> list:
 
     # Remove duplicates
     faces = _nms_faces(faces, cfg.face_nms_iou_thresh)
-
-    # Enforce maximum face count
-    max_faces = getattr(cfg, 'face_max_count', 6)
-    if len(faces) > max_faces:
-        # Keep the largest faces (most prominent)
-        faces = sorted(faces, key=lambda f: f[2] * f[3], reverse=True)[:max_faces]
-
     return faces
 
 
@@ -232,73 +189,28 @@ def build_subject_mask(rgb: np.ndarray, cfg: LineartConfig, alpha_channel: Optio
     return mask
 
 
-def _smooth_contour_spline(cnt: np.ndarray, n_points: int = 400) -> Optional[np.ndarray]:
-    """
-    Fit a periodic B-spline through contour points and resample at n_points.
-    Returns a smooth (N,1,2) array ready for cv2.drawContours/polylines,
-    or None if spline fitting fails (e.g. too few points).
-    """
-    if not _SCIPY_AVAILABLE:
-        return None
-    pts = cnt[:, 0, :]          # (N, 2) array of (x, y)
-    if len(pts) < 4:
-        return None
-    try:
-        # smoothing factor s=0 = interpolating spline (passes through all points)
-        # per=True = closed/periodic curve
-        tck, _ = splprep([pts[:, 0].astype(float), pts[:, 1].astype(float)],
-                         s=len(pts) * 0.5, per=True, quiet=True)
-        u_new = np.linspace(0, 1, n_points)
-        x_new, y_new = splev(u_new, tck)
-        spline_pts = np.stack([x_new, y_new], axis=1).astype(np.int32)
-        return spline_pts.reshape((-1, 1, 2))
-    except Exception:
-        return None
-
-
 def build_silhouette(subject_mask: np.ndarray, cfg: LineartConfig) -> np.ndarray:
-    """
-    Draw the subject silhouette as a smooth, anti-aliased contour.
-    Uses scipy B-spline smoothing when available (far smoother than approxPolyDP).
-    Falls back to tiny-epsilon approxPolyDP + LINE_AA if scipy is missing.
-    """
+    """Draw the subject silhouette as a smooth, solid-stroke contour."""
     mask = subject_mask.copy()
 
-    # 1. Large Gaussian blur + re-threshold to eliminate staircase jaggies on mask edge
+    # Smooth the mask boundary to eliminate staircase jaggies before tracing
     if cfg.mask_smooth_ksize > 1:
-        k = max(21, cfg.mask_smooth_ksize if cfg.mask_smooth_ksize % 2 == 1 else 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)
 
-    # 2. Extra morphological close to fill small notches on the boundary
-    k_close = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (9, 9))
-    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, k_close, iterations=2)
-
-    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+    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:
-            continue
-
-        # Try scipy B-spline first for organically smooth curves
-        smooth = _smooth_contour_spline(cnt)
-        if smooth is not None:
-            cv2.polylines(silhouette, [smooth], isClosed=True,
-                          color=255, thickness=cfg.silhouette_line_thickness,
-                          lineType=cv2.LINE_AA)
-        else:
-            # Fallback: very small epsilon so approxPolyDP barely simplifies
-            eps = 0.0003 * cv2.arcLength(cnt, True)
-            approx = cv2.approxPolyDP(cnt, eps, True)
-            cv2.drawContours(silhouette, [approx], -1, 255,
-                             cfg.silhouette_line_thickness, lineType=cv2.LINE_AA)
-
+        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)
     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
@@ -314,38 +226,13 @@ def build_face_erase_mask(faces: list, shape: Tuple[int, int], cfg: LineartConfi
 
 
 def build_interior_edges(rgb: np.ndarray, subject_mask: np.ndarray, cfg: LineartConfig) -> np.ndarray:
-    """
-    Detect structural body lines using a two-pass Canny strategy:
-    - Primary pass: standard parameters for prominent structural lines
-    - Detail pass (optional): more sensitive params to capture fine features
-      (hair texture, fabric folds, accessories) that would still be stitchable
-    Lines too short to translate to embroidery stitches are discarded.
-    """
+    """Detect structural body lines using Canny, filtering noise."""
     gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)
-
-    # --- Primary pass ---
-    blurred_primary = cv2.bilateralFilter(gray, cfg.bilateral_d, cfg.bilateral_sigma_color, cfg.bilateral_sigma_space)
-    blurred_primary = cv2.GaussianBlur(blurred_primary, (cfg.gaussian_ksize, cfg.gaussian_ksize), 0)
-    edges_primary = cv2.Canny(blurred_primary, cfg.canny_low, cfg.canny_high)
-
-    # --- Detail pass (fine features) ---
-    edges_detail = np.zeros_like(edges_primary)
-    if getattr(cfg, 'enable_detail_pass', True):
-        detail_d = getattr(cfg, 'detail_bilateral_d', 7)
-        detail_sigma = getattr(cfg, 'detail_bilateral_sigma', 60)
-        detail_ksize = getattr(cfg, 'detail_gaussian_ksize', 5)
-        blurred_detail = cv2.bilateralFilter(gray, detail_d, detail_sigma, detail_sigma)
-        blurred_detail = cv2.GaussianBlur(blurred_detail, (detail_ksize, detail_ksize), 0)
-        edges_detail = cv2.Canny(
-            blurred_detail,
-            getattr(cfg, 'detail_canny_low', 15),
-            getattr(cfg, 'detail_canny_high', 55)
-        )
-
-    # Combine both passes
-    edges = cv2.bitwise_or(edges_primary, edges_detail)
-
-    # Erode subject mask to avoid catching the outer boundary twice
+    blurred = cv2.GaussianBlur(gray, (cfg.gaussian_ksize, cfg.gaussian_ksize), 0)
+    blurred = cv2.bilateralFilter(blurred, cfg.bilateral_d, cfg.bilateral_sigma_color, cfg.bilateral_sigma_space)
+    edges = cv2.Canny(blurred, cfg.canny_low, cfg.canny_high)
+    
+    # Erode the subject mask so Canny doesn't catch the outer boundary twice
     erode_size = max(5, cfg.silhouette_line_thickness * 2 + 3)
     if erode_size % 2 == 0:
         erode_size += 1
@@ -353,23 +240,16 @@ def build_interior_edges(rgb: np.ndarray, subject_mask: np.ndarray, cfg: Lineart
     eroded_mask = cv2.erode(subject_mask, kernel_erode, iterations=1)
     edges = cv2.bitwise_and(edges, eroded_mask)
 
-    # Filter contours: remove noise and lines too short to be embroidered
-    min_perimeter = cfg.min_contour_perimeter
-    min_stitch = getattr(cfg, 'min_embroidery_stitch_px', 15)
+    # Filter out short/noisy contours
     contours, _ = cv2.findContours(edges, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
     filtered = np.zeros_like(edges)
     for cnt in contours:
         perimeter = cv2.arcLength(cnt, False)
-        # Skip contours that are too short for embroidery
-        if perimeter < min_perimeter:
-            continue
-        # Additional embroidery feasibility check (absolute pixel length)
-        if min_stitch > 0 and perimeter < min_stitch:
-            continue
-        # Smooth contour to reduce Canny wobbles while preserving natural flow
-        eps = 0.0012 * perimeter
-        smooth = cv2.approxPolyDP(cnt, eps, False)
-        cv2.drawContours(filtered, [smooth], -1, 255, cfg.interior_line_thickness)
+        if perimeter > cfg.min_contour_perimeter:
+            # Simplify interior edges slightly to remove Canny wobbles while keeping natural flow
+            eps = 0.0012 * perimeter
+            smooth = cv2.approxPolyDP(cnt, eps, False)
+            cv2.drawContours(filtered, [smooth], -1, 255, cfg.interior_line_thickness)
 
     # Mild dilation for uniform, solid strokes
     kernel_dilate = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
@@ -379,12 +259,10 @@ 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, num_faces: int = 6):
-    global _LANDMARKER_CACHE, _LANDMARKER_NUM_FACES
-    # Re-create if num_faces changed
-    if _LANDMARKER_CACHE is None or _LANDMARKER_NUM_FACES != num_faces:
+def get_landmarker(model_path):
+    global _LANDMARKER_CACHE
+    if _LANDMARKER_CACHE is None:
         import mediapipe as mp
         from mediapipe.tasks import python
         from mediapipe.tasks.python import vision
@@ -394,22 +272,14 @@ def get_landmarker(model_path, num_faces: int = 6):
             base_options=base_options,
             output_face_blendshapes=False,
             output_facial_transformation_matrixes=False,
-            num_faces=num_faces
+            num_faces=1
         )
         _LANDMARKER_CACHE = vision.FaceLandmarker.create_from_options(options)
-        _LANDMARKER_NUM_FACES = num_faces
     return _LANDMARKER_CACHE
 
 
 def draw_eyebrows(rgb: np.ndarray, cfg: LineartConfig, faces: Optional[list] = None) -> np.ndarray:
-    """
-    Detect and draw eyebrows using MediaPipe FaceLandmarker.
-    Strategy:
-      Phase 1 — global detection on the full image (catches upright faces).
-      Phase 2 — per-face crops (catches tilted / partially occluded faces that
-                 the global pass misses).
-    Deduplication uses pixel-space distance to avoid double-drawing same face.
-    """
+    """Detect and draw eyebrows landmarks using MediaPipe Task API with hybrid global + crop detection."""
     h, w, _ = rgb.shape
     eyebrows_layer = np.zeros((h, w), dtype=np.uint8)
 
@@ -418,7 +288,7 @@ def draw_eyebrows(rgb: np.ndarray, cfg: LineartConfig, faces: Optional[list] = N
         from mediapipe.tasks import python
         from mediapipe.tasks.python import vision
 
-        # Resolve model path
+        # Determine model path
         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")
@@ -430,114 +300,86 @@ def draw_eyebrows(rgb: np.ndarray, cfg: LineartConfig, faces: Optional[list] = N
                 urllib.request.urlretrieve(model_url, model_path)
                 print("[AI] Download complete!")
 
-        # Landmark indices for full eyebrow arcs (upper + lower boundary)
-        LEFT_EYEBROW  = [70, 63, 105, 66, 107, 55, 65, 52, 53, 46]
+        LEFT_EYEBROW = [70, 63, 105, 66, 107, 55, 65, 52, 53, 46]
         RIGHT_EYEBROW = [336, 296, 334, 293, 300, 285, 295, 282, 283, 276]
+        
+        eyebrow_thickness = max(1, cfg.interior_line_thickness - 1)
+        processed_centers = []
 
-        eyebrow_thickness = getattr(cfg, 'eyebrow_thickness', cfg.interior_line_thickness)
-        eyebrow_dilate    = getattr(cfg, 'eyebrow_dilate', 1)
-
-        # Deduplication in pixel space (avoids normalised-coord mismatches)
-        drawn_centers_px: list = []  # list of (cx_px, cy_px)
-
-        def is_duplicate_px(cx_px: float, cy_px: float) -> bool:
-            min_dist = min(w, h) * 0.06          # 6% of shortest side
-            for (pcx, pcy) in drawn_centers_px:
-                if np.hypot(cx_px - pcx, cy_px - pcy) < min_dist:
+        def is_duplicate(cx, cy):
+            for (pcx, pcy) in processed_centers:
+                dist = np.sqrt((cx - pcx)**2 + (cy - pcy)**2)
+                if dist < 0.08:
                     return True
             return False
 
-        def draw_eyebrow_landmarks(face_lms, origin_x: int, origin_y: int,
-                                   scale_x: float, scale_y: float):
-            """Map landmark coords back to full-image pixels and draw."""
-            for indices in [LEFT_EYEBROW, RIGHT_EYEBROW]:
-                pts = []
-                for idx in indices:
-                    lm = face_lms[idx]
-                    px = int(origin_x + lm.x * scale_x)
-                    py = int(origin_y + lm.y * scale_y)
-                    pts.append([px, py])
-                pts_np = np.array(pts, np.int32).reshape((-1, 1, 2))
-                cv2.polylines(eyebrows_layer, [pts_np],
-                              isClosed=False, color=255,
-                              thickness=eyebrow_thickness,
-                              lineType=cv2.LINE_AA)
-
         if faces is None:
             faces = detect_faces(rgb, cfg)
 
         with _LANDMARKER_LOCK:
-            num_faces = getattr(cfg, 'mediapipe_num_faces', 6)
-            landmarker = get_landmarker(model_path, num_faces=num_faces)
-
-            # ── Phase 1: full-image detection ──────────────────────────────
+            landmarker = get_landmarker(model_path)
+            
+            # Phase 1: Global detection (upright / clear faces)
             mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=rgb)
             global_result = landmarker.detect(mp_image)
             if global_result.face_landmarks:
-                for face_lms in global_result.face_landmarks:
-                    # Face centre in pixel coords
-                    cx_px = np.mean([lm.x for lm in face_lms]) * w
-                    cy_px = np.mean([lm.y for lm in face_lms]) * h
-                    if not is_duplicate_px(cx_px, cy_px):
-                        drawn_centers_px.append((cx_px, cy_px))
-                        draw_eyebrow_landmarks(face_lms,
-                                               origin_x=0, origin_y=0,
-                                               scale_x=w, scale_y=h)
-
-            # ── Phase 2: per-face crop (tilted / small / occluded faces) ───
-            for (fx, fy, fw, fh) in faces:
-                # Generous 50% margin so MediaPipe sees face context
-                mx = int(fw * 0.50)
-                my = int(fh * 0.50)
-                x1 = max(0, fx - mx);  y1 = max(0, fy - my)
-                x2 = min(w, fx + fw + mx); y2 = min(h, fy + fh + my)
-                crop_w, crop_h = x2 - x1, y2 - y1
-                if crop_w < 20 or crop_h < 20:
+                for face_landmarks in global_result.face_landmarks:
+                    xs = [lm.x for lm in face_landmarks]
+                    ys = [lm.y for lm in face_landmarks]
+                    cx, cy = np.mean(xs), np.mean(ys)
+                    if not is_duplicate(cx, cy):
+                        processed_centers.append((cx, cy))
+                        for indices in [LEFT_EYEBROW, RIGHT_EYEBROW]:
+                            points = []
+                            for idx in indices:
+                                lm = face_landmarks[idx]
+                                points.append([int(lm.x * w), int(lm.y * h)])
+                            pts = np.array(points, np.int32).reshape((-1, 1, 2))
+                            cv2.polylines(eyebrows_layer, [pts], isClosed=False, color=255, thickness=eyebrow_thickness)
+
+            # Phase 2: OpenCV crops with 45% margin (for tilted / overlapping faces)
+            for i, (fx, fy, fw, fh) in enumerate(faces):
+                margin_x = int(fw * 0.45)
+                margin_y = int(fh * 0.45)
+                x1 = max(0, fx - margin_x)
+                y1 = max(0, fy - margin_y)
+                x2 = min(w, fx + fw + margin_x)
+                y2 = min(h, fy + fh + margin_y)
+
+                crop_w = x2 - x1
+                crop_h = y2 - y1
+                if crop_w <= 0 or crop_h <= 0:
                     continue
 
-                # Face centre in full-image pixels
-                face_cx_px = (x1 + x2) / 2
-                face_cy_px = (y1 + y2) / 2
-                if is_duplicate_px(face_cx_px, face_cy_px):
-                    continue  # already drawn from Phase 1
+                crop_cx = (x1 + crop_w / 2) / w
+                crop_cy = (y1 + crop_h / 2) / h
+                if is_duplicate(crop_cx, crop_cy):
+                    continue
 
                 crop = rgb[y1:y2, x1:x2]
-                # Upscale to at least 256px wide for better landmarker accuracy
-                target = max(512, crop_w, crop_h)
-                scale = target / max(crop_w, crop_h)
-                cw_scaled = int(crop_w * scale)
-                ch_scaled = int(crop_h * scale)
-                crop_resized = cv2.resize(crop, (cw_scaled, ch_scaled), interpolation=cv2.INTER_CUBIC)
-
+                crop_resized = cv2.resize(crop, (512, 512), interpolation=cv2.INTER_CUBIC)
                 crop_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=crop_resized)
                 crop_result = landmarker.detect(crop_image)
 
                 if crop_result.face_landmarks:
-                    face_lms = crop_result.face_landmarks[0]
-                    # Re-compute centre in full-image coords
-                    cx_px2 = x1 + np.mean([lm.x for lm in face_lms]) * crop_w
-                    cy_px2 = y1 + np.mean([lm.y for lm in face_lms]) * crop_h
-                    if is_duplicate_px(cx_px2, cy_px2):
-                        continue
-                    drawn_centers_px.append((cx_px2, cy_px2))
-                    # Scale back: landmark coords are relative to the scaled crop
-                    draw_eyebrow_landmarks(face_lms,
-                                           origin_x=x1, origin_y=y1,
-                                           scale_x=crop_w / cw_scaled * cw_scaled,
-                                           scale_y=crop_h / ch_scaled * ch_scaled)
-
-        print(f"[eyebrows] Drew eyebrows for {len(drawn_centers_px)} face(s)")
-
+                    face_landmarks = crop_result.face_landmarks[0]
+                    xs_global = [(x1 + lm.x * crop_w) / w for lm in face_landmarks]
+                    ys_global = [(y1 + lm.y * crop_h) / h for lm in face_landmarks]
+                    cx, cy = np.mean(xs_global), np.mean(ys_global)
+                    if not is_duplicate(cx, cy):
+                        processed_centers.append((cx, cy))
+                        for indices in [LEFT_EYEBROW, RIGHT_EYEBROW]:
+                            points = []
+                            for idx in indices:
+                                lm = face_landmarks[idx]
+                                gx = int(x1 + lm.x * crop_w)
+                                gy = int(y1 + lm.y * crop_h)
+                                points.append([gx, gy])
+                            pts = np.array(points, np.int32).reshape((-1, 1, 2))
+                            cv2.polylines(eyebrows_layer, [pts], isClosed=False, color=255, thickness=eyebrow_thickness)
     except Exception as e:
         print(f"[AI] Eyebrow extraction error or library missing: {e}")
 
-    # Dilate eyebrow strokes for bolder/more visible lines
-    if eyebrows_layer.any():
-        dil = getattr(cfg, 'eyebrow_dilate', 1)
-        if dil > 0:
-            kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
-            eyebrows_layer = cv2.dilate(eyebrows_layer, kernel, iterations=dil)
-
     return eyebrows_layer
 
 
@@ -677,4 +519,4 @@ def build_faceless_embroidery_assets(
 
     lineart = make_faceless_lineart(img, cfg)
     cutout = make_faceless_cutout(img)
-    return lineart, cutout
+    return lineart, cutout