Update faceless_processing.py

faceless_processing.py

@@ -16,10 +16,8 @@ except Exception as e:
     print(f"[AI] Failed to load rembg session: {e}")
     _SESSION_ISNET = None
 
-# Globally download cascades and models at startup if missing (runs on main container with internet access)
 def _download_assets_globally():
     try:
-        # 1. Cascades
         cascade_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "cascades")
         os.makedirs(cascade_dir, exist_ok=True)
         xml_urls = {
@@ -29,13 +27,12 @@ def _download_assets_globally():
         for name, url in xml_urls.items():
             path = os.path.join(cascade_dir, name)
             if not os.path.exists(path) or os.path.getsize(path) < 1000:
-                print(f"[AI] Downloading cascade {name} globally from OpenCV GitHub...")
+                print(f"[AI] Downloading cascade {name} globally...")
                 try:
                     urllib.request.urlretrieve(url, path)
                 except Exception as dl_err:
-                    print(f"[AI] Failed to download {name} globally: {dl_err}")
+                    print(f"[AI] Failed to download {name}: {dl_err}")
 
-        # 2. MediaPipe Model
         model_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "models")
         os.makedirs(model_dir, exist_ok=True)
         model_path = os.path.join(model_dir, "face_landmarker.task")
@@ -44,9 +41,8 @@ def _download_assets_globally():
             try:
                 model_url = "https://storage.googleapis.com/mediapipe-models/face_landmarker/face_landmarker/float16/1/face_landmarker.task"
                 urllib.request.urlretrieve(model_url, model_path)
-                print("[AI] face_landmarker.task download complete!")
             except Exception as dl_err:
-                print(f"[AI] Failed to download face_landmarker.task globally: {dl_err}")
+                print(f"[AI] Failed to download face_landmarker.task: {dl_err}")
     except Exception as e:
         print(f"[AI] Global asset download manager failed: {e}")
 
@@ -55,7 +51,6 @@ _download_assets_globally()
 
 @dataclass
 class LineartConfig:
-    # Backward compatibility fields (unused by OpenCV pipeline but required by callers)
     prompt: str = ""
     negative_prompt: str = ""
     stable_diffusion_model_id: str = ""
@@ -68,46 +63,44 @@ class LineartConfig:
     transparency_threshold: float = 0.03
     detect_eyebrows: bool = True
 
-
     # Subject mask
-    white_bg_threshold: int = 245          # pixels above this = background (raised to avoid erasing light subjects)
-    mask_close_iterations: int = 4
+    white_bg_threshold: int = 245
+    mask_close_iterations: int = 3
     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²)
+    mask_smooth_ksize: int = 5
+    mask_smooth_threshold: int = 128
+    min_silhouette_area: float = 100.0
 
     # Silhouette outline
-    silhouette_line_thickness: int = 3   # outer contour stroke width (px); match interior for uniform look
-
-    # Edge detection
-    canny_low: int = 40
-    canny_high: int = 110
-    bilateral_d: int = 11
-    bilateral_sigma_color: int = 80
-    bilateral_sigma_space: int = 80
-    gaussian_ksize: int = 9
-    min_contour_perimeter: float = 50.0    # filters out short noisy lines
-    interior_line_thickness: int = 3        # thickness of interior detail lines (>=1)
+    silhouette_line_thickness: int = 3
+
+    # Edge detection (Ajustado para capturar mais detalhes)
+    canny_low: int = 30
+    canny_high: int = 85
+    bilateral_d: int = 7
+    bilateral_sigma_color: int = 50
+    bilateral_sigma_space: int = 50
+    gaussian_ksize: int = 3                  # Reduzido de 9 para 3 para preservar nitidez
+    min_contour_perimeter: float = 15.0      # Reduzido de 50 para 15 para não apagar traços finos
+    interior_line_thickness: int = 2         # Reduzido para um traço mais sofisticado e detalhado
 
     # Face detection
-    face_scale_factor: float = 1.05
+    face_scale_factor: float = 1.10
     face_min_neighbors: int = 3
