Update faceless_processing.py

faceless_processing.py

@@ -81,21 +81,21 @@ class LineartConfig:
     mask_smooth_threshold: int = 128
     min_silhouette_area: float = 200.0
 
-    # Silhouette outline — desenha com espessura fina e depois dilata
-    silhouette_line_thickness: int = 1   # desenho fino, dilatação depois
-
-    # Edge detection — parâmetros ajustados para reter detalhes
-    canny_low: int = 25                    # fallback (fixo)
-    canny_high: int = 90                   # fallback (fixo)
-    bilateral_d: int = 5                   # menos agressivo
-    bilateral_sigma_color: int = 60        # reduzido
-    bilateral_sigma_space: int = 60        # reduzido
-    gaussian_ksize: int = 5                # menor
-    min_contour_perimeter: float = 20.0    # mais baixo para capturar detalhes
+    # Silhouette outline — desenha fino e dilata depois
+    silhouette_line_thickness: int = 1
+
+    # ----- PARÂMETROS EQUILIBRADOS (nem muito detalhe, nem muito liso) -----
+    canny_low: int = 30                    # fallback
+    canny_high: int = 120                  # fallback
+    bilateral_d: int = 7                   # médio
+    bilateral_sigma_color: int = 80        # médio
+    bilateral_sigma_space: int = 80        # médio
+    gaussian_ksize: int = 7                # médio (mata textura fina, mantém dobras)
+    min_contour_perimeter: float = 30.0    # ignora linhas muito curtas (ruído)
     interior_line_thickness: int = 1       # fino, dilata depois
 
-    # Secondary detail pass — ATIVADO para capturar bordas finas
-    enable_detail_pass: bool = True
+    # ---- Detail pass DESLIGADO (evita excesso de ruído) ----
+    enable_detail_pass: bool = False
     detail_canny_low: int = 10
     detail_canny_high: int = 40
     detail_gaussian_ksize: int = 3
@@ -103,14 +103,15 @@ class LineartConfig:
     detail_bilateral_d: int = 3
     detail_bilateral_sigma: int = 40
 
-    # Embroidery stitch feasibility — reduzido para preservar detalhes curtos
-    min_embroidery_stitch_px: int = 15
+    # Embroidery stitch feasibility
+    min_embroidery_stitch_px: int = 20
 
-    # Auto-Canny sigma — mais baixo = mais detalhes
-    canny_sigma: float = 0.20
+    # Auto-Canny sigma — valor médio (0.25) pega dobras principais e ignora textura
+    canny_sigma: float = 0.25
 
-    # Aspect ratio filter: 0 = disabled. Mantenha 0 para não perder detalhes finos.
-    min_aspect_ratio: float = 0
+    # --- FILTRO MÁGICO: elimina bolinhas/rugas (redondas) e mantém linhas (dobras) ---
+    # 2.0 = só mantém contornos que são pelo menos 2x mais longos que largos
+    min_aspect_ratio: float = 2.0
 
     # Face detection
     face_scale_factor: float = 1.05
@@ -280,22 +281,10 @@ def _auto_canny(image: np.ndarray, sigma: float = 0.33,
         v = float(np.median(image))
     lower = int(max(0, (1.0 - sigma) * v))
     upper = int(min(255, (1.0 + sigma) * v))
-    print(f"[auto_canny] median={v:.1f}  lower={lower}  upper={upper}")
+    # print(f"[auto_canny] median={v:.1f}  lower={lower}  upper={upper}")
     return cv2.Canny(image, lower, upper)
 
 
-def _xdog_filter(gray: np.ndarray, sigma: float = 1.4, k: float = 1.6,
-                  gamma: float = 0.98, epsilon: float = 0.02, phi: float = 200) -> np.ndarray:
-    f = gray.astype(np.float32) / 255.0
-    g1 = cv2.GaussianBlur(f, (0, 0), sigma)
-    g2 = cv2.GaussianBlur(f, (0, 0), sigma * k)
-    dog = g1 - gamma * g2
-    result = np.where(dog >= epsilon, 1.0, 1.0 + np.tanh(phi * (dog - epsilon)))
-    result = np.clip(result, 0.0, 1.0)
-    edges = (1.0 - result) * 255
-    return edges.astype(np.uint8)
-
-
 def build_face_erase_mask(faces: list, shape: Tuple[int, int], cfg: LineartConfig) -> np.ndarray:
     h, w = shape
     mask = np.zeros((h, w), dtype=np.uint8)
@@ -312,34 +301,33 @@ 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:
     gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)
 
-    # Suavização mais leve
+    # Suavização moderada: mata textura de pele/tecido, mas mantém dobras principais
     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)
 
-    # Erosão da máscara menos agressiva
+    # Erosão da máscara para evitar bordas do fundo
     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)
 
