Update faceless_processing.py

faceless_processing.py

@@ -23,8 +23,10 @@ except Exception as e:
     print(f"[AI] Failed to load rembg session: {e}")
     _SESSION_ISNET = None
 
+# Globally download cascades and models at startup if missing (runs on main container with internet access)
 def _download_assets_globally():
     try:
+        # 1. Cascades
         cascade_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "cascades")
         os.makedirs(cascade_dir, exist_ok=True)
         xml_urls = {
@@ -34,32 +36,33 @@ def _download_assets_globally():
         for name, url in xml_urls.items():
             path = os.path.join(cascade_dir, name)
             if not os.path.exists(path) or os.path.getsize(path) < 1000:
-                print(f"[AI] Downloading cascade {name} ...")
+                print(f"[AI] Downloading cascade {name} globally from OpenCV GitHub...")
                 try:
                     urllib.request.urlretrieve(url, path)
-                except Exception as e:
-                    print(f"[AI] Failed: {e}")
+                except Exception as dl_err:
+                    print(f"[AI] Failed to download {name} globally: {dl_err}")
 
+        # 2. MediaPipe Model
         model_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "models")
         os.makedirs(model_dir, exist_ok=True)
         model_path = os.path.join(model_dir, "face_landmarker.task")
         if not os.path.exists(model_path) or os.path.getsize(model_path) < 1000000:
-            print("[AI] Downloading face_landmarker.task ...")
+            print("[AI] Downloading face_landmarker.task globally...")
             try:
                 model_url = "https://storage.googleapis.com/mediapipe-models/face_landmarker/face_landmarker/float16/1/face_landmarker.task"
                 urllib.request.urlretrieve(model_url, model_path)
-                print("[AI] Download complete!")
-            except Exception as e:
-                print(f"[AI] Failed: {e}")
+                print("[AI] face_landmarker.task download complete!")
+            except Exception as dl_err:
+                print(f"[AI] Failed to download face_landmarker.task globally: {dl_err}")
     except Exception as e:
-        print(f"[AI] Asset download error: {e}")
+        print(f"[AI] Global asset download manager failed: {e}")
 
 _download_assets_globally()
 
 
 @dataclass
 class LineartConfig:
-    # Backward compatibility fields
+    # Backward compatibility fields (unused by OpenCV pipeline but required by callers)
     prompt: str = ""
     negative_prompt: str = ""
     stable_diffusion_model_id: str = ""
@@ -80,34 +83,30 @@ class LineartConfig:
     mask_smooth_threshold: int = 128
     min_silhouette_area: float = 200.0
 
-    silhouette_line_thickness: int = 1   # desenha fino, dilata depois
-
-    # --- PARÂMETROS AJUSTADOS PARA RETER DETALHES, MAS SEM EXCESSO ---
-    canny_low: int = 30
-    canny_high: int = 120
-    bilateral_d: int = 6                 # um pouco menos suavização
-    bilateral_sigma_color: int = 70      # intermediário
-    bilateral_sigma_space: int = 70
-    gaussian_ksize: int = 5              # menos blur
-    min_contour_perimeter: float = 20.0  # captura linhas mais curtas
-    interior_line_thickness: int = 1     # fino, dilata depois
-
-    # Detail pass ATIVADO, mas com filtros para não gerar muito ruído
-    enable_detail_pass: bool = True
-    detail_canny_low: int = 8
-    detail_canny_high: int = 35
-    detail_gaussian_ksize: int = 3
-    detail_min_perimeter: float = 12.0
-    detail_bilateral_d: int = 3
-    detail_bilateral_sigma: int = 35
-
-    min_embroidery_stitch_px: int = 15
-
-    # Auto-Canny sigma: 0.22 pega mais detalhes que 0.25
-    canny_sigma: float = 0.22
-
-    # Filtro de aspecto: 1.5 descarta apenas ruídos muito redondos
-    min_aspect_ratio: float = 1.5
+    # Silhouette outline — thicker for embroidery visibility
+    silhouette_line_thickness: int = 4     # bold outer contour
+
+    # Edge detection — single pass, balanced for body/clothing details
+    canny_low: int = 40                    # slight lower to recover chin/jaw line
+    canny_high: int = 130
+    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
 
     # Face detection
     face_scale_factor: float = 1.05
