feat: improve line art quality - dual-pass Canny, CLAHE face detect, up to 6 faces/eyebrows, embroidery stitch filter

faceless_processing.py

@@ -68,9 +68,8 @@ class LineartConfig:
     transparency_threshold: float = 0.03
     detect_eyebrows: bool = True
 
-
     # Subject mask
-    white_bg_threshold: int = 245          # pixels above this = background (raised to avoid erasing light subjects)
+    white_bg_threshold: int = 245          # pixels above this = background
     mask_close_iterations: int = 4
     mask_open_iterations: int = 1
     mask_smooth_ksize: int = 5             # GaussianBlur kernel before silhouette (must be odd; 0 = disabled)
@@ -78,32 +77,50 @@ 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 = 3     # outer contour stroke width (px)
 
-    # Edge detection
-    canny_low: int = 40
-    canny_high: int = 110
+    # Edge detection — primary pass (prominent structural lines)
+    canny_low: int = 35
+    canny_high: int = 100
     bilateral_d: int = 11
-    bilateral_sigma_color: int = 80
-    bilateral_sigma_space: int = 80
+    bilateral_sigma_color: int = 90
+    bilateral_sigma_space: int = 90
     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)
+    min_contour_perimeter: float = 40.0    # primary minimum contour length (lowered to catch more detail)
+    interior_line_thickness: int = 3       # thickness of interior detail lines
+
+    # Edge detection — secondary detail pass (fine features, lower threshold)
+    enable_detail_pass: bool = True        # enable secondary Canny pass for fine details
+    detail_canny_low: int = 15             # more sensitive lower threshold
+    detail_canny_high: int = 55            # more sensitive upper threshold
+    detail_gaussian_ksize: int = 5         # less blur to preserve fine lines
+    detail_min_perimeter: float = 30.0     # shorter minimum contour for fine details
+    detail_bilateral_d: int = 7            # smaller filter for detail preservation
+    detail_bilateral_sigma: int = 60
+
+    # Embroidery minimum stitch feasibility
+    # Lines shorter than this (in pixels relative to image width) are discarded as too thin to stitch
+    # Set to 0 to disable. Recommended: ~15px on a 512px-wide image
+    min_embroidery_stitch_px: int = 15
 
     # Face detection
     face_scale_factor: float = 1.05
     face_min_neighbors: int = 3
-    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_min_size: Tuple[int, int] = (20, 20)  # lowered to detect smaller/tilted faces
+    face_max_y_ratio: float = 0.65         # ignore faces below 65% image height (slightly higher to catch low angles)
+    face_nms_iou_thresh: float = 0.35      # more aggressive dedup to handle crowded images
+    face_max_count: int = 6               # maximum number of faces to process
 
     # 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_rx_ratio: float = 0.35
+    face_ry_ratio: float = 0.38
     face_erase_blur: int = 8
-    face_erase_threshold: int = 130        # higher = sharper face mask edge, less spill
+    face_erase_threshold: int = 130
+
+    # MediaPipe face landmarker: max faces (up to 6 supported)
+    mediapipe_num_faces: int = 6
 
 
 def _nms_faces(faces: list, iou_thresh: float) -> list:
@@ -130,13 +147,15 @@ 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."""
+    """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 = []
 
     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')
@@ -147,7 +166,6 @@ 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'),
@@ -156,14 +174,16 @@ def detect_faces(rgb: np.ndarray, cfg: LineartConfig) -> list:
             
         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())
+                # 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())
     except Exception as e:
         print(f"[AI] Face detection failed or cascades unavailable: {e}")
 
@@ -172,6 +192,13 @@ 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
 
 
@@ -226,13 +253,38 @@ 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 Canny, filtering noise."""
+    """
+    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)
-    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
+
+    # --- 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
     erode_size = max(5, cfg.silhouette_line_thickness * 2 + 3)
     if erode_size % 2 == 0:
         erode_size += 1
@@ -240,16 +292,23 @@ 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 out short/noisy contours
+    # 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)
     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)
-        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)
+        # 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)
 
     # Mild dilation for uniform, solid strokes
     kernel_dilate = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
@@ -259,10 +318,12 @@ 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 = 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
         from mediapipe.tasks.python import vision
@@ -272,9 +333,10 @@ 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
         )
         _LANDMARKER_CACHE = vision.FaceLandmarker.create_from_options(options)
+        _LANDMARKER_NUM_FACES = num_faces
     return _LANDMARKER_CACHE
 
 
@@ -317,7 +379,8 @@ def draw_eyebrows(rgb: np.ndarray, cfg: LineartConfig, faces: Optional[list] = N
             faces = detect_faces(rgb, cfg)
 
         with _LANDMARKER_LOCK:
-            landmarker = get_landmarker(model_path)
+            num_faces = getattr(cfg, 'mediapipe_num_faces', 6)
+            landmarker = get_landmarker(model_path, num_faces=num_faces)
             
             # Phase 1: Global detection (upright / clear faces)
             mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=rgb)
@@ -354,9 +417,7 @@ def draw_eyebrows(rgb: np.ndarray, cfg: LineartConfig, faces: Optional[list] = N
                 crop_cx = (x1 + crop_w / 2) / w
                 crop_cy = (y1 + crop_h / 2) / h
                 if is_duplicate(crop_cx, crop_cy):
-                    continue    
-
-
+                    continue
 
                 crop = rgb[y1:y2, x1:x2]
                 crop_resized = cv2.resize(crop, (512, 512), interpolation=cv2.INTER_CUBIC)