Update faceless_processing.py

faceless_processing.py

@@ -1,6 +1,6 @@
 import cv2
 import numpy as np
-from PIL import Image, ImageFilter, ImageOps
+from PIL import Image, ImageFilter
 from dataclasses import dataclass
 from typing import Tuple, Optional
 import io
@@ -34,6 +34,8 @@ _LINEART_DETECTOR = None
 _LINEART_AVAILABLE = True
 
 
+
+
 def get_lineart_detector():
     """
     Lazy-load the controlnet_aux LineartDetector (informative-drawings model
@@ -73,8 +75,7 @@ def _download_assets_globally():
         os.makedirs(cascade_dir, exist_ok=True)
         xml_urls = {
             'haarcascade_frontalface_default.xml': 'https://raw.githubusercontent.com/opencv/opencv/master/data/haarcascades/haarcascade_frontalface_default.xml',
-            'haarcascade_frontalface_alt2.xml': 'https://raw.githubusercontent.com/opencv/opencv/master/data/haarcascades/haarcascade_frontalface_alt2.xml',
-            'haarcascade_profileface.xml': 'https://raw.githubusercontent.com/opencv/opencv/master/data/haarcascades/haarcascade_profileface.xml'
+            'haarcascade_frontalface_alt2.xml': 'https://raw.githubusercontent.com/opencv/opencv/master/data/haarcascades/haarcascade_frontalface_alt2.xml'
         }
         for name, url in xml_urls.items():
             path = os.path.join(cascade_dir, name)
@@ -104,6 +105,7 @@ _download_assets_globally()
 get_lineart_detector()
 
 
+
 @dataclass
 class LineartConfig:
     # Backward compatibility fields
@@ -127,36 +129,39 @@ class LineartConfig:
     mask_smooth_threshold: int = 128
     min_silhouette_area: float = 200.0
 
-    # Silhouette outline — clean, slightly bold for embroidery visibility
+    # Silhouette outline
+
+    silhouette_smooth_ksize: int = 5
+    
     silhouette_line_thickness: int = 3
 
-    # --- Neural line-art parameters (replace the old Canny block) ---
-    # Resolution the detector runs at. Higher = more/finer detail. 768-1024
-    # gives the clean structural lines (lapels, folds, hair) seen in the ref.
-    lineart_detect_resolution: int = 1024
-    lineart_image_resolution: int = 1024
-    # coarse=False => detailed model (sk_model2). True => simpler/cleaner lines.
-    lineart_coarse: bool = False
-    # Strength threshold: only keep line pixels stronger than this (0-255).
-    # Lower = keep more faint lines (more detail like face shape / hair strands).
-    lineart_threshold: int = 14
-    # Minimum contour length (px) to keep — removes speckle noise.
-    # Low value preserves short strokes (eyebrows, hair locks, jaw line).
-    lineart_min_perimeter: float = 8.0
-    # How much to erode the subject mask before keeping interior lines.
-    # Smaller = keeps lines closer to the silhouette (face outline, hair edge).
-    interior_erode_size: int = 3
-    # Final interior stroke thickness.
+    # --- Neural line-art parameters ---
+    lineart_detect_resolution: int = 2048
+    lineart_image_resolution: int = 2048
+    lineart_coarse: bool = True
+    
+    # AUMENTADO: Força a ignorar dobras de roupa e focar só na estrutura
+    lineart_threshold: int = 100
+    
+    # AJUSTE DE CABELO E CORPO: Diminuído para capturar fios e dobras de roupa.
+    lineart_min_perimeter: float = 70.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 params (only used if controlnet_aux is missing) ----
-    canny_low: int = 40
-    canny_high: int = 130
+
+
+    # ---- Canny fallback parametros ----
+    canny_low: int = 35
+    canny_high: int = 75
     bilateral_d: int = 11
     bilateral_sigma_color: int = 110
     bilateral_sigma_space: int = 110
     gaussian_ksize: int = 11
-    min_contour_perimeter: float = 65.0
+    min_contour_perimeter: float = 15.0
     min_embroidery_stitch_px: int = 25
     enable_detail_pass: bool = False
     detail_canny_low: int = 15
@@ -174,28 +179,31 @@ class LineartConfig:
     face_nms_iou_thresh: float = 0.35
     face_max_count: int = 6
 
-    # Face erase ellipse — covers ONLY eyes/nose/mouth zone (keeps eyebrows/chin)
+    # Face erase ellipse
     face_cx_ratio: float = 0.50
-    face_cy_ratio: float = 0.46
-    face_rx_ratio: float = 0.27
-    face_ry_ratio: float = 0.19
+    face_cy_ratio: float = 0.55
+    face_rx_ratio: float = 0.48
+    face_ry_ratio: float = 0.50
     face_erase_blur: int = 5
     face_erase_threshold: int = 90
 
     # MediaPipe
     mediapipe_num_faces: int = 6
 
-    # Eyebrow drawing — subtle (per user request)
-    eyebrow_thickness: int = 3
-    eyebrow_dilate: int = 1
+    # --- 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 (head/jaw outline). Draws the MediaPipe face oval so the
-    # "formato do rosto" is visible while the centre stays faceless.
+    # Face shape
     draw_face_oval: bool = True
-    face_oval_thickness: int = 2
-    # Skip the very top of the oval (forehead) so the line doesn't cut across
-    # the hair. 0.0 = draw full oval, 0.25 = skip top 25% (recommended).
-    face_oval_skip_top_ratio: float = 0.18
+    face_oval_thickness: int = 1
+    face_oval_skip_top_ratio: float = 0.50
+
+
+
+
 
 
 def _nms_faces(faces: list, iou_thresh: float) -> list:
@@ -220,57 +228,37 @@ def _nms_faces(faces: list, iou_thresh: float) -> list:
     return [faces[i] for i in keep]
 
 
-def _load_cascade(cascade_dir: str, name: str) -> Optional[cv2.CascadeClassifier]:
-    """Load a Haar cascade from the local dir, falling back to OpenCV's builtin."""
-    local = os.path.join(cascade_dir, name)
-    if os.path.exists(local):
-        c = cv2.CascadeClassifier(local)
-        if not c.empty():
-            return c
-    builtin = cv2.CascadeClassifier(cv2.data.haarcascades + name)
-    return builtin if not builtin.empty() else None
-
-
 def detect_faces(rgb: np.ndarray, cfg: LineartConfig) -> list:
-    h, w = rgb.shape[:2]
+    h = rgb.shape[0]
     gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)
     clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
     gray_eq = clahe.apply(gray)
-    gray_flip = cv2.flip(gray_eq, 1)  # mirror, for the other-facing profile
     faces = []
     try:
         cascade_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "cascades")
-        frontal = [c for c in (
-            _load_cascade(cascade_dir, 'haarcascade_frontalface_default.xml'),
-            _load_cascade(cascade_dir, 'haarcascade_frontalface_alt2.xml'),
-        ) if c is not None]
-        profile = _load_cascade(cascade_dir, 'haarcascade_profileface.xml')
-
-        # --- Frontal faces (raw + CLAHE) ---
-        for cascade in frontal:
-            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())
-
-        # --- Profile faces (side view). The cascade only detects faces looking
-        # one direction, so run it on the image AND its mirror, remapping x. ---
-        if profile is not None and not profile.empty():
-            # left-facing profiles
-            for (fx, fy, fw, fh) in profile.detectMultiScale(
-                    gray_eq, scaleFactor=cfg.face_scale_factor,
-                    minNeighbors=cfg.face_min_neighbors, minSize=cfg.face_min_size):
-                faces.append([int(fx), int(fy), int(fw), int(fh)])
-            # right-facing profiles (detected on the mirror, x flipped back)
-            for (fx, fy, fw, fh) in profile.detectMultiScale(
-                    gray_flip, scaleFactor=cfg.face_scale_factor,
-                    minNeighbors=cfg.face_min_neighbors, minSize=cfg.face_min_size):
-                faces.append([int(w - fx - fw), int(fy), int(fw), int(fh)])
+        path_default = os.path.join(cascade_dir, 'haarcascade_frontalface_default.xml')
+        path_alt = os.path.join(cascade_dir, 'haarcascade_frontalface_alt2.xml')
+        classifiers = []
+        if os.path.exists(path_default):
+            classifiers.append(cv2.CascadeClassifier(path_default))
+        if os.path.exists(path_alt):
+            classifiers.append(cv2.CascadeClassifier(path_alt))
+        if not classifiers or all(c.empty() for c in classifiers):
+            classifiers = [
+                cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'),
+                cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_alt2.xml')
+            ]
+        for cascade in classifiers:
+            if cascade and not cascade.empty():
+                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}")
 