@@ -117,23 +116,31 @@ class LineartConfig:
     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.54
-    face_rx_ratio: float = 0.28
-    face_ry_ratio: float = 0.22
-    face_erase_blur: int = 18
-    face_erase_threshold: int = 45
+    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
 
-    detect_face_oval: bool = True
-    face_oval_thickness: int = 2
-
-    eyebrow_thickness: int = 3
-    eyebrow_dilate: int = 2
+    # Eyebrow drawing — thick and bold for embroidery visibility
+    eyebrow_thickness: int = 5           # thick stroke
+    eyebrow_dilate: int = 2              # extra dilation for bolder lines
 
 
 def _nms_faces(faces: list, iou_thresh: float) -> list:
+    """Non-maximum suppression to remove duplicate face detections."""
     if not faces:
         return []
     boxes = np.array(faces, dtype=float)
@@ -156,8 +163,10 @@ 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."""
     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 = []
@@ -181,6 +190,7 @@ 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,
@@ -191,18 +201,27 @@ def detect_faces(rgb: np.ndarray, cfg: LineartConfig) -> list:
                     if len(detected) > 0:
                         faces.extend(detected.tolist())
     except Exception as e:
-        print(f"[AI] Face detection failed: {e}")
+        print(f"[AI] Face detection failed or cascades unavailable: {e}")
 
+    # Remove detections in lower body (false positives)
     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)
+
+    # 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
 
 
 def build_subject_mask(rgb: np.ndarray, cfg: LineartConfig, alpha_channel: Optional[np.ndarray] = None) -> np.ndarray:
+    """Build subject mask. Uses alpha channel if available, otherwise thresholds white background."""
     if alpha_channel is not None:
+        # Use rembg/RGBA alpha directly — much more accurate than color threshold
         mask = (alpha_channel > 30).astype(np.uint8) * 255
     else:
         white_mask = np.all(rgb > cfg.white_bg_threshold, axis=2)
@@ -214,14 +233,21 @@ def build_subject_mask(rgb: np.ndarray, cfg: LineartConfig, alpha_channel: Optio
 
 
 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, :]
+    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=2.0, per=True, quiet=True)
+                         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)
@@ -231,44 +257,50 @@ def _smooth_contour_spline(cnt: np.ndarray, n_points: int = 400) -> Optional[np.
 
 
 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.
+    """
     mask = subject_mask.copy()
+
+    # 1. Large Gaussian blur + re-threshold to eliminate staircase jaggies on mask edge
     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)
         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)
     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)
+
     return silhouette
 
 
-def _auto_canny(image: np.ndarray, sigma: float = 0.33,
-                mask: Optional[np.ndarray] = None) -> np.ndarray:
-    if mask is not None and np.any(mask > 0):
-        subject_pixels = image[mask > 0]
-        v = float(np.median(subject_pixels))
-    else:
-        v = float(np.median(image))
-    lower = int(max(0, (1.0 - sigma) * v))
-    upper = int(min(255, (1.0 + sigma) * v))
-    return cv2.Canny(image, lower, upper)
 
 
 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
     mask = np.zeros((h, w), dtype=np.uint8)
     for (fx, fy, fw, fh) in faces:
@@ -282,72 +314,66 @@ 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.
+    """
     gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)
 
-    # Suavização moderada
-    blurred = cv2.bilateralFilter(gray, cfg.bilateral_d,
-                                   cfg.bilateral_sigma_color,
-                                   cfg.bilateral_sigma_space)
-    blurred = cv2.GaussianBlur(blurred, (cfg.gaussian_ksize, cfg.gaussian_ksize), 0)
-
-    erode_size = max(3, cfg.silhouette_line_thickness + 2)
-    if erode_size % 2 == 0:
-        erode_size += 1
-    kernel_erode = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (erode_size, erode_size))
-    eroded_mask = cv2.erode(subject_mask, kernel_erode, iterations=1)
-
-    # Canny principal
-    sigma = getattr(cfg, 'canny_sigma', 0.33)
-    if sigma > 0:
-        edges = _auto_canny(blurred, sigma, mask=eroded_mask)
-    else:
-        edges = cv2.Canny(blurred, cfg.canny_low, cfg.canny_high)
-
-    # Detail pass (ativado)
-    if getattr(cfg, 'enable_detail_pass', False):
-        detail_d = getattr(cfg, 'detail_bilateral_d', 3)
-        detail_sigma = getattr(cfg, 'detail_bilateral_sigma', 35)
-        detail_ksize = getattr(cfg, 'detail_gaussian_ksize', 3)
+    # --- 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', 8),
-            getattr(cfg, 'detail_canny_high', 35)
+            getattr(cfg, 'detail_canny_low', 15),
+            getattr(cfg, 'detail_canny_high', 55)
         )
-        edges = cv2.bitwise_or(edges, edges_detail)
 
+    # Combine both passes
+    edges = cv2.bitwise_or(edges_primary, edges_detail)
+
+    # Erode subject mask to avoid catching the outer boundary twice
+    erode_size = max(5, cfg.silhouette_line_thickness * 2 + 3)
+    if erode_size % 2 == 0:
+        erode_size += 1
+    kernel_erode = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (erode_size, erode_size))
+    eroded_mask = cv2.erode(subject_mask, kernel_erode, iterations=1)
     edges = cv2.bitwise_and(edges, eroded_mask)
 
-    # Filtrar contornos
+    # 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)
-    min_aspect = getattr(cfg, 'min_aspect_ratio', 1.5)
-
     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
-        if min_aspect > 0:
-            x, y, bw, bh = cv2.boundingRect(cnt)
-            long_side = max(bw, bh)
-            short_side = min(bw, bh) + 1
-            if long_side / short_side < min_aspect:
-                continue
-
-        eps = 0.005 * perimeter
+        # 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)
 
-    # Dilatação final: apenas 1 iteração para não perder detalhes
+    # Mild dilation for uniform, solid strokes
     kernel_dilate = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
     filtered = cv2.dilate(filtered, kernel_dilate, iterations=1)
-
     return filtered
 
 
@@ -357,6 +383,7 @@ _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:
         import mediapipe as mp
         from mediapipe.tasks import python
@@ -375,6 +402,14 @@ def get_landmarker(model_path, num_faces: int = 6):
 
 
 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.
+    """
     h, w, _ = rgb.shape
     eyebrows_layer = np.zeros((h, w), dtype=np.uint8)
 
@@ -383,6 +418,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
         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")
@@ -394,16 +430,18 @@ 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]
         RIGHT_EYEBROW = [336, 296, 334, 293, 300, 285, 295, 282, 283, 276]
 
-        eyebrow_thickness = getattr(cfg, 'eyebrow_thickness', 3)
-        eyebrow_dilate    = getattr(cfg, 'eyebrow_dilate', 2)
+        eyebrow_thickness = getattr(cfg, 'eyebrow_thickness', cfg.interior_line_thickness)
+        eyebrow_dilate    = getattr(cfg, 'eyebrow_dilate', 1)
 
-        drawn_centers_px: list = []
+        # 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
+            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:
                     return True
