fix: smooth lineart, detect eyebrows on tilted faces, thinner eyebrows

app.py

@@ -33,18 +33,11 @@ def process_faceless(input_image, prompt="", negative_prompt=""):
         else:
             return lineart_path, None
     except Exception as e:
-        import traceback
-        err_str = "".join(traceback.format_exception(type(e), e, e.__traceback__))
-        print(f"[ERRO] process_faceless: {err_str}")
-        
-        from PIL import ImageDraw
-        err_img = Image.new("RGBA", (1024, 1024), (40, 0, 0, 255))
-        draw = ImageDraw.Draw(err_img)
-        draw.text((10, 10), err_str, fill=(255, 255, 255, 255))
-        
-        err_path = os.path.join(tempfile.gettempdir(), f"err_{os.getpid()}_{os.urandom(4).hex()}.png")
-        err_img.save(err_path, "PNG")
-        return err_path, None
+        print(f"[ERRO] process_faceless: {e}")
+        # Save original to temp file to be safe
+        orig_path = os.path.join(tempfile.gettempdir(), f"orig_{os.getpid()}_{os.urandom(4).hex()}.png")
+        input_image.save(orig_path, "PNG")
+        return orig_path, None
 
 
 # Interface Gradio
@@ -63,5 +56,6 @@ demo = gr.Interface(
     description="Gera contornos e linearts minimalistas (Faceless) para bordados a partir de retratos.\n\n**Nota:** O rosto é completamente apagado e apenas a silhueta externa é desenhada."
 )
 
+
 if __name__ == "__main__":
     demo.launch()

faceless_processing.py

@@ -77,7 +77,7 @@ class LineartConfig:
     min_silhouette_area: float = 200.0     # drop tiny isolated blobs from the silhouette (px²)
 
     # Silhouette outline
-    silhouette_line_thickness: int = 4   # outer contour stroke width (px); match interior for uniform look
+    silhouette_line_thickness: int = 3   # outer contour stroke width (px); match interior for uniform look
 
     # Edge detection
     canny_low: int = 40
@@ -203,7 +203,7 @@ def build_silhouette(subject_mask: np.ndarray, cfg: LineartConfig) -> np.ndarray
     for cnt in contours:
         if cv2.contourArea(cnt) >= cfg.min_silhouette_area:
             # Smooth the polygon points slightly to reduce digitisation noise
-            eps = 0.0015 * cv2.arcLength(cnt, True)
+            eps = 0.0045 * cv2.arcLength(cnt, True)
             smooth = cv2.approxPolyDP(cnt, eps, True)
             cv2.drawContours(silhouette, [smooth], -1, 255, cfg.silhouette_line_thickness)
     return silhouette
@@ -235,8 +235,12 @@ def build_interior_edges(rgb: np.ndarray, subject_mask: np.ndarray, cfg: Lineart
     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.min_contour_perimeter:
-            cv2.drawContours(filtered, [cnt], -1, 255, cfg.interior_line_thickness)
+        perimeter = cv2.arcLength(cnt, False)
+        if perimeter > cfg.min_contour_perimeter:
+            # Simplify interior edges to 0.004 to remove Canny wobbles
+            eps = 0.004 * 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))
@@ -244,8 +248,8 @@ def build_interior_edges(rgb: np.ndarray, subject_mask: np.ndarray, cfg: Lineart
     return filtered
 
 
-def draw_eyebrows(rgb: np.ndarray, cfg: LineartConfig) -> np.ndarray:
-    """Detect and draw eyebrows landmarks using MediaPipe Task API."""
+def draw_eyebrows(rgb: np.ndarray, cfg: LineartConfig, faces: Optional[list] = None) -> np.ndarray:
+    """Detect and draw eyebrows landmarks using MediaPipe Task API with hybrid global + crop detection."""
     h, w, _ = rgb.shape
     eyebrows_layer = np.zeros((h, w), dtype=np.uint8)
 
@@ -266,38 +270,89 @@ def draw_eyebrows(rgb: np.ndarray, cfg: LineartConfig) -> np.ndarray:
                 urllib.request.urlretrieve(model_url, model_path)
                 print("[AI] Download complete!")
 
-        # Create mediapipe image
-        mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=rgb)
-
-        # Initialize landmarker
+        # Initialize landmarker with num_faces=1 for high sensitivity on local crops
         base_options = python.BaseOptions(model_asset_path=model_path)
         options = vision.FaceLandmarkerOptions(
             base_options=base_options,
             output_face_blendshapes=False,
             output_facial_transformation_matrixes=False,
-            num_faces=5
+            num_faces=1
         )
 
         LEFT_EYEBROW = [70, 63, 105, 66, 107, 55, 65, 52, 53, 46]
         RIGHT_EYEBROW = [336, 296, 334, 293, 300, 285, 295, 282, 283, 276]