-    # Detecção principal (Canny adaptativo)
+    # Detecção principal com Canny adaptativo (sigma=0.25)
     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)
 
-    # Passagem de detalhes (ativada)
+    # Detail pass DESLIGADO para evitar excesso de ruído
     if getattr(cfg, 'enable_detail_pass', False):
         detail_d = getattr(cfg, 'detail_bilateral_d', 3)
         detail_sigma = getattr(cfg, 'detail_bilateral_sigma', 40)
         detail_ksize = getattr(cfg, 'detail_gaussian_ksize', 3)
         blurred_detail = cv2.bilateralFilter(gray, detail_d, detail_sigma, detail_sigma)
         blurred_detail = cv2.GaussianBlur(blurred_detail, (detail_ksize, detail_ksize), 0)
-        # Para detalhes, usamos Canny fixo com limiares baixos
         edges_detail = cv2.Canny(
             blurred_detail,
             getattr(cfg, 'detail_canny_low', 10),
@@ -351,8 +339,8 @@ def build_interior_edges(rgb: np.ndarray, subject_mask: np.ndarray, cfg: Lineart
 
     # Filtrar contornos
     min_perimeter = cfg.min_contour_perimeter
-    min_stitch = getattr(cfg, 'min_embroidery_stitch_px', 15)
-    min_aspect = getattr(cfg, 'min_aspect_ratio', 0)
+    min_stitch = getattr(cfg, 'min_embroidery_stitch_px', 20)
+    min_aspect = getattr(cfg, 'min_aspect_ratio', 2.0)  # FILTRO DE ASPECTO ATIVADO
 
     contours, _ = cv2.findContours(edges, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
     filtered = np.zeros_like(edges)
@@ -363,13 +351,17 @@ def build_interior_edges(rgb: np.ndarray, subject_mask: np.ndarray, cfg: Lineart
             continue
         if min_stitch > 0 and perimeter < min_stitch:
             continue
+        
+        # ----- FILTRO MÁGICO: elimina rugas/poros (redondos) e mantém dobras (alongadas) -----
         if min_aspect > 0:
             x, y, bw, bh = cv2.boundingRect(cnt)
             long_side = max(bw, bh)
             short_side = min(bw, bh) + 1
+            # Se for mais redondo que o limite, descarta
             if long_side / short_side < min_aspect:
                 continue
-        # Suavização do contorno com epsilon pequeno
+
+        # Suavização do contorno para ficar orgânico
         eps = 0.005 * perimeter
         smooth = cv2.approxPolyDP(cnt, eps, False)
         # Desenha com espessura fina (1) para preservar geometria
@@ -377,7 +369,7 @@ def build_interior_edges(rgb: np.ndarray, subject_mask: np.ndarray, cfg: Lineart
 
     # Dilatação final para engrossar as linhas (mantém a forma)
     kernel_dilate = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
-    filtered = cv2.dilate(filtered, kernel_dilate, iterations=2)  # engrossa 2px
+    filtered = cv2.dilate(filtered, kernel_dilate, iterations=2)
 
     return filtered
 
@@ -515,7 +507,6 @@ def draw_eyebrows(rgb: np.ndarray, cfg: LineartConfig, faces: Optional[list] = N
     except Exception as e:
         print(f"[AI] Eyebrow extraction error or library missing: {e}")
 
-    # Dilatação para engrossar as sobrancelhas
     if eyebrows_layer.any():
         dil = getattr(cfg, 'eyebrow_dilate', 2)
         if dil > 0:
@@ -539,7 +530,7 @@ def draw_face_oval(
         148, 176, 149, 150, 136, 172, 58, 132, 93, 234
     ]
 
-    thickness = getattr(cfg, 'face_oval_thickness', 2)  # fino, dilata depois
+    thickness = getattr(cfg, 'face_oval_thickness', 2)
 
     try:
         import mediapipe as mp
@@ -626,7 +617,6 @@ def draw_face_oval(
     except Exception as e:
         print(f"[face_oval] Error: {e}")
 
-    # Dilatação para engrossar o oval (consistente com as demais linhas)
     if oval_layer.any():
         kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
         oval_layer = cv2.dilate(oval_layer, kernel, iterations=2)
@@ -678,11 +668,7 @@ def make_faceless_lineart(
         face_oval = draw_face_oval(rgb, cfg, faces=faces)
         final_lines = cv2.add(final_lines, face_oval)
 
-    # Dilatação final global para garantir espessura uniforme (opcional)
-    # Se quiser linhas ainda mais grossas, descomente:
-    # kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3,3))
-    # final_lines = cv2.dilate(final_lines, kernel, iterations=1)
-
+    # Borda segura
     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