-    face_min_size: Tuple[int, int] = (25, 25)
-    face_max_y_ratio: float = 0.6          # ignore faces below 60% image height
-    face_nms_iou_thresh: float = 0.4
+    face_min_size: Tuple[int, int] = (30, 30)
+    face_max_y_ratio: float = 0.65
+    face_nms_iou_thresh: float = 0.3
 
-    # Face erase ellipse (ratios relative to face bbox) — smaller = more conservative
+    # Face erase ellipse (Ajustado para preservar o contorno da mandíbula/sombrancelhas nas bordas)
     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.5
+    face_rx_ratio: float = 0.32
+    face_ry_ratio: float = 0.35
+    face_erase_blur: int = 5
+    face_erase_threshold: int = 140
 
 
 def _nms_faces(faces: list, iou_thresh: float) -> list:
-    """Non-maximum suppression to remove duplicate face detections."""
     if not faces:
         return []
     boxes = np.array(faces, dtype=float)
@@ -130,13 +123,11 @@ def _nms_faces(faces: list, iou_thresh: float) -> list:
 
 
 def detect_faces(rgb: np.ndarray, cfg: LineartConfig) -> list:
-    """Detect faces and filter out false positives in lower body."""
     h = rgb.shape[0]
     gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)
     faces = []
 
     try:
-        # Load local classifiers from downloaded folder
         cascade_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "cascades")
         path_default = os.path.join(cascade_dir, 'haarcascade_frontalface_default.xml')
         path_alt = os.path.join(cascade_dir, 'haarcascade_frontalface_alt2.xml')
@@ -147,7 +138,6 @@ def detect_faces(rgb: np.ndarray, cfg: LineartConfig) -> list:
         if os.path.exists(path_alt):
             classifiers.append(cv2.CascadeClassifier(path_alt))
             
-        # Fallback to cv2 data directory if local files are missing
         if not classifiers or all(c.empty() for c in classifiers):
             classifiers = [
                 cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'),
@@ -165,38 +155,28 @@ def detect_faces(rgb: np.ndarray, cfg: LineartConfig) -> list:
                 if len(detected) > 0:
                     faces.extend(detected.tolist())
     except Exception as e:
-        print(f"[AI] Face detection failed or cascades unavailable: {e}")
+        print(f"[AI] Face detection error: {e}")
 
-    # Remove detections in lower body (false positives)
     faces = [f for f in faces if f[1] < h * cfg.face_max_y_ratio]
-
-    # Remove duplicates
-    faces = _nms_faces(faces, cfg.face_nms_iou_thresh)
-    return faces
+    return _nms_faces(faces, cfg.face_nms_iou_thresh)
 
 
 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
-    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7))
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
     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)
     return mask
 
 
 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:
-        # Use a larger kernel (at least 15) for beautiful organic curves
-        k = max(15, cfg.mask_smooth_ksize if cfg.mask_smooth_ksize % 2 == 1 else cfg.mask_smooth_ksize + 1)
+        k = max(7, 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)
 
@@ -204,15 +184,13 @@ def build_silhouette(subject_mask: np.ndarray, cfg: LineartConfig) -> np.ndarray
     silhouette = np.zeros_like(subject_mask)
     for cnt in contours:
         if cv2.contourArea(cnt) >= cfg.min_silhouette_area:
-            # Smooth contour slightly without polygonal blockiness
-            eps = 0.0012 * cv2.arcLength(cnt, True)
+            eps = 0.0008 * cv2.arcLength(cnt, True)
             smooth = cv2.approxPolyDP(cnt, eps, True)
             cv2.drawContours(silhouette, [smooth], -1, 255, cfg.silhouette_line_thickness)
     return silhouette
 
 
 def build_face_erase_mask(faces: list, shape: Tuple[int, int], cfg: LineartConfig) -> np.ndarray:
-    """Build a soft binary mask covering face interior regions."""
     h, w = shape
     mask = np.zeros((h, w), dtype=np.uint8)
     for (fx, fy, fw, fh) in faces:
@@ -221,39 +199,39 @@ def build_face_erase_mask(faces: list, shape: Tuple[int, int], cfg: LineartConfi
         rx = int(fw * cfg.face_rx_ratio)
         ry = int(fh * cfg.face_ry_ratio)
         cv2.ellipse(mask, (cx, cy), (rx, ry), 0, 0, 360, 255, -1)
-    soft = np.array(Image.fromarray(mask).filter(ImageFilter.GaussianBlur(cfg.face_erase_blur)))
-    return (soft > cfg.face_erase_threshold).astype(np.uint8) * 255
+    
+    if len(faces) > 0:
+        soft = np.array(Image.fromarray(mask).filter(ImageFilter.GaussianBlur(cfg.face_erase_blur)))
+        return (soft > cfg.face_erase_threshold).astype(np.uint8) * 255
+    return mask
 
 
 def build_interior_edges(rgb: np.ndarray, subject_mask: np.ndarray, cfg: LineartConfig) -> np.ndarray:
-    """Detect structural body lines using Canny, filtering noise."""
     gray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)
-    blurred = cv2.GaussianBlur(gray, (cfg.gaussian_ksize, cfg.gaussian_ksize), 0)
-    blurred = cv2.bilateralFilter(blurred, cfg.bilateral_d, cfg.bilateral_sigma_color, cfg.bilateral_sigma_space)
+    
+    # Reduzido o pré-processamento destrutivo de desfoque
+    if cfg.gaussian_ksize > 0:
+        gray = cv2.GaussianBlur(gray, (cfg.gaussian_ksize, cfg.gaussian_ksize), 0)
+    blurred = cv2.bilateralFilter(gray, cfg.bilateral_d, cfg.bilateral_sigma_color, cfg.bilateral_sigma_space)
+    
     edges = cv2.Canny(blurred, cfg.canny_low, cfg.canny_high)
     
-    # Erode the subject mask so Canny doesn't catch the outer boundary twice
-    erode_size = max(5, cfg.silhouette_line_thickness * 2 + 3)
+    erode_size = max(3, cfg.silhouette_line_thickness + 1)
     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)
     edges = cv2.bitwise_and(edges, eroded_mask)
 
-    # Filter out short/noisy contours
     contours, _ = cv2.findContours(edges, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
     filtered = np.zeros_like(edges)
     for cnt in contours:
         perimeter = cv2.arcLength(cnt, False)
         if perimeter > cfg.min_contour_perimeter:
-            # Simplify interior edges slightly to remove Canny wobbles while keeping natural flow
-            eps = 0.0012 * perimeter
+            eps = 0.0005 * perimeter  # Simplificação reduzida para manter curvas orgânicas
             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))
-    filtered = cv2.dilate(filtered, kernel_dilate, iterations=1)
     return filtered
 
 
@@ -272,133 +250,88 @@ def get_landmarker(model_path):
             base_options=base_options,
             output_face_blendshapes=False,
             output_facial_transformation_matrixes=False,
-            num_faces=1
+            num_faces=4  # Aumentado para suportar mais rostos caso necessário
         )
         _LANDMARKER_CACHE = vision.FaceLandmarker.create_from_options(options)
     return _LANDMARKER_CACHE
 
 
 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)
 
     try:
         import mediapipe as mp
-        from mediapipe.tasks import python
-        from mediapipe.tasks.python import vision
-
-        # Determine model path
         model_path = cfg.mediapipe_model_path
         if not model_path or not os.path.exists(model_path):
             model_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "models")
-            os.makedirs(model_dir, exist_ok=True)
             model_path = os.path.join(model_dir, "face_landmarker.task")
-            if not os.path.exists(model_path) or os.path.getsize(model_path) < 1000000:
-                print("[AI] Downloading face_landmarker.task for eyebrows...")
-                model_url = "https://storage.googleapis.com/mediapipe-models/face_landmarker/face_landmarker/float16/1/face_landmarker.task"
-                urllib.request.urlretrieve(model_url, model_path)
-                print("[AI] Download complete!")
 
+        # Índices corrigidos e completos das sobrancelhas no MediaPipe Mesh
         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)
+        eyebrow_thickness = cfg.interior_line_thickness
 
         with _LANDMARKER_LOCK:
             landmarker = get_landmarker(model_path)
             
-            # Phase 1: Global detection (upright / clear faces)
+            # Executa sempre o modelo global primeiro (MediaPipe lida bem com rostos inteiros)
             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
+                    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)
+                return eyebrows_layer # Se o global resolveu perfeitamente, retorna direto
+
+            # Se o global falhou, tenta via crops gerados pelo Haar Cascades
+            if faces is None:
+                faces = detect_faces(rgb, cfg)
+
+            for (fx, fy, fw, fh) in faces:
+                margin_x = int(fw * 0.3)
+                margin_y = int(fh * 0.3)
+                x1, y1 = max(0, fx - margin_x), max(0, fy - margin_y)
+                x2, y2 = min(w, fx + fw + margin_x), min(h, fy + fh + margin_y)
 
                 crop = rgb[y1:y2, x1:x2]
-                crop_resized = cv2.resize(crop, (512, 512), interpolation=cv2.INTER_CUBIC)
+                if crop.size == 0:
+                    continue
+                crop_resized = cv2.resize(crop, (256, 256), interpolation=cv2.INTER_LINEAR)
                 crop_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=crop_resized)
                 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)
+                    for indices in [LEFT_EYEBROW, RIGHT_EYEBROW]:
+                        points = []
+                        for idx in indices:
+                            lm = face_landmarks[idx]
+                            gx = int(x1 + (lm.x * (x2 - x1)))
+                            gy = int(y1 + (lm.y * (y2 - y1)))
+                            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}")
+        print(f"[AI] Eyebrow extraction error: {e}")
 
     return eyebrows_layer
 
 
-
-def make_faceless_lineart(
-    img: Image.Image,
-    cfg: LineartConfig = None
-) -> Image.Image:
-    """
-    Generate faceless lineart transparent image from a photo.
-    """
+def make_faceless_lineart(img: Image.Image, cfg: LineartConfig = None) -> Image.Image:
     cfg = cfg or LineartConfig()
     
-    # Preserve alpha channel if image already has a transparent background (e.g. from rembg)
     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")
         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))
@@ -411,45 +344,31 @@ 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)
-
-    # 2. Detect faces
     faces = detect_faces(rgb, cfg)
-    print(f"[lineart] Detected {len(faces)} face(s)")
 
-    # 3. Silhouette outline
     silhouette = build_silhouette(subject_mask, cfg)
-
-    # 4. Interior structural edges
     interior = build_interior_edges(rgb, subject_mask, cfg)
 
-    # 5. Erase face details (keep silhouette outline of head shape)
+    # O "Erase" agora limpa os olhos e a boca, mantendo as sobrancelhas e as bordas externas intactas
     face_erase = build_face_erase_mask(faces, (h, w), cfg)
     interior_clean = cv2.bitwise_and(interior, cv2.bitwise_not(face_erase))
 
-    # 6. Combine
     final_lines = cv2.add(silhouette, interior_clean)
 
-    # 6.5. Optional eyebrow detection overlay
     if cfg.detect_eyebrows:
         eyebrows = draw_eyebrows(rgb, cfg, faces=faces)
         final_lines = cv2.add(final_lines, eyebrows)
 
-    # Avoid drawing rectangular boxes/borders at the image edges
-    border_erase_width = max(cfg.silhouette_line_thickness, cfg.interior_line_thickness) + 2
+    border_erase_width = max(cfg.silhouette_line_thickness, cfg.interior_line_thickness) + 1
     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
-
-    transparent = Image.new("RGBA", size, (0, 0, 0, 0))
+    transparent = Image.new("RGBA", img.size, (0, 0, 0, 0))
     transparent.putalpha(alpha)
 
     return transparent
@@ -470,8 +389,7 @@ def _has_real_transparency(img: Image.Image) -> bool:
     rgba = img.convert("RGBA")
     alpha = rgba.getchannel("A")
     sample = list(alpha.getdata())
-    total = 0
-    visible = 0
+    total, visible = 0, 0
     for index in range(0, len(sample), 12):
         total += 1
         if sample[index] < 245:
@@ -484,7 +402,6 @@ def remove_background_subject(img: Image.Image) -> Image.Image:
         rgba = img.convert("RGBA")
         if _has_real_transparency(rgba):
             return rgba
-
         if _SESSION_ISNET is None:
             return rgba