@@ -411,6 +449,7 @@ def draw_eyebrows(rgb: np.ndarray, cfg: LineartConfig, faces: Optional[list] = N
 
         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:
@@ -431,17 +470,23 @@ def draw_eyebrows(rgb: np.ndarray, cfg: LineartConfig, faces: Optional[list] = N
             num_faces = getattr(cfg, 'mediapipe_num_faces', 6)
             landmarker = get_landmarker(model_path, num_faces=num_faces)
 
+            # ── Phase 1: full-image detection ──────────────────────────────
             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, 0, 0, w, h)
+                        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)
@@ -449,25 +494,33 @@ def draw_eyebrows(rgb: np.ndarray, cfg: LineartConfig, faces: Optional[list] = N
                 crop_w, crop_h = x2 - x1, y2 - y1
                 if crop_w < 20 or crop_h < 20:
                     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
+                    continue  # already drawn from Phase 1
+
                 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_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,
@@ -476,10 +529,11 @@ def draw_eyebrows(rgb: np.ndarray, cfg: LineartConfig, faces: Optional[list] = N
         print(f"[eyebrows] Drew eyebrows for {len(drawn_centers_px)} face(s)")
 
     except Exception as e:
-        print(f"[AI] Eyebrow extraction error: {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', 2)
+        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)
@@ -487,117 +541,22 @@ def draw_eyebrows(rgb: np.ndarray, cfg: LineartConfig, faces: Optional[list] = N
     return eyebrows_layer
 
 
-def draw_face_oval(rgb: np.ndarray, cfg: 'LineartConfig', faces: Optional[list] = None) -> np.ndarray:
-    h, w, _ = rgb.shape
-    oval_layer = np.zeros((h, w), dtype=np.uint8)
-
-    FACE_LOWER_CONTOUR = [
-        454, 323, 361, 288, 397, 365, 379, 378, 400, 377,
-        152,
-        148, 176, 149, 150, 136, 172, 58, 132, 93, 234
-    ]
-
-    thickness = getattr(cfg, 'face_oval_thickness', 2)
-
-    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 not os.path.exists(model_path) or os.path.getsize(model_path) < 1000000:
-            print("[face_oval] face_landmarker.task not found, skipping oval drawing")
-            return oval_layer
-
-        drawn_centers_px: list = []
-
-        def is_duplicate_px(cx_px: float, cy_px: float) -> bool:
-            min_dist = min(w, h) * 0.06
-            return any(np.hypot(cx_px - pcx, cy_px - pcy) < min_dist
-                       for (pcx, pcy) in drawn_centers_px)
-
-        def draw_oval_from_landmarks(face_lms, origin_x: int, origin_y: int,
-                                      scale_x: float, scale_y: float):
-            pts = []
-            for idx in FACE_LOWER_CONTOUR:
-                if idx >= len(face_lms):
-                    continue
-                lm = face_lms[idx]
-                px = int(origin_x + lm.x * scale_x)
-                py = int(origin_y + lm.y * scale_y)
-                pts.append([px, py])
-            if len(pts) < 4:
-                return
-            pts_np = np.array(pts, np.int32).reshape((-1, 1, 2))
-            cv2.polylines(oval_layer, [pts_np], isClosed=False,
-                          color=255, thickness=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)
-
-            mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=rgb)
-            result = landmarker.detect(mp_image)
-            if result.face_landmarks:
-                for face_lms in result.face_landmarks:
-                    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_oval_from_landmarks(face_lms, 0, 0, w, h)
-
-            for (fx, fy, fw, fh) in faces:
-                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:
-                    continue
-                face_cx_px = (x1 + x2) / 2
-                face_cy_px = (y1 + y2) / 2
-                if is_duplicate_px(face_cx_px, face_cy_px):
-                    continue
-                crop = rgb[y1:y2, x1:x2]
-                target = max(512, crop_w, crop_h)
-                scale = target / max(crop_w, crop_h)
-                cw_s = int(crop_w * scale); ch_s = int(crop_h * scale)
-                crop_r = cv2.resize(crop, (cw_s, ch_s), interpolation=cv2.INTER_CUBIC)
-                crop_img = mp.Image(image_format=mp.ImageFormat.SRGB, data=crop_r)
-                crop_res = landmarker.detect(crop_img)
-                if crop_res.face_landmarks:
-                    face_lms = crop_res.face_landmarks[0]
-                    cx2 = x1 + np.mean([lm.x for lm in face_lms]) * crop_w
-                    cy2 = y1 + np.mean([lm.y for lm in face_lms]) * crop_h
-                    if is_duplicate_px(cx2, cy2):
-                        continue
-                    drawn_centers_px.append((cx2, cy2))
-                    draw_oval_from_landmarks(face_lms, x1, y1, crop_w, crop_h)
-
-        print(f"[face_oval] Drew face oval for {len(drawn_centers_px)} face(s)")
-
-    except Exception as e:
-        print(f"[face_oval] Error: {e}")
-
-    if oval_layer.any():
-        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
-        oval_layer = cv2.dilate(oval_layer, kernel, iterations=2)
 
-    return oval_layer
-
-
-def make_faceless_lineart(img: Image.Image, cfg: LineartConfig = None) -> Image.Image:
+def make_faceless_lineart(
+    img: Image.Image,
+    cfg: LineartConfig = None
+) -> Image.Image:
+    """
+    Generate faceless lineart transparent image from a photo.
+    """
     cfg = cfg or LineartConfig()
     
+    # Preserve alpha channel if image already has a transparent background (e.g. from rembg)
     alpha_channel: Optional[np.ndarray] = None
     if img.mode in ("RGBA", "LA") or (img.mode == "P" and "transparency" in img.info):
         rgba_img = img.convert("RGBA")
         alpha_np = np.array(rgba_img)[:, :, 3]
+        # Only use alpha mask if it contains meaningful transparency
         if np.any(alpha_np < 200):
             alpha_channel = alpha_np
         background = Image.new("RGBA", img.size, (255, 255, 255, 255))
@@ -610,27 +569,32 @@ def make_faceless_lineart(img: Image.Image, cfg: LineartConfig = None) -> Image.
     rgb = img_np[:, :, :3]
     h, w = rgb.shape[:2]
 
+    # 1. Subject mask — use alpha if available, else color threshold
     subject_mask = build_subject_mask(rgb, cfg, alpha_channel)
+
+    # 2. Detect faces
     faces = detect_faces(rgb, cfg)
     print(f"[lineart] Detected {len(faces)} face(s)")
 
+    # 3. Silhouette outline
     silhouette = build_silhouette(subject_mask, cfg)
+
+    # 4. Interior structural edges
     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)
     interior_clean = cv2.bitwise_and(interior, cv2.bitwise_not(face_erase))
 
+    # 6. Combine
     final_lines = cv2.add(silhouette, interior_clean)
 
+    # 6.5. Optional eyebrow detection overlay
     if cfg.detect_eyebrows:
         eyebrows = draw_eyebrows(rgb, cfg, faces=faces)
         final_lines = cv2.add(final_lines, eyebrows)
 
-    if getattr(cfg, 'detect_face_oval', True):
-        face_oval = draw_face_oval(rgb, cfg, faces=faces)
-        final_lines = cv2.add(final_lines, face_oval)
-
-    # Remove bordas
+    # Avoid drawing rectangular boxes/borders at the image edges
     border_erase_width = max(cfg.silhouette_line_thickness, cfg.interior_line_thickness) + 2
     if border_erase_width > 0:
         final_lines[0:border_erase_width, :] = 0
@@ -638,9 +602,14 @@ def make_faceless_lineart(img: Image.Image, cfg: LineartConfig = None) -> Image.
         final_lines[:, 0:border_erase_width] = 0
         final_lines[:, -border_erase_width:] = 0
 
+
+    # 7. Build output image
     alpha = Image.fromarray(final_lines)
-    transparent = Image.new("RGBA", img.size, (0, 0, 0, 0))
+    size = img.size
+
+    transparent = Image.new("RGBA", size, (0, 0, 0, 0))
     transparent.putalpha(alpha)
+
     return transparent
 
 
@@ -673,13 +642,16 @@ def remove_background_subject(img: Image.Image) -> Image.Image:
         rgba = img.convert("RGBA")
         if _has_real_transparency(rgba):
             return rgba
+
         if _SESSION_ISNET is None:
             return rgba
+
         mask = remove(rgba, session=_SESSION_ISNET, only_mask=True)
         alpha = mask.convert("L") if isinstance(mask, Image.Image) else Image.open(io.BytesIO(mask)).convert("L")
         if alpha.size != rgba.size:
             alpha = alpha.resize(rgba.size, Image.LANCZOS)
         alpha = alpha.filter(ImageFilter.GaussianBlur(radius=0.8))
+
         r, g, b, _a = rgba.split()
         return Image.merge("RGBA", (r, g, b, alpha))
     except Exception as exc: