Update faceless_processing.py

faceless_processing.py

@@ -34,8 +34,6 @@ _LINEART_DETECTOR = None
 _LINEART_AVAILABLE = True
 
 
-
-
 def get_lineart_detector():
     """
     Lazy-load the controlnet_aux LineartDetector (informative-drawings model
@@ -105,7 +103,6 @@ _download_assets_globally()
 get_lineart_detector()
 
 
-
 @dataclass
 class LineartConfig:
     # Backward compatibility fields
@@ -137,20 +134,15 @@ class LineartConfig:
     lineart_image_resolution: int = 1024
     lineart_coarse: bool = True
     
-    # AUMENTADO: Força a ignorar dobras de roupa e focar só na estrutura
-    lineart_threshold: int = 100
+    # AUMENTADO: Força bruta para ignorar detalhes fracos
+    lineart_threshold: int = 120
     
-    # AJUSTE DE CABELO E CORPO: Diminuído para capturar fios e dobras de roupa.
-    lineart_min_perimeter: float = 70.0
+    # AUMENTADO: Faca implacável para traços curtos
+    lineart_min_perimeter: float = 90.0
     
-    # Diminuído para manter os traços mais próximos da borda.
     interior_erode_size: int = 1
-    
-    # AJUSTE GERAL: Afinado para traços internos mais delicados.
     interior_line_thickness: int = 2
 
-
-
     # ---- Canny fallback parametros ----
     canny_low: int = 35
     canny_high: int = 75
@@ -188,17 +180,15 @@ class LineartConfig:
     mediapipe_num_faces: int = 6
 
     # --- AJUSTE DE SOBRANCELHA ---
-    # Reduzido drasticamente para um traço fino e sutil.
     eyebrow_thickness: int = 2 
-    # Zerado (era 1). Isso remove o "borrão" que deixava a sobrancelha grossa demais.
     eyebrow_dilate: int = 0 
 
     # Face shape
     draw_face_oval: bool = True
     face_oval_thickness: int = 1
-    face_oval_skip_top_ratio: float = 0.50
-
-
+    
+    # AJUSTE FINO: Remove 45% do topo do oval (o que causava aquele erro bizarro)
+    face_oval_skip_top_ratio: float = 0.45 
 
 
 def _nms_faces(faces: list, iou_thresh: float) -> list:
@@ -264,7 +254,6 @@ def detect_faces(rgb: np.ndarray, cfg: LineartConfig) -> list:
         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:
     if alpha_channel is not None:
@@ -292,8 +281,6 @@ def _smooth_contour_spline(cnt: np.ndarray, n_points: int = 400) -> Optional[np.
         spline_pts = np.stack([x_new, y_new], axis=1).astype(np.int32)
         return spline_pts.reshape((-1, 1, 2))
     except Exception:
-
-
         return None
 
 
@@ -338,32 +325,20 @@ def build_face_erase_mask(faces: list, shape: Tuple[int, int], cfg: LineartConfi
 
 
 def _line_strength_from_detector(pil_lineart: Image.Image, target_hw: Tuple[int, int]) -> np.ndarray:
-    """
-    Convert the detector output into a polarity-normalised "line strength" map
-    where lines = bright (255) on a black (0) background, resized to target.
-    Handles either polarity (black-on-white or white-on-black).
-    """
     h, w = target_hw
     gray = np.array(pil_lineart.convert("L"))
-    # Determine background from the image corners
     corners = [gray[0, 0], gray[0, -1], gray[-1, 0], gray[-1, -1]]
     bg = float(np.median(corners))
     if bg > 127:
-        strength = 255 - gray          # dark lines on light bg -> invert
+        strength = 255 - gray
     else:
-        strength = gray                # already light lines on dark bg
+        strength = gray
     if strength.shape[:2] != (h, w):
         strength = cv2.resize(strength, (w, h), interpolation=cv2.INTER_LINEAR)
     return strength.astype(np.uint8)
 
 
-
 def build_interior_edges(rgb: np.ndarray, subject_mask: np.ndarray, cfg: LineartConfig) -> np.ndarray:
-    """
-    Detect structural lines (clothing folds, lapels, collars, cuffs, hair) using
-    the neural LineartDetector. Produces continuous, illustrator-style strokes.
-    Falls back to the legacy Canny pipeline if controlnet_aux is unavailable.
-    """
     h, w = rgb.shape[:2]
     detector = get_lineart_detector()
 
@@ -379,12 +354,8 @@ def build_interior_edges(rgb: np.ndarray, subject_mask: np.ndarray, cfg: Lineart
                 )
             strength = _line_strength_from_detector(pil_out, (h, w))
 
-            # Threshold to a binary line map
             _, edges = cv2.threshold(strength, cfg.lineart_threshold, 255, cv2.THRESH_BINARY)
 
-            # Keep lines only inside the subject. Use a SMALL erosion so that
-            # face-shape, hairline and jaw lines (which sit close to the
-            # silhouette) are preserved instead of being eaten away.
             erode_size = getattr(cfg, 'interior_erode_size', 3)
             erode_size = max(1, erode_size)
             if erode_size % 2 == 0:
@@ -393,24 +364,32 @@ 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)
 
-            # Remove speckle: drop tiny contours
+            # Aspirador de Sujeiras
+            kernel_clean = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
+            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)
             for cnt in contours:
-                if cv2.arcLength(cnt, False) < cfg.lineart_min_perimeter:
+                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 < 40.0:
                     continue
+                    
                 cv2.drawContours(filtered, [cnt], -1, 255, cfg.interior_line_thickness)
 
-            # Gentle dilation for solid, embroiderable strokes
-            ernel_dilate = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
+            kernel_dilate = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
             filtered = cv2.dilate(filtered, kernel_dilate, iterations=1)
             filtered = cv2.GaussianBlur(filtered, (3, 3), 0)
-            filtered = cv2.threshold(filtered, 127, 255, cv2.THRESH_BINARY)
+            
+            _, filtered = cv2.threshold(filtered, 127, 255, cv2.THRESH_BINARY)
+            
             return filtered
         except Exception as e:
             print(f"[AI] Neural lineart failed, falling back to Canny: {e}")
 
-    # ---------------- Legacy Canny fallback ----------------
     return _build_interior_edges_canny(rgb, subject_mask, cfg)
 
 
@@ -457,8 +436,6 @@ def get_landmarker(model_path, num_faces: int = 6):
             output_face_blendshapes=False,
             output_facial_transformation_matrixes=False,
             num_faces=num_faces,
-            # Lower confidence thresholds so smiling / tilted / smaller faces
-            # are still detected and their eyebrows get drawn.
             min_face_detection_confidence=0.2,
             min_face_presence_confidence=0.2,
             min_tracking_confidence=0.2,
@@ -486,7 +463,6 @@ def draw_eyebrows(rgb: np.ndarray, cfg: LineartConfig, faces: Optional[list] = N
 
         LEFT_EYEBROW  = [70, 63, 105, 66, 107, 55, 65, 52, 53, 46]
         RIGHT_EYEBROW = [336, 296, 334, 293, 300, 285, 295, 282, 283, 276]
-        # MediaPipe face oval (head/jaw outline), ordered around the perimeter.
         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]
@@ -505,7 +481,6 @@ def draw_eyebrows(rgb: np.ndarray, cfg: LineartConfig, faces: Optional[list] = N
             return False
 
         def draw_eyebrow_landmarks(face_lms, origin_x, origin_y, scale_x, scale_y):
-            # Eyebrows
             for indices in [LEFT_EYEBROW, RIGHT_EYEBROW]:
                 pts = []
                 for idx in indices:
@@ -517,7 +492,6 @@ def draw_eyebrows(rgb: np.ndarray, cfg: LineartConfig, faces: Optional[list] = N
                 cv2.polylines(eyebrows_layer, [pts_np], isClosed=False, color=255,
                               thickness=eyebrow_thickness, lineType=cv2.LINE_AA)
 
-            # Face oval (head / jaw outline) — gives the "formato do rosto"
             if draw_oval:
                 oval_pts = []
                 for idx in FACE_OVAL:
@@ -527,16 +501,12 @@ def draw_eyebrows(rgb: np.ndarray, cfg: LineartConfig, faces: Optional[list] = N
                     oval_pts.append([px, py])
                 oval_np = np.array(oval_pts, np.int32)
                 if len(oval_np) >= 4:
-                    # Optionally drop the top (forehead) points so the outline
-                    # doesn't cut a hard line across the hair.
                     if oval_skip_top > 0:
                         y_min = oval_np[:, 1].min()
                         y_max = oval_np[:, 1].max()
                         cutoff = y_min + (y_max - y_min) * oval_skip_top
                         kept = oval_np[oval_np[:, 1] >= cutoff]
                         if len(kept) >= 4:
-                            # open arc (jaw + cheeks), not closed, to leave the
-                            # crown of the head to the hair/silhouette lines
                             arc = kept.reshape((-1, 1, 2))
                             cv2.polylines(eyebrows_layer, [arc], isClosed=False,
                                           color=255, thickness=oval_thickness,
@@ -620,8 +590,6 @@ def make_faceless_lineart(img: Image.Image, cfg: LineartConfig = None) -> Image.
     rgb = img_np[:, :, :3]
     h, w = rgb.shape[:2]
 
-    # If no alpha was provided, derive a subject mask with rembg for a clean
-    # silhouette and to confine interior lines to the subject.
     if alpha_channel is None and _SESSION_ISNET is not None:
         try:
             cut = remove(Image.fromarray(rgb).convert("RGBA"), session=_SESSION_ISNET, only_mask=True)
@@ -685,9 +653,6 @@ def _has_real_transparency(img: Image.Image) -> bool:
     return total > 0 and (visible / total) >= 0.03
 
 
-
-
-
 def remove_background_subject(img: Image.Image) -> Image.Image:
     try:
         rgba = img.convert("RGBA")
@@ -711,7 +676,6 @@ def make_faceless_cutout(img: Image.Image) -> Image.Image:
     return remove_background_subject(img)
 
 
-
 def build_faceless_embroidery_assets(img: Image.Image, cfg: Optional[LineartConfig] = None, **kwargs) -> Tuple[Image.Image, Image.Image]:
     if cfg is None:
         cfg = LineartConfig()
@@ -721,4 +685,4 @@ def build_faceless_embroidery_assets(img: Image.Image, cfg: Optional[LineartConf
         cfg.negative_prompt = kwargs["negative_prompt"]
     lineart = make_faceless_lineart(img, cfg)
     cutout = make_faceless_cutout(img)
-    return lineart, cutout
+    return lineart, cutout