Update faceless_processing.py

faceless_processing.py

@@ -12,7 +12,7 @@ from rembg import remove, new_session
 try:
     _SESSION_ISNET = new_session("isnet-general-use")
 except Exception as e:
-    print(f"[AI] Failed to load rembg session: {e}")
+    print(f"[AI] Failed to load rembg session1 {e}")
     _SESSION_ISNET = None
 
 # Globally download cascades at startup if missing (runs on main container with internet access)
@@ -53,12 +53,9 @@ class LineartConfig:
     transparency_threshold: float = 0.03
 
     # Subject mask
-    white_bg_threshold: int = 245          # pixels above this = background (raised to avoid erasing light subjects)
+    white_bg_threshold: int = 235          # pixels above this = background
     mask_close_iterations: int = 4
     mask_open_iterations: int = 1
-    mask_smooth_ksize: int = 5             # GaussianBlur kernel before silhouette (must be odd; 0 = disabled)
-    mask_smooth_threshold: int = 128       # re-binarize after blur
-    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
@@ -80,13 +77,13 @@ class LineartConfig:
     face_max_y_ratio: float = 0.6          # ignore faces below 60% image height
     face_nms_iou_thresh: float = 0.4
 
-    # Face erase ellipse (ratios relative to face bbox) — smaller = more conservative
+    # Face erase ellipse (ratios relative to face bbox)
     face_cx_ratio: float = 0.5
-    face_cy_ratio: float = 0.45
-    face_rx_ratio: float = 0.35            # reduced from 0.40 to avoid erasing neck/ears
-    face_ry_ratio: float = 0.38            # reduced from 0.42 to avoid erasing chin/neck
-    face_erase_blur: int = 8
-    face_erase_threshold: int = 130        # higher = sharper face mask edge, less spill
+    face_cy_ratio: float = 0.48
+    face_rx_ratio: float = 0.40
+    face_ry_ratio: float = 0.42
+    face_erase_blur: int = 10
+    face_erase_threshold: int = 100
 
 
 def _nms_faces(faces: list, iou_thresh: float) -> list:
@@ -158,14 +155,10 @@ def detect_faces(rgb: np.ndarray, cfg: LineartConfig) -> list:
     return faces
 
 
-def build_subject_mask(rgb: np.ndarray, cfg: LineartConfig, alpha_channel: Optional[np.ndarray] = None) -> np.ndarray:
-    """Build subject mask. Uses alpha channel if available, otherwise thresholds white background."""
-    if alpha_channel is not None:
-        # Use rembg/RGBA alpha directly — much more accurate than color threshold
-        mask = (alpha_channel > 30).astype(np.uint8) * 255
-    else:
-        white_mask = np.all(rgb > cfg.white_bg_threshold, axis=2)
-        mask = (~white_mask).astype(np.uint8) * 255
+def build_subject_mask(rgb: np.ndarray, cfg: LineartConfig) -> np.ndarray:
+    """Threshold out white background and clean up mask."""
+    white_mask = np.all(rgb > cfg.white_bg_threshold, axis=2)
+    mask = (~white_mask).astype(np.uint8) * 255
     kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7))
     mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel, iterations=cfg.mask_close_iterations)
     mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel, iterations=cfg.mask_open_iterations)
@@ -173,23 +166,10 @@ def build_subject_mask(rgb: np.ndarray, cfg: LineartConfig, alpha_channel: Optio
 
 
 def build_silhouette(subject_mask: np.ndarray, cfg: LineartConfig) -> np.ndarray:
-    """Draw the subject silhouette as a smooth, solid-stroke contour."""
-    mask = subject_mask.copy()
-
-    # Smooth the mask boundary to eliminate staircase jaggies before tracing
-    if cfg.mask_smooth_ksize > 1:
-        k = cfg.mask_smooth_ksize if cfg.mask_smooth_ksize % 2 == 1 else cfg.mask_smooth_ksize + 1
-        mask = cv2.GaussianBlur(mask, (k, k), 0)
-        _, mask = cv2.threshold(mask, cfg.mask_smooth_threshold, 255, cv2.THRESH_BINARY)
-
-    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_TC89_KCOS)
+    """Draw the subject silhouette as a uniform-width contour stroke."""
+    contours, _ = cv2.findContours(subject_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
     silhouette = np.zeros_like(subject_mask)
-    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)
-            smooth = cv2.approxPolyDP(cnt, eps, True)
-            cv2.drawContours(silhouette, [smooth], -1, 255, cfg.silhouette_line_thickness)
+    cv2.drawContours(silhouette, contours, -1, 255, cfg.silhouette_line_thickness)
     return silhouette
 
 
@@ -237,16 +217,10 @@ def make_faceless_lineart(
     """
     cfg = cfg or LineartConfig()
     
-    # Preserve alpha channel if image already has a transparent background (e.g. from rembg)
-    alpha_channel: Optional[np.ndarray] = None
+    # Force transparent background to white background for processing mask correctly
     if img.mode in ("RGBA", "LA") or (img.mode == "P" and "transparency" in img.info):
-        rgba_img = img.convert("RGBA")
-        alpha_np = np.array(rgba_img)[:, :, 3]
-        # Only use alpha mask if it contains meaningful transparency
-        if np.any(alpha_np < 200):
-            alpha_channel = alpha_np
         background = Image.new("RGBA", img.size, (255, 255, 255, 255))
-        rgba = Image.alpha_composite(background, rgba_img)
+        rgba = Image.alpha_composite(background, img.convert("RGBA"))
         img = rgba.convert("RGB")
     else:
         img = img.convert("RGB")
@@ -255,8 +229,8 @@ def make_faceless_lineart(
     rgb = img_np[:, :, :3]
     h, w = rgb.shape[:2]
 
-    # 1. Subject mask — use alpha if available, else color threshold
-    subject_mask = build_subject_mask(rgb, cfg, alpha_channel)
+    # 1. Subject mask
+    subject_mask = build_subject_mask(rgb, cfg)
 
     # 2. Detect faces
     faces = detect_faces(rgb, cfg)
@@ -275,6 +249,14 @@ def make_faceless_lineart(
     # 6. Combine
     final_lines = cv2.add(silhouette, interior_clean)
 
+    # Avoid drawing rectangular boxes/borders at the image edges
+    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
+        final_lines[-border_erase_width:, :] = 0
+        final_lines[:, 0:border_erase_width] = 0
+        final_lines[:, -border_erase_width:] = 0
+
     # 7. Build output image
     alpha = Image.fromarray(final_lines)
     size = img.size