+        
+        eyebrow_thickness = max(1, cfg.interior_line_thickness - 1)
+        processed_centers = []
+
+        def is_duplicate(cx, cy):
+            for (pcx, pcy) in processed_centers:
+                dist = np.sqrt((cx - pcx)**2 + (cy - pcy)**2)
+                if dist < 0.08:
+                    return True
+            return False
+
+        if faces is None:
+            faces = detect_faces(rgb, cfg)
 
         with vision.FaceLandmarker.create_from_options(options) as landmarker:
-            result = landmarker.detect(mp_image)
-            if result.face_landmarks:
-                print(f"[eyebrows] Detected {len(result.face_landmarks)} faces with eyebrows")
-                for face_landmarks in result.face_landmarks:
-                    for indices in [LEFT_EYEBROW, RIGHT_EYEBROW]:
-                        points = []
-                        for idx in indices:
-                            landmark = face_landmarks[idx]
-                            x = int(landmark.x * w)
-                            y = int(landmark.y * h)
-                            points.append([x, y])
-
-                        pts = np.array(points, np.int32)
-                        pts = pts.reshape((-1, 1, 2))
-                        # Draw standard eyebrow contours
-                        cv2.polylines(eyebrows_layer, [pts], isClosed=False, color=255, thickness=cfg.interior_line_thickness)
+            # Phase 1: Global detection (upright / clear faces)
+            mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=rgb)
+            global_result = landmarker.detect(mp_image)
+            if global_result.face_landmarks:
+                for face_landmarks in global_result.face_landmarks:
+                    xs = [lm.x for lm in face_landmarks]
+                    ys = [lm.y for lm in face_landmarks]
+                    cx, cy = np.mean(xs), np.mean(ys)
+                    if not is_duplicate(cx, cy):
+                        processed_centers.append((cx, cy))
+                        for indices in [LEFT_EYEBROW, RIGHT_EYEBROW]:
+                            points = []
+                            for idx in indices:
+                                lm = face_landmarks[idx]
+                                points.append([int(lm.x * w), int(lm.y * h)])
+                            pts = np.array(points, np.int32).reshape((-1, 1, 2))
+                            cv2.polylines(eyebrows_layer, [pts], isClosed=False, color=255, thickness=eyebrow_thickness)
+
+            # Phase 2: OpenCV crops with 45% margin (for tilted / overlapping faces)
+            for i, (fx, fy, fw, fh) in enumerate(faces):
+                margin_x = int(fw * 0.45)
+                margin_y = int(fh * 0.45)
+                x1 = max(0, fx - margin_x)
+                y1 = max(0, fy - margin_y)
+                x2 = min(w, fx + fw + margin_x)
+                y2 = min(h, fy + fh + margin_y)
+
+                crop_w = x2 - x1
+                crop_h = y2 - y1
+                if crop_w <= 0 or crop_h <= 0:
+                    continue
+
+                crop_cx = (x1 + crop_w / 2) / w
+                crop_cy = (y1 + crop_h / 2) / h
+                if is_duplicate(crop_cx, crop_cy):
+                    continue
+
+                crop = rgb[y1:y2, x1:x2]
+                crop_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=crop)
+                crop_result = landmarker.detect(crop_image)
+
+                if crop_result.face_landmarks:
+                    face_landmarks = crop_result.face_landmarks[0]
+                    xs_global = [(x1 + lm.x * crop_w) / w for lm in face_landmarks]
+                    ys_global = [(y1 + lm.y * crop_h) / h for lm in face_landmarks]
+                    cx, cy = np.mean(xs_global), np.mean(ys_global)
+                    if not is_duplicate(cx, cy):
+                        processed_centers.append((cx, cy))
+                        for indices in [LEFT_EYEBROW, RIGHT_EYEBROW]:
+                            points = []
+                            for idx in indices:
+                                lm = face_landmarks[idx]
+                                gx = int(x1 + lm.x * crop_w)
+                                gy = int(y1 + lm.y * crop_h)
+                                points.append([gx, gy])
+                            pts = np.array(points, np.int32).reshape((-1, 1, 2))
+                            cv2.polylines(eyebrows_layer, [pts], isClosed=False, color=255, thickness=eyebrow_thickness)
     except Exception as e:
         print(f"[AI] Eyebrow extraction error or library missing: {e}")
 
@@ -354,7 +409,7 @@ def make_faceless_lineart(
 
     # 6.5. Optional eyebrow detection overlay
     if cfg.detect_eyebrows:
-        eyebrows = draw_eyebrows(rgb, cfg)
+        eyebrows = draw_eyebrows(rgb, cfg, faces=faces)
         final_lines = cv2.add(final_lines, eyebrows)
 
     # Avoid drawing rectangular boxes/borders at the image edges