Delete watermark_remover.py

watermark_remover.py

@@ -1,92 +0,0 @@
-import numpy as np
-from PIL import Image
-import io
-import os
-
-ALPHA_THRESHOLD = 0.002
-MAX_ALPHA = 0.99
-LOGO_VALUE = 255
-
-def get_alpha_map(size: int) -> np.ndarray:
-    """
-    Load the background image and calculate the alpha map.
-    """
-    bg_path = f"assets/bg_{size}.png"
-    if not os.path.exists(bg_path):
-        # Retry with absolute path relative to this file
-        base_dir = os.path.dirname(os.path.abspath(__file__))
-        bg_path = os.path.join(base_dir, "assets", f"bg_{size}.png")
-        if not os.path.exists(bg_path):
-            raise FileNotFoundError(f"Background image {bg_path} not found.")
-
-    with Image.open(bg_path) as img:
-        img = img.convert("RGBA")
-        data = np.array(img, dtype=np.float32)
-        
-        # Max of RGB channels normalized to [0, 1]
-        r = data[:, :, 0]
-        g = data[:, :, 1]
-        b = data[:, :, 2]
-        
-        max_channel = np.maximum(np.maximum(r, g), b)
-        alpha_map = max_channel / 255.0
-        return alpha_map
-
-def remove_watermark(image_bytes: bytes) -> tuple[bytes, str]:
-    """
-    Remove the Gemini watermark from an image given as bytes.
-    Returns (processed_image_bytes, format).
-    """
-    with Image.open(io.BytesIO(image_bytes)) as img:
-        img_format = img.format or 'PNG'
-        
-        if img.mode != 'RGBA' and img.mode != 'RGB':
-             img = img.convert('RGB')
-             
-        data = np.array(img, dtype=np.float32)
-        height, width = data.shape[:2]
-        
-        if width > 1024 and height > 1024:
-            logo_size = 96
-            margin_right = 64
-            margin_bottom = 64
-        else:
-            logo_size = 48
-            margin_right = 32
-            margin_bottom = 32
-            
-        x = width - margin_right - logo_size
-        y = height - margin_bottom - logo_size
-        
-        # If the image is smaller than the required margins + logo, return as is
-        if x < 0 or y < 0:
-            return image_bytes, img_format
-            
-        alpha_map = get_alpha_map(logo_size)
-        
-        # Crop the region to process
-        region = data[y:y+logo_size, x:x+logo_size, :3]
-        
-        # Apply reverse blending
-        for c in range(3):
-            # Mask applied only where alpha >= ALPHA_THRESHOLD
-            mask = alpha_map >= ALPHA_THRESHOLD
-            
-            alpha_limited = np.minimum(alpha_map[mask], MAX_ALPHA)
-            one_minus_alpha = 1.0 - alpha_limited
-            
-            watermarked = region[mask, c]
-            original = (watermarked - alpha_limited * LOGO_VALUE) / one_minus_alpha
-            
-            # Clip to [0, 255] and round
-            region[mask, c] = np.clip(np.round(original), 0, 255)
-            
-        # Update data with region
-        data[y:y+logo_size, x:x+logo_size, :3] = region
-        
-        # Create output image
-        out_img = Image.fromarray(data.astype(np.uint8), mode=img.mode)
-        out_buffer = io.BytesIO()
-        out_img.save(out_buffer, format="PNG")
-        
-        return out_buffer.getvalue(), "PNG"