Update faceless_processing.py

faceless_processing.py

@@ -202,6 +202,12 @@ class LineartConfig:
     # AJUSTE FINO: Remove 50% do topo do oval (desenha apenas a mandíbula inferior)
     face_oval_skip_top_ratio: float = 0.50 
 
+    # --- Parâmetros de limpeza e bordabilidade ---
+    min_line_distance: int = 8
+    line_overlap_threshold: float = 0.35
+    custom_tuned_for_embroidery: bool = False
+
+
 
 def _nms_faces(faces: list, iou_thresh: float) -> list:
     if not faces:
@@ -501,6 +507,54 @@ def _line_strength_from_detector(pil_lineart: Image.Image, target_hw: Tuple[int,
     return strength.astype(np.uint8)
 
 
+def _filter_dense_contours(contours: list, min_dist_px: int, overlap_threshold: float, min_perimeter: float, thickness: int, shape: Tuple[int, int], min_area: float = 0.0) -> np.ndarray:
+    """
+    Filters contours to ensure that no two lines are too close to each other,
+    which makes the lineart highly suitable for embroidery (prevents dense/overlapping stitches).
+    """
+    sorted_cnts = sorted(contours, key=lambda c: cv2.arcLength(c, False), reverse=True)
+    
+    filtered_mask = np.zeros(shape, dtype=np.uint8)
+    dilated_mask = np.zeros(shape, dtype=np.uint8)
+    
+    if min_dist_px > 0:
+        kernel_dist = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (min_dist_px * 2 + 1, min_dist_px * 2 + 1))
+    else:
+        kernel_dist = None
+
+    for cnt in sorted_cnts:
+        perimeter = cv2.arcLength(cnt, False)
+        # contourArea requires at least 3 points
+        area = cv2.contourArea(cnt) if len(cnt) >= 3 else 0.0
+        
+        if perimeter < min_perimeter:
+            continue
+        if min_area > 0 and area < min_area:
+            continue
+            
+        cnt_mask = np.zeros(shape, dtype=np.uint8)
+        cv2.drawContours(cnt_mask, [cnt], -1, 255, thickness)
+        
+        if kernel_dist is not None and np.any(dilated_mask > 0):
+            intersection = cv2.bitwise_and(cnt_mask, dilated_mask)
+            num_intersect = cv2.countNonZero(intersection)
+            num_total = cv2.countNonZero(cnt_mask)
+            
+            if num_total > 0 and (num_intersect / num_total) > overlap_threshold:
+                # Too close to existing lines
+                continue
+                
+        cv2.drawContours(filtered_mask, [cnt], -1, 255, thickness)
+        
+        if kernel_dist is not None:
+            cnt_draw = np.zeros(shape, dtype=np.uint8)
+            cv2.drawContours(cnt_draw, [cnt], -1, 255, thickness)
+            cnt_dilated = cv2.dilate(cnt_draw, kernel_dist, iterations=1)
+            dilated_mask = cv2.bitwise_or(dilated_mask, cnt_dilated)
+            
+    return filtered_mask
+
+
 def build_interior_edges(rgb: np.ndarray, subject_mask: np.ndarray, cfg: LineartConfig) -> np.ndarray:
     h, w = rgb.shape[:2]
     detector = get_lineart_detector()
@@ -534,19 +588,19 @@ def build_interior_edges(rgb: np.ndarray, subject_mask: np.ndarray, cfg: Lineart
                 edges = cv2.morphologyEx(edges, cv2.MORPH_OPEN, kernel_clean, iterations=1)
 
             contours, _ = cv2.findContours(edges, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
-            filtered = np.zeros_like(edges)
-            
             min_area = getattr(cfg, 'lineart_min_area', 40.0)
+            min_dist = getattr(cfg, 'min_line_distance', 8)
+            overlap_thresh = getattr(cfg, 'line_overlap_threshold', 0.35)
             
-            for cnt in contours:
-                perimeter = cv2.arcLength(cnt, False)
-                area = cv2.contourArea(cnt)
-                
-                # BARREIRA EXTREMA: Elimina pontos isolados e traços curtos
-                if perimeter < cfg.lineart_min_perimeter or area < min_area:
-                    continue
-                    
-                cv2.drawContours(filtered, [cnt], -1, 255, cfg.interior_line_thickness)
+            filtered = _filter_dense_contours(
+                contours=contours,
+                min_dist_px=min_dist,
+                overlap_threshold=overlap_thresh,
+                min_perimeter=cfg.lineart_min_perimeter,
+                thickness=cfg.interior_line_thickness,
+                shape=edges.shape,
+                min_area=min_area
+            )
 
             kernel_dilate = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
             filtered = cv2.dilate(filtered, kernel_dilate, iterations=1)
@@ -575,19 +629,34 @@ def _build_interior_edges_canny(rgb: np.ndarray, subject_mask: np.ndarray, cfg:
     edges = cv2.bitwise_and(edges, eroded_mask)
 
     contours, _ = cv2.findContours(edges, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
-    filtered = np.zeros_like(edges)
+    
+    smoothed_contours = []
     for cnt in contours:
         perimeter = cv2.arcLength(cnt, False)
         if perimeter < cfg.min_contour_perimeter:
             continue
         eps = 0.0012 * perimeter
         smooth = cv2.approxPolyDP(cnt, eps, False)
-        cv2.drawContours(filtered, [smooth], -1, 255, cfg.interior_line_thickness)
+        smoothed_contours.append(smooth)
+        
+    min_dist = getattr(cfg, 'min_line_distance', 8)
+    overlap_thresh = getattr(cfg, 'line_overlap_threshold', 0.35)
+    
+    filtered = _filter_dense_contours(
+        contours=smoothed_contours,
+        min_dist_px=min_dist,
+        overlap_threshold=overlap_thresh,
+        min_perimeter=cfg.min_contour_perimeter,
+        thickness=cfg.interior_line_thickness,
+        shape=edges.shape
+    )
+    
     kernel_dilate = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
     filtered = cv2.dilate(filtered, kernel_dilate, iterations=1)
     return filtered
 
 
+
 _LANDMARKER_LOCK = threading.Lock()
 _LANDMARKER_CACHE = None
 _LANDMARKER_NUM_FACES = None
@@ -748,6 +817,7 @@ def draw_eyebrows(rgb: np.ndarray, cfg: LineartConfig, faces: Optional[list] = N
     return eyebrows_layer
 
 
+
 def make_faceless_lineart(img: Image.Image, cfg: LineartConfig = None) -> Image.Image:
     cfg = cfg or LineartConfig()
 
@@ -781,6 +851,38 @@ def make_faceless_lineart(img: Image.Image, cfg: LineartConfig = None) -> Image.
     faces = detect_faces(rgb, cfg)
     print(f"[lineart] Detected {len(faces)} face(s)")
 
+    # Se NÃO detectou rosto, entra em modo de contingência ("cartoon-clean" automático)
+    is_cartoon_fallback = getattr(cfg, 'is_cartoon_fallback', False) or (len(faces) == 0)
+    
+    if is_cartoon_fallback and not getattr(cfg, 'custom_tuned_for_embroidery', False):
+        print("[lineart] No face detected or cartoon fallback active. Tuning parameters for clean structured lineart.")
+        cfg.erase_faces = False
+        cfg.detect_eyebrows = False
+        cfg.erase_borders = False
+        
+        # Parâmetros equilibrados para traços nítidos e bordáveis
+        cfg.lineart_threshold = 95
+        cfg.lineart_min_perimeter = 45.0
+        cfg.lineart_min_area = 20.0
+        cfg.lineart_morph_open = True
+        
+        cfg.canny_low = 50
+        cfg.canny_high = 110
+        cfg.min_contour_perimeter = 35.0
+        
+        # Suavização para remover pelos sem perder formas principais
+        cfg.bilateral_d = 7
+        cfg.bilateral_sigma_color = 90
+        cfg.bilateral_sigma_space = 90
+        cfg.gaussian_ksize = 5
+        
+        # Filtro de proximidade entre linhas
+        cfg.min_line_distance = 8
+        cfg.line_overlap_threshold = 0.35
+        
+        cfg.custom_tuned_for_embroidery = True
+
+    subject_mask = build_subject_mask(rgb, cfg, alpha_channel)
     silhouette = build_silhouette(subject_mask, cfg)
     interior = build_interior_edges(rgb, subject_mask, cfg)