@@ -281,6 +269,7 @@ 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:
@@ -308,6 +297,8 @@ 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
 
 
@@ -371,6 +362,7 @@ def _line_strength_from_detector(pil_lineart: Image.Image, target_hw: Tuple[int,
     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
@@ -415,8 +407,10 @@ def build_interior_edges(rgb: np.ndarray, subject_mask: np.ndarray, cfg: Lineart
                 cv2.drawContours(filtered, [cnt], -1, 255, cfg.interior_line_thickness)
 
             # Gentle dilation for solid, embroiderable strokes
-            kernel_dilate = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
+            ernel_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)
             return filtered
         except Exception as e:
             print(f"[AI] Neural lineart failed, falling back to Canny: {e}")
@@ -479,41 +473,6 @@ def get_landmarker(model_path, num_faces: int = 6):
     return _LANDMARKER_CACHE
 
 
-def _draw_eyebrows_geometric(eyebrows_layer: np.ndarray, faces: list, cfg: LineartConfig) -> np.ndarray:
-    """
-    Fallback used when MediaPipe (OpenGL) fails to load on the Space.
-    Draws approximate eyebrows + a jaw/chin arc from the Haar cascade bounding
-    box using standard facial proportions, so these details are NEVER missing.
-    """
-    eb_th = max(2, getattr(cfg, 'eyebrow_thickness', 2))
-    oval_th = max(1, getattr(cfg, 'face_oval_thickness', 1))
-    draw_oval = getattr(cfg, 'draw_face_oval', True)
-    count = 0
-    for (fx, fy, fw, fh) in faces:
-        # Eyebrows: horizontal band around 30% of face height, slight upward arc
-        eb_y = int(fy + fh * 0.30)
-        lift = int(fh * 0.04)
-        left = (int(fx + fw * 0.18), int(fx + fw * 0.44))
-        right = (int(fx + fw * 0.56), int(fx + fw * 0.82))
-        for (xa, xb) in (left, right):
-            mx = (xa + xb) // 2
-            pts = np.array([[xa, eb_y], [mx, eb_y - lift], [xb, eb_y]], np.int32)
-            cv2.polylines(eyebrows_layer, [pts.reshape((-1, 1, 2))],
-                          isClosed=False, color=255, thickness=eb_th,
-                          lineType=cv2.LINE_AA)
-        if draw_oval:
-            # Jaw / chin arc only (lower half of the face) so hair stays free
-            cx = int(fx + fw * 0.50)
-            cy = int(fy + fh * 0.52)
-            rx = int(fw * 0.46)
-            ry = int(fh * 0.50)
-            cv2.ellipse(eyebrows_layer, (cx, cy), (rx, ry), 0, 30, 150,
-                        255, oval_th, lineType=cv2.LINE_AA)
-        count += 1
-    print(f"[eyebrows] Geometric fallback drew {count} face(s)")
-    return eyebrows_layer
-
-
 def draw_eyebrows(rgb: np.ndarray, cfg: LineartConfig, faces: Optional[list] = None) -> np.ndarray:
     h, w, _ = rgb.shape
     eyebrows_layer = np.zeros((h, w), dtype=np.uint8)
@@ -538,7 +497,7 @@ def draw_eyebrows(rgb: np.ndarray, cfg: LineartConfig, faces: Optional[list] = N
                      172, 58, 132, 93, 234, 127, 162, 21, 54, 103, 67, 109]
 
         eyebrow_thickness = getattr(cfg, 'eyebrow_thickness', cfg.interior_line_thickness)
-        draw_oval = getattr(cfg, 'draw_face_oval', True)
+        draw_oval = True
         oval_thickness = getattr(cfg, 'face_oval_thickness', 2)
         oval_skip_top = getattr(cfg, 'face_oval_skip_top_ratio', 0.18)
         drawn_centers_px: list = []
@@ -564,29 +523,34 @@ def draw_eyebrows(rgb: np.ndarray, cfg: LineartConfig, faces: Optional[list] = N
                               thickness=eyebrow_thickness, lineType=cv2.LINE_AA)
 
             # Face oval (head / jaw outline) — gives the "formato do rosto"
-            if draw_oval:
-                oval_pts = []
+                if draw_oval:
+                    oval_pts = []
                 for idx in FACE_OVAL:
                     lm = face_lms[idx]
                     px = int(origin_x + lm.x * scale_x)
                     py = int(origin_y + lm.y * scale_y)
                     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,
-                                          lineType=cv2.LINE_AA)
+                    # LÓGICA REVISADA: Focar apenas no terço inferior (queixo/maxilar)
+                    y_min = oval_np[:, 1].min()
+                    y_max = oval_np[:, 1].max()
+                    
+                    # Corta os 60% superiores do rosto (mantém apenas o "U" inferior)
+                    cutoff = y_min + (y_max - y_min) * 0.60 
+                    
+                    kept = oval_np[oval_np[:, 1] >= cutoff]
+                    
+                    if len(kept) >= 4:
+                        # Ordena os pontos da esquerda para a direita para evitar o polígono maluco
+                        kept = kept[np.argsort(kept[:, 0])]
+                        arc = kept.reshape((-1, 1, 2))
+                        
+                        # Desenha o maxilar sem fechar a forma
+                        cv2.polylines(eyebrows_layer, [arc], isClosed=False,
+                                      color=255, thickness=oval_thickness,
+                                      lineType=cv2.LINE_AA)
                     else:
                         cv2.polylines(eyebrows_layer, [oval_np.reshape((-1, 1, 2))],
                                       isClosed=True, color=255,
@@ -636,22 +600,8 @@ def draw_eyebrows(rgb: np.ndarray, cfg: LineartConfig, faces: Optional[list] = N
                     draw_eyebrow_landmarks(face_lms, x1, y1, crop_w, crop_h)
 
         print(f"[eyebrows] Drew eyebrows for {len(drawn_centers_px)} face(s)")
-
-        # If MediaPipe ran but found no faces, use the geometric fallback so
-        # eyebrows / face shape are still present.
-        if not drawn_centers_px:
-            if faces is None:
-                faces = detect_faces(rgb, cfg)
-            if faces:
-                eyebrows_layer = _draw_eyebrows_geometric(eyebrows_layer, faces, cfg)
     except Exception as e:
         print(f"[AI] Eyebrow extraction error or library missing: {e}")
-        # MediaPipe failed to load (e.g. libGLESv2 missing). Fall back to the
-        # geometric approximation from the Haar cascade boxes.
-        if faces is None:
-            faces = detect_faces(rgb, cfg)
-        if faces:
-            eyebrows_layer = _draw_eyebrows_geometric(eyebrows_layer, faces, cfg)
 
     if eyebrows_layer.any():
         dil = getattr(cfg, 'eyebrow_dilate', 1)
@@ -664,10 +614,6 @@ def draw_eyebrows(rgb: np.ndarray, cfg: LineartConfig, faces: Optional[list] = N
 def make_faceless_lineart(img: Image.Image, cfg: LineartConfig = None) -> Image.Image:
     cfg = cfg or LineartConfig()
 
-    # Honour EXIF orientation (phone photos). Without this, photos with an
-    # orientation tag are processed sideways and end up rotated/cropped.
-    img = ImageOps.exif_transpose(img)
-
     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")
@@ -749,10 +695,13 @@ 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:
-        # Match the lineart orientation so the cutout never ends up rotated/cropped.
-        img = ImageOps.exif_transpose(img)
         rgba = img.convert("RGBA")
         if _has_real_transparency(rgba):
             return rgba
@@ -774,6 +723,7 @@ 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()