Upload folder using huggingface_hub

.github/workflows/update_space.yml

@@ -0,0 +1,28 @@
+name: Run Python script
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+
+    - name: Install Gradio
+      run: python -m pip install gradio
+
+    - name: Log in to Hugging Face
+      run: python -c 'import huggingface_hub; huggingface_hub.login(token="${{ secrets.hf_token }}")'
+
+    - name: Deploy to Spaces
+      run: gradio deploy

README.md

@@ -1,12 +1,6 @@
 ---
-title: Test Test
-emoji: 🐢
-colorFrom: green
-colorTo: red
+title: test_test
+app_file: gradio_test.py
 sdk: gradio
 sdk_version: 5.23.3
-app_file: app.py
-pinned: false
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

gradio_test.py

@@ -0,0 +1,1010 @@
+import os
+import io
+import uuid
+import json
+import numpy as np
+import requests
+import gradio as gr
+from bs4 import BeautifulSoup
+from PIL import Image, ImageDraw, ImageFont
+import easyocr
+from deep_translator import GoogleTranslator, MyMemoryTranslator, LingueeTranslator, DeeplTranslator
+from typing import List, Dict, Any, Optional, Tuple, Generator
+import math # Add this import at the top
+
+# --- Configuration ---
+STATIC_DIR = "static"
+TRANSLATED_IMAGE_DIR = os.path.join(STATIC_DIR, "translated")
+FONT_PATH = "font/Movistar Text Regular.ttf"
+USE_POLLINATIONS = True  # Toggle to use Pollinations.ai for translation
+# Select which free translator to use as default
+DEFAULT_FREE_TRANSLATOR = "google"  # Options: "google", "mymemory", "linguee"
+GROUPING_VERTICAL_THRESHOLD = 25 # Pixels - Adjust as needed
+GROUPING_HORIZONTAL_OVERLAP_THRESHOLD = 0.1 # Minimum % overlap to consider horizontal grouping
+
+# --- Create necessary directories ---
+os.makedirs(TRANSLATED_IMAGE_DIR, exist_ok=True)
+
+# --- Helper Functions ---
+def calculate_font_size(text: str, max_width: float, max_height: float, font_path: str = FONT_PATH) -> int:
+    """Calculates a suitable font size to fit text within a bounding box."""
+    font_size = int(max_height * 0.8)  # Start with a reasonable guess
+    if font_size <= 0:
+        return 1  # Minimum font size
+
+    try:
+        font = ImageFont.truetype(font_path, font_size)
+        text_bbox = font.getbbox(text)
+        text_width = text_bbox[2] - text_bbox[0]
+        text_height = text_bbox[3] - text_bbox[1]
+
+        # Reduce font size until it fits (simplified approach)
+        while (text_width > max_width or text_height > max_height) and font_size > 5:
+            font_size -= 1
+            font = ImageFont.truetype(font_path, font_size)
+            text_bbox = font.getbbox(text)
+            text_width = text_bbox[2] - text_bbox[0]
+            text_height = text_bbox[3] - text_bbox[1]
+
+        return max(font_size, 5)  # Ensure a minimum size
+    except IOError:
+        print(f"Warning: Font file not found at {font_path}. Using default PIL font.")
+        # Fallback logic if font file is not found
+        return int(max_height * 0.5)  # Simplified fallback
+    except Exception as e:
+        print(f"Error calculating font size: {e}")
+        return int(max_height * 0.5)  # Simplified fallback
+
+def scrape_comic_images(url: str) -> List[str]:
+    """Scrape all comic images from the provided URL."""
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3"
+    }
+    try:
+        response = requests.get(url, headers=headers, timeout=15)
+        response.raise_for_status()  # Raise an exception for bad status codes
+
+        soup = BeautifulSoup(response.content, "html.parser")
+        images = []
+        image_urls = set()  # Use a set to avoid duplicate URLs
+
+        # Common selectors for manhwa/manhua sites
+        selectors = [
+            ".chapter-content img",
+            ".comic-container img",
+            ".reading-content img",
+            "#readerarea img",
+            ".viewer-container img",
+            "img.comic-panel"
+        ]
+
+        for selector in selectors:
+            for img in soup.select(selector):
+                src = img.get("src") or img.get("data-src") or img.get("data-original")
+                if src:
+                    # Resolve relative URLs
+                    src = requests.compat.urljoin(url, src.strip())
+                    if src not in image_urls:
+                        images.append(src)
+                        image_urls.add(src)
+
+        if not images:
+            # Fallback: Find all images if specific selectors fail
+            print("Warning: Specific selectors failed, trying to find all images.")
+            for img in soup.find_all("img"):
+                src = img.get("src") or img.get("data-src") or img.get("data-original")
+                if src:
+                    src = requests.compat.urljoin(url, src.strip())
+                    if src not in image_urls:
+                        images.append(src)
+                        image_urls.add(src)
+
+        if not images:
+            raise ValueError("Could not find any images on the page using common selectors.")
+
+        return images
+
+    except Exception as e:
+        print(f"Error scraping comic images: {e}")
+        return []
+
+def detect_text(image_content: bytes, language: str) -> List[dict]:
+    """Detect text regions in the image using OCR."""
+    try:
+        image = Image.open(io.BytesIO(image_content)).convert("RGB")
+        image_np = np.array(image)
+
+        # Initialize OCR reader
+        # Use 'ch_sim' for Simplified Chinese instead of 'zh'
+        lang_list = [lang.strip() for lang in language.split(',')] if language != "auto" else ['ko', 'ch_sim', 'ja', 'en'] 
+        print(f"Initializing EasyOCR with languages: {lang_list}")
+        reader = easyocr.Reader(lang_list, gpu=False)  # Specify gpu=False if no GPU or CUDA issues
+
+        # Detect text
+        results = reader.readtext(image_np, detail=1, paragraph=False)  # Process line by line
+
+        # Process results
+        text_regions = []
+        for bbox, text, conf in results:
+            # bbox is [[x1,y1],[x2,y1],[x2,y2],[x1,y2]]
+            # Ensure bbox coordinates are standard Python numbers
+            bbox_float = [[float(p[0]), float(p[1])] for p in bbox]
+            if conf > 0.3:  # Confidence threshold (adjust as needed)
+                text_regions.append({
+                    "bbox": bbox_float,
+                    "text": text,
+                    "confidence": float(conf)
+                })
+        print(f"Detected {len(text_regions)} text regions.")
+        return text_regions
+    except Exception as e:
+        print(f"Error during OCR detection: {e}")
+        return []
+
+def _calculate_group_bbox(regions: List[Dict]) -> List[float]:
+    """Calculates the encompassing bounding box for a list of regions."""
+    if not regions:
+        return [0, 0, 0, 0]
+    
+    min_x = min(r['bbox'][0][0] for r in regions)
+    min_y = min(r['bbox'][0][1] for r in regions)
+    max_x = max(r['bbox'][1][0] for r in regions) # Using top-right x for max_x
+    max_y = max(r['bbox'][2][1] for r in regions) # Using bottom-right y for max_y
+    
+    # Ensure coordinates are valid
+    min_x = max(0, min_x)
+    min_y = max(0, min_y)
+    # Assuming max_x and max_y will be derived from valid regions
+    
+    # Return as [x1, y1, x2, y2] format for consistency
+    return [min_x, min_y, max_x, max_y]
+
+# Define utility functions for rectangle operations
+def rect_distance(rect1, rect2):
+    """Calculate the distance between two rectangles (bounding boxes)"""
+    # Convert from [[x1,y1],[x2,y1],[x2,y2],[x1,y2]] format to [x1,y1,x2,y2]
+    r1 = [rect1[0][0], rect1[0][1], rect1[2][0], rect1[2][1]]
+    r2 = [rect2[0][0], rect2[0][1], rect2[2][0], rect2[2][1]]
+    
+    # Check for overlap
+    if (r1[0] <= r2[2] and r2[0] <= r1[2] and r1[1] <= r2[3] and r2[1] <= r1[3]):
+        return 0  # Rectangles overlap
+    
+    # Calculate distances
+    dx = max(0, max(r1[0], r2[0]) - min(r1[2], r2[2]))
+    dy = max(0, max(r1[1], r2[1]) - min(r1[3], r2[3]))
+    
+    # Return Euclidean distance
+    return math.sqrt(dx*dx + dy*dy)
+
+def rect_center(rect):
+    """Calculate the center point of a rectangle"""
+    # Convert from [[x1,y1],[x2,y1],[x2,y2],[x1,y2]] format
+    x1, y1 = rect[0]
+    x2, y2 = rect[2]
+    return [(x1 + x2) / 2, (y1 + y2) / 2]
+
+def rect_contains_point(rect, point):
+    """Check if a rectangle contains a point"""
+    # Convert from [[x1,y1],[x2,y1],[x2,y2],[x1,y2]] format
+    x1, y1 = rect[0]
+    x2, y2 = rect[2]
+    px, py = point
+    return x1 <= px <= x2 and y1 <= py <= y2
+
+def expand_rect(rect1, rect2):
+    """Create a new rectangle that encompasses both input rectangles"""
+    # Convert from [[x1,y1],[x2,y1],[x2,y2],[x1,y2]] format
+    x1_1, y1_1 = rect1[0]
+    x2_1, y2_1 = rect1[2]
+    x1_2, y1_2 = rect2[0]
+    x2_2, y2_2 = rect2[2]
+    
+    # Find the min/max coordinates
+    x1 = min(x1_1, x1_2)
+    y1 = min(y1_1, y1_2)
+    x2 = max(x2_1, x2_2)
+    y2 = max(y2_1, y2_2)
+    
+    # Return in the format [[x1,y1],[x2,y1],[x2,y2],[x1,y2]]
+    return [[x1, y1], [x2, y1], [x2, y2], [x1, y2]]
+
+def is_valid_rect(rect):
+    """Validate rectangle properties"""
+    # Convert from [[x1,y1],[x2,y1],[x2,y2],[x1,y2]] format
+    x1, y1 = rect[0]
+    x2, y2 = rect[2]
+    
+    # Check if width and height are positive
+    return x2 > x1 and y2 > y1
+
+def group_text_regions(regions: List[Dict], 
+                       proximity_threshold: float = 100.0) -> List[Dict]:
+    """Groups text regions based on proximity and overlap to identify speech bubbles."""
+    if not regions:
+        return []
+
+    # Extract bounding boxes from regions
+    bboxes = [region['bbox'] for region in regions]
+    
+    # Dictionary to track which rectangles have been grouped
+    grouped = [False] * len(bboxes)
+    
+    # List to store the grouped rectangles
+    grouped_boxes = []
+    
+    # Group rectangles based on proximity and overlap
+    for i in range(len(bboxes)):
+        if grouped[i]:
+            continue  # Skip if already grouped
+            
+        # Start a new group with this rectangle
+        current_group = bboxes[i]
+        grouped[i] = True
+        
+        # Flag to check if we made any changes in this pass
+        made_changes = True
+        
+        # Keep expanding the group until no more changes
+        while made_changes:
+            made_changes = False
+            
+            for j in range(len(bboxes)):
+                if grouped[j]:
+                    continue  # Skip if already grouped
+                
+                # Check if this rectangle should be added to the current group
+                if rect_distance(current_group, bboxes[j]) < proximity_threshold:
+                    # Expand the current group to include this rectangle
+                    current_group = expand_rect(current_group, bboxes[j])
+                    grouped[j] = True
+                    made_changes = True
+        
+        # Add the final group to our list if it's valid
+        if is_valid_rect(current_group):
+            grouped_boxes.append(current_group)
+    
+    # Now combine text from all regions within each group
+    result_groups = []
+    
+    for group_bbox in grouped_boxes:
+        # Find all regions whose center is within this group
+        group_regions = []
+        group_text = ""
+        
+        for region in regions:
+            center = rect_center(region['bbox'])
+            if rect_contains_point(group_bbox, center):
+                group_regions.append(region)
+                # Add space between text fragments
+                if group_text:
+                    group_text += " "
+                group_text += region['text']
+        
+        # Create the grouped region
+        if group_regions:
+            result_groups.append({
+                "text": group_text,
+                "bbox": group_bbox,
+                "original_regions": group_regions,
+                "is_group": True
+            })
+    
+    # Debug output
+    print(f"Proximity-based grouping: {len(regions)} individual regions into {len(result_groups)} speech bubbles.")
+    
+    return result_groups
+
+def translate_with_pollinations(texts: List[str], src_lang: str, target_lang: str) -> List[Dict[str, str]]:
+    """Translate texts using Pollinations.ai API."""
+    if not texts:
+        return []
+        
+    try:
+        # Convert language codes to what Pollinations expects
+        lang_map = {
+            "zh": "zh-CN",
+            "ko": "ko",
+            "ja": "ja",
+            "en": "en",
+            "auto": "auto"
+        }
+        
+        # Map our language codes to Pollinations expected codes
+        src_lang_mapped = lang_map.get(src_lang, src_lang)
+        target_lang_mapped = lang_map.get(target_lang, target_lang)
+        
+        # Preparing batch of at least 10 texts for translation
+        batch_texts = texts.copy()
+        while len(batch_texts) < 10:
+            batch_texts.extend(texts[:min(len(texts), 10-len(batch_texts))])
+        
+        # Prepare the system prompt for the translation task
+        system_prompt = f"You are a professional translator. Translate the following texts from {src_lang_mapped} to {target_lang_mapped}. Preserve the meaning, tone, and style of the original text. Return the results in JSON format with 'original' and 'translated' keys for each text."
+        
+        # Create the user prompt with the texts to translate
+        user_prompt = "Translate these texts and return a JSON array with objects containing 'original' and 'translated' properties:\n"
+        for i, text in enumerate(batch_texts):
+            user_prompt += f"{i+1}. {text}\n"
+        
+        # Prepare the API request to Pollinations.ai
+        api_url = "https://api.pollinations.ai/v2/generate/text"
+        headers = {
+            "Content-Type": "application/json"
+        }
+        
+        payload = {
+            "model": "openai",  # Using OpenAI model as it's good for translation
+            "prompt": user_prompt,
+            "system": system_prompt,
+            "jsonMode": True,  # Request JSON output
+            "reasoning_effort": "high",  # Higher quality translations
+            "private": True,
+            "referrer": "manga_ocr_translator"
+        }
+        
+        print(f"Sending batch of {len(batch_texts)} texts to Pollinations.ai for translation")
+        response = requests.post(api_url, headers=headers, json=payload, timeout=60)
+        response.raise_for_status()
+        
+        # Parse the response
+        result = response.json()
+        translated_text = result.get("response", "")
+        
+        # The response should be a JSON string that we need to parse
+        try:
+            translated_data = json.loads(translated_text)
+            
+            # Map the translation results back to the original texts
+            # Create a mapping of original text to its translation
+            translation_map = {}
+            for item in translated_data:
+                if isinstance(item, dict) and "original" in item and "translated" in item:
+                    translation_map[item["original"]] = item["translated"]
+            
+            # Apply translations to our original texts list
+            translated_results = []
+            for text in texts:
+                translated_results.append({
+                    "original": text,
+                    "translated": translation_map.get(text, text)  # Default to original if not found
+                })
+                print(f"Pollinations translation: '{text}' -> '{translation_map.get(text, text)}'")
+            
+            return translated_results
+            
+        except json.JSONDecodeError as e:
+            print(f"Error parsing translation response as JSON: {e}")
+            print(f"Raw response: {translated_text}")
+            # Fallback: Return original texts
+            return [{"original": text, "translated": text} for text in texts]
+            
+    except Exception as e:
+        print(f"Error with Pollinations.ai translation: {e}")
+        # Return original texts as fallback
+        return [{"original": text, "translated": text} for text in texts]
+
+def translate_with_free_translator(texts: List[str], src_lang: str, target_lang: str, 
+                                  translator_type: str = DEFAULT_FREE_TRANSLATOR) -> List[Dict[str, str]]:
+    """Translate texts using available free translation APIs."""
+    if not texts:
+        return []
+    
+    # Debug info
+    print(f"Translating {len(texts)} texts using {translator_type} translator")
+    print(f"Source language: {src_lang}, Target language: {target_lang}")
+    
+    # Standardize language codes for different services
+    lang_map = {
+        # ISO-639 language code mapping for various services
+        "auto": "auto",
+        "en": "en",
+        "zh": "zh-CN",
+        "ja": "ja",
+        "ko": "ko",
+        "es": "es",
+        "fr": "fr",
+        "de": "de",
+        "it": "it",
+        "pt": "pt",
+        "ru": "ru"
+    }
+    
+    # Map to standardized language codes if available, otherwise use as-is
+    std_src_lang = lang_map.get(src_lang, src_lang)
+    std_target_lang = lang_map.get(target_lang, target_lang)
+    
+    translated_results = []
+    
+    try:
+        # Select translator based on specified type
+        if translator_type == "google":
+            # Google Translate (free tier without API key)
+            translator = GoogleTranslator(source=std_src_lang if std_src_lang != "auto" else "auto", 
+                                         target=std_target_lang)
+            
+            for text in texts:
+                if not text or len(text.strip()) < 2:
+                    translated_results.append({"original": text, "translated": text})
+                    continue
+                
+                try:
+                    translated = translator.translate(text)
+                    translated_results.append({
+                        "original": text,
+                        "translated": translated or text  # Fallback to original if None
+                    })
+                    print(f"Translated: '{text}' -> '{translated}'")
+                except Exception as e:
+                    print(f"Error translating text '{text}': {e}")
+                    translated_results.append({"original": text, "translated": text})
+        
+        elif translator_type == "mymemory":
+            # MyMemory (free with limits)
+            translator = MyMemoryTranslator(source=std_src_lang if std_src_lang != "auto" else "auto", 
+                                           target=std_target_lang)
+            
+            for text in texts:
+                if not text or len(text.strip()) < 2:
+                    translated_results.append({"original": text, "translated": text})
+                    continue
+                
+                try:
+                    translated = translator.translate(text)
+                    translated_results.append({
+                        "original": text,
+                        "translated": translated or text
+                    })
+                    print(f"Translated: '{text}' -> '{translated}'")
+                except Exception as e:
+                    print(f"Error translating text '{text}': {e}")
+                    translated_results.append({"original": text, "translated": text})
+        
+        elif translator_type == "linguee":
+            # Linguee (free)
+            # Note: Linguee has limited language support
+            try:
+                translator = LingueeTranslator(source=std_src_lang, target=std_target_lang)
+                
+                for text in texts:
+                    if not text or len(text.strip()) < 2:
+                        translated_results.append({"original": text, "translated": text})
+                        continue
+                    
+                    try:
+                        translated = translator.translate(text)
+                        translated_results.append({
+                            "original": text,
+                            "translated": translated or text
+                        })
+                        print(f"Translated: '{text}' -> '{translated}'")
+                    except Exception as e:
+                        print(f"Error translating text '{text}': {e}")
+                        translated_results.append({"original": text, "translated": text})
+            except Exception as e:
+                print(f"Linguee translator error: {e}. Falling back to Google Translate.")
+                # Fallback to Google Translate
+                return translate_with_free_translator(texts, src_lang, target_lang, "google")
+        
+        else:
+            # Default fallback to Google
+            print(f"Unknown translator type '{translator_type}', using Google Translate as fallback")
+            return translate_with_free_translator(texts, src_lang, target_lang, "google")
+    
+    except Exception as e:
+        print(f"Error setting up translator: {e}")
+        # Return original texts if translation fails
+        for text in texts:
+            translated_results.append({"original": text, "translated": text})
+    
+    return translated_results
+
+def translate_grouped_regions(grouped_regions: List[Dict], src_lang: str, target_lang: str, use_pollinations: bool = False, 
+                              free_translator: str = DEFAULT_FREE_TRANSLATOR) -> List[Dict]:
+    """Translate text within grouped regions."""
+    if not grouped_regions:
+        return []
+
+    # Add translated_text to all regions with original text as a fallback
+    for region in grouped_regions:
+        region["translated_text"] = region["text"]  # Default fallback for the group
+
+    # Extract all texts (already grouped) for translation
+    texts_to_translate = [region["text"] for region in grouped_regions if region["text"] and len(region["text"].strip()) >= 2]
+    
+    if not texts_to_translate:
+        print("No valid grouped texts to translate")
+        return grouped_regions # Return groups with original text as fallback
+        
+    try:
+        print(f"Translating {len(texts_to_translate)} grouped texts from '{src_lang}' to '{target_lang}'...")
+        
+        translation_results = []
+        # Use Pollinations.ai for translation if enabled
+        if use_pollinations and USE_POLLINATIONS:
+            print("Using Pollinations.ai for translation")
+            translation_results = translate_with_pollinations(texts_to_translate, src_lang, target_lang)
+            
+        # Otherwise, use selected free translator
+        else:
+            print(f"Using free translator: {free_translator}")
+            translation_results = translate_with_free_translator(
+                texts_to_translate, 
+                src_lang, 
+                target_lang, 
+                free_translator
+            )
+        
+        # Create a dictionary mapping original grouped text to translated text
+        # Ensure the results match the input order
+        translations_dict = {item["original"]: item["translated"] for item in translation_results}
+        
+        # Apply translations back to the grouped regions
+        for region in grouped_regions:
+            original_text = region["text"]
+            if original_text in translations_dict:
+                region["translated_text"] = translations_dict[original_text]
+                print(f"  Applied translation to group: '{original_text}' -> '{region['translated_text']}'")
+            else:
+                 print(f"  Warning: Translation not found for group text: '{original_text}'") # Should not happen if results map correctly
+
+        return grouped_regions
+
+    except Exception as e:
+        print(f"Error during grouped translation setup: {e}")
+        # Fallback already handled by setting original text
+        return grouped_regions
+
+def overlay_grouped_text(image_content: bytes, translated_grouped_regions: List[dict]) -> Image.Image:
+    """Overlay translated grouped text onto the original image and return the PIL Image."""
+    try:
+        image = Image.open(io.BytesIO(image_content)).convert("RGBA")
+        draw = ImageDraw.Draw(image)
+        
+        # Sort regions by area (smallest to largest) to ensure smaller bubbles are processed later
+        # This helps with overlapping bubbles, as smaller ones often appear on top
+        sorted_regions = sorted(translated_grouped_regions, 
+                               key=lambda r: (r.get("bbox")[2][0] - r.get("bbox")[0][0]) * 
+                                           (r.get("bbox")[2][1] - r.get("bbox")[0][1]) 
+                               if r.get("bbox") else 0)
+
+        for group in sorted_regions:
+            if "translated_text" not in group or not group.get("is_group", False):
+                print("Skipping non-group or untranslated region in overlay.")
+                continue 
+
+            group_bbox_corners = group["bbox"] # This is the combined bbox for the group
+            translated_text = group["translated_text"]
+
+            # Extract combined bounding box coordinates [x1, y1, x2, y2]
+            x1, y1 = group_bbox_corners[0] # Top-left
+            x2, y2 = group_bbox_corners[2] # Bottom-right
+            
+            # Basic validation
+            if x1 >= x2 or y1 >= y2:
+                 print(f"Warning: Degenerate group bbox found: {group_bbox_corners}. Skipping group.")
+                 continue
+                 
+            width, height = x2 - x1, y2 - y1
+            if width <= 0 or height <= 0:
+                 print(f"Warning: Non-positive dimensions for group bbox: {group_bbox_corners}. Skipping group.")
+                 continue
+
+            # --- Background Clearing ---
+            # Apply a more generous padding to ensure no text from other bubbles bleeds in
+            padding = max(10, int(min(width, height) * 0.1))  # Increased padding for better erasure
+            
+            # For more complete text removal, we'll clear both the group bounding box and each original region
+            
+            # 1. First clear the entire group bounding box with padding
+            for px in range(int(x1 - padding), int(x2 + padding + 1)):
+                for py in range(int(y1 - padding), int(y2 + padding + 1)):
+                    if 0 <= px < image.width and 0 <= py < image.height:
+                        image.putpixel((px, py), (255, 255, 255, 255))  # White background
+            
+            # 2. For more thorough clearing, also clear each original region with its own padding
+            # This helps ensure we catch text that might be outside the main group bbox
+            if "original_regions" in group:
+                for orig_region in group["original_regions"]:
+                    orig_bbox = orig_region["bbox"]
+                    orig_x1, orig_y1 = orig_bbox[0]
+                    orig_x2, orig_y2 = orig_bbox[2]
+                    # Add extra padding specifically for original regions
+                    region_padding = max(8, int(min(orig_x2 - orig_x1, orig_y2 - orig_y1) * 0.15))
+                    
+                    # Clear each original region with its own padding
+                    for px in range(int(orig_x1 - region_padding), int(orig_x2 + region_padding + 1)):
+                        for py in range(int(orig_y1 - region_padding), int(orig_y2 + region_padding + 1)):
+                            if 0 <= px < image.width and 0 <= py < image.height:
+                                image.putpixel((px, py), (255, 255, 255, 255))  # White background
+            
+            print(f"Cleared background for text region and {len(group.get('original_regions', []))} original regions")
+            
+            # --- Font Calculation with Wrapping Logic ---
+            # Get an initial font size estimate
+            initial_font_size = calculate_font_size(translated_text, width, height, FONT_PATH)
+            try:
+                font = ImageFont.truetype(FONT_PATH, initial_font_size)
+            except Exception as e:
+                print(f"Error loading font size {initial_font_size}: {e}. Using default.")
+                try: 
+                    font = ImageFont.load_default()
+                except Exception as font_e:
+                    print(f"Error loading default font: {font_e}. Cannot draw text.")
+                    continue
+            
+            # Calculate effective drawing area (with reduced width for better aesthetics)
+            effective_width = width * 0.9  # Reduce slightly to avoid text touching edges
+            effective_height = height * 0.9
+            
+            # Determine if text needs wrapping
+            text_lines = []
+            words = translated_text.split()
+            current_line = words[0] if words else ""
+            
+            # Simple word wrapping algorithm
+            for word in words[1:]:
+                test_line = current_line + " " + word
+                # Use getbbox for more accurate width calculation during wrapping check
+                line_bbox_wrap = font.getbbox(test_line)
+                line_width_wrap = line_bbox_wrap[2] - line_bbox_wrap[0]
+                
+                if line_width_wrap <= effective_width:
+                    current_line = test_line
+                else:
+                    text_lines.append(current_line)
+                    current_line = word
+            
+            # Add the last line
+            if current_line:
+                text_lines.append(current_line)
+            
+            # If no lines were created (empty text), skip
+            if not text_lines:
+                continue
+                
+            # --- Font Calculation & Line Height (Robust Spacing) ---
+            # Use getbbox for line height calculation based on a reference string
+            line_bbox_ref = font.getbbox("Tg")
+            line_height_metric = line_bbox_ref[3] - line_bbox_ref[1] # Height of the bbox
+            # Increase spacing significantly - force separation
+            line_spacing_factor = 2.0 
+            line_height = line_height_metric * line_spacing_factor
+            print(f"Using bbox height for metric: {line_height_metric:.2f}, Aggressive Line Height ({line_spacing_factor}x): {line_height:.2f}")
+            
+            # Approximate total height for resizing check
+            total_text_height_check = line_height * len(text_lines) 
+            
+            # If wrapped text is too tall, recalculate font size
+            if total_text_height_check > effective_height:
+                print(f"Resizing font: Estimated wrapped height ({total_text_height_check:.1f}) > effective height ({effective_height:.1f})")
+                scale_factor = effective_height / total_text_height_check 
+                new_font_size = max(6, int(initial_font_size * scale_factor)) # Min size 6pt
+                print(f"Original font size: {initial_font_size}, New font size: {new_font_size}")
+                try:
+                    font = ImageFont.truetype(FONT_PATH, new_font_size)
+                    # Recalculate line height metric and line height with new font
+                    line_bbox_ref = font.getbbox("Tg")
+                    line_height_metric = line_bbox_ref[3] - line_bbox_ref[1]
+                    line_height = line_height_metric * line_spacing_factor # Apply same spacing factor
+                    print(f"Recalculated Aggressive Line Height after resize: {line_height:.2f}")
+                except Exception as e:
+                    print(f"Error loading adjusted font: {e}")
+            
+            # Final font decided. Get its metrics if needed elsewhere, but height is set.
+            print(f"Final line height for drawing: {line_height:.2f}")
+            
+            # --- Draw Text (Robust Top-Left Stacking) ---
+            try:
+                # Calculate vertical starting position for the *top* of the first line
+                total_drawn_height = line_height * len(text_lines) # Total height including full spacing for all lines
+                start_y_top = y1 + (height - total_drawn_height) / 2
+                print(f"Drawing text block: Total Height={total_drawn_height:.1f}, Start Top Y={start_y_top:.1f}")
+                
+                # Draw each line using top-left anchor and explicit vertical step
+                for i, line in enumerate(text_lines):
+                    # Use getlength for precise width if possible
+                    try:
+                        line_width = font.getlength(line)
+                    except AttributeError:
+                        line_bbox_draw = font.getbbox(line, anchor="lt") # Use top-left anchor for bbox width
+                        line_width = line_bbox_draw[2] - line_bbox_draw[0]
+
+                    draw_x = x1 + (width - line_width) / 2
+                    # Position the *top* of the current line
+                    draw_y_top = start_y_top + (i * line_height)
+                    
+                    print(f"  Drawing line {i+1}/{len(text_lines)}: '{line}' at Top-Left ({draw_x:.1f}, {draw_y_top:.1f}) Width={line_width:.1f}")
+
+                    # Basic bounds check for top-left corner
+                    draw_x = max(padding, min(image.width - padding - line_width, draw_x))
+                    draw_y_top = max(padding, min(image.height - padding - line_height_metric, draw_y_top)) # Check against metric height
+                    
+                    # Draw using Pillow's stroke feature with top-left anchor
+                    stroke_width = max(1, int(initial_font_size * 0.08))
+                    draw.text(
+                        (draw_x, draw_y_top),
+                        line,
+                        font=font,
+                        fill="black",
+                        anchor="lt", # Use top-left anchor
+                        stroke_width=stroke_width,
+                        stroke_fill="white"
+                    )
+                
+                print(f"Drew wrapped text ({len(text_lines)} lines) in bbox [{x1:.0f},{y1:.0f} - {x2:.0f},{y2:.0f}]")
+                
+            except Exception as draw_e:
+                print(f"Error drawing text: {draw_e}")
+
+        # Debug statement to confirm processing is complete
+        print(f"Overlay complete. Processed {len(sorted_regions)} regions.")
+        return image
+
+    except Exception as e:
+        print(f"Error during image overlay: {e}")
+        import traceback
+        traceback.print_exc()
+        # Return original image in case of error
+        return Image.open(io.BytesIO(image_content))
+
+# --- Gradio Functions ---
+
+def translate_manga_page(url: str, source_language: str, target_language: str, 
+                           use_pollinations: bool = False, free_translator: str = DEFAULT_FREE_TRANSLATOR) -> Generator[Tuple[Optional[str], Optional[Image.Image]], None, None]:
+    """Process manga URL, yielding status and translated images one by one."""
+    processed_count = 0
+    total_images = 0
+    try:
+        # Scrape image URLs
+        print(f"Scraping images from: {url}")
+        yield f"Scraping images from URL...", None
+        image_urls = scrape_comic_images(url)
+        total_images = len(image_urls)
+        if not image_urls:
+            print("No images found at the URL.")
+            yield "No images found at the URL.", None
+            return
+        
+        yield f"Found {total_images} images. Starting processing...", None
+        print(f"Found {total_images} images.")
+        
+        if len(image_urls) > 5:
+            print("Limiting to the first 5 images for translation.")
+            image_urls_to_process = image_urls[0:5]
+        else:
+            image_urls_to_process = image_urls
+        for i, image_url in enumerate(image_urls_to_process):
+            current_status = f"Processing image {i+1}/{len(image_urls_to_process)}: {os.path.basename(image_url)}"
+            print(current_status)
+            yield current_status, None # Yield status update
+            
+            try:
+                img_response = requests.get(image_url, timeout=15)
+                img_response.raise_for_status()
+                image_content = img_response.content
+                
+                # 1. Detect text regions
+                text_regions = detect_text(image_content, source_language)
+                
+                if not text_regions:
+                    print("No text detected in this image.")
+                    continue # Skip this image if no text found
+                
+                # 2. Group detected regions
+                grouped_regions = group_text_regions(text_regions)
+                if not grouped_regions:
+                     print("No groups formed from detected text.")
+                     continue # Skip if grouping fails
+
+                # 3. Translate grouped text
+                translated_grouped_regions = translate_grouped_regions(
+                    grouped_regions, 
+                    source_language, 
+                    target_language, 
+                    use_pollinations,
+                    free_translator
+                )
+                
+                # 4. Overlay translated grouped text
+                translated_image = overlay_grouped_text(image_content, translated_grouped_regions)
+                
+                # 5. Yield the translated image
+                yield None, translated_image 
+                processed_count += 1
+                print(f"Successfully processed and yielded image {i+1}.")
+                
+            except requests.exceptions.RequestException as req_e:
+                 print(f"Failed to download image {image_url}: {req_e}")
+                 yield f"Failed to download image {i+1}", None
+            except Exception as e:
+                print(f"Error processing image {image_url}: {e}")
+                yield f"Error processing image {i+1}", None 
+                continue
+        
+        yield f"Finished processing. Successfully translated {processed_count}/{len(image_urls_to_process)} images.", None
+            
+    except Exception as e:
+        print(f"Error in translate_manga_page: {e}")
+        yield f"An error occurred during the process: {str(e)}", None
+    finally:
+        print(f"Translation process ended. Processed {processed_count} images.")
+
+def batch_translate_text(texts: str, source_language: str, target_language: str) -> str:
+    """Translate batch of texts using Pollinations.ai."""
+    # Split text into lines and filter out empty ones
+    text_list = [line.strip() for line in texts.split('\n') if line.strip()]
+    
+    if not text_list:
+        return "No text provided for translation."
+    
+    try:
+        # Translate the texts
+        translated_results = translate_with_pollinations(text_list, source_language, target_language)
+        
+        # Format results
+        output = "Translation Results:\n\n"
+        for item in translated_results:
+            output += f"Original: {item['original']}\nTranslated: {item['translated']}\n\n"
+        
+        return output
+    
+    except Exception as e:
+        print(f"Error in batch_translate_text: {e}")
+        return f"An error occurred during translation: {str(e)}"
+
+# --- Gradio Interface ---
+
+# CSS for vertical scrolling in the image column
+css = """
+#image-column {
+    max-height: 80vh; /* Adjust height as needed */
+    overflow-y: auto;
+}
+"""
+
+with gr.Blocks(title="Manga Translator", theme=gr.themes.Soft(), css=css) as app:
+    gr.Markdown("# Manga Translator with AI 🌐")
+    
+    with gr.Tab("Translate Manga Pages"):
+        with gr.Row():
+            with gr.Column():
+                url_input = gr.Textbox(label="Manga URL", placeholder="Enter manga chapter URL")
+                source_language = gr.Dropdown(
+                    choices=["auto", "ja", "ko", "zh"],
+                    value="auto",
+                    label="Source Language"
+                )
+                target_language = gr.Dropdown(
+                    choices=["en", "es", "fr", "de", "it", "pt", "ru"],
+                    value="en",
+                    label="Target Language"
+                )
+                translator_option = gr.Radio(
+                    choices=["pollinations", "google", "mymemory", "linguee"],
+                    value="pollinations",
+                    label="Translation Engine"
+                )
+                translate_button = gr.Button("Translate Manga")
+                
+        with gr.Row():
+            # Use Textbox for status updates
+            translation_status = gr.Textbox(label="Status", value="Idle", interactive=False)
+        
+        # Create an output gallery instead of a column for better image display
+        output_gallery = gr.Gallery(
+            label="Translation Results",
+            columns=1,
+            rows=None,
+            object_fit="contain",
+            height="auto",
+            preview=True
+        )
+    
+    with gr.Tab("Direct Text Translation"):
+        with gr.Row():
+            with gr.Column():
+                batch_text = gr.Textbox(
+                    label="Enter Text (one per line)",
+                    placeholder="Enter text to translate (one segment per line)",
+                    lines=10
+                )
+                with gr.Row():
+                    with gr.Column():
+                        batch_source_language = gr.Dropdown(
+                            choices=["auto", "ja", "ko", "zh", "en"],
+                            value="auto",
+                            label="Source Language"
+                        )
+                    with gr.Column():
+                        batch_target_language = gr.Dropdown(
+                            choices=["en", "es", "fr", "de", "it", "pt", "ru", "ja", "ko", "zh"],
+                            value="en",
+                            label="Target Language"
+                        )
+                batch_translator_option = gr.Radio(
+                    choices=["pollinations", "google", "mymemory", "linguee"],
+                    value="pollinations",
+                    label="Translation Engine"
+                )
+                batch_translate_btn = gr.Button("Translate Text")
+        
+        batch_result = gr.Textbox(
+            label="Translation Results",
+            lines=15,
+            interactive=False
+        )
+    
+    # Event handlers
+    def process_manga_stream(url, src_lang, tgt_lang, translator):
+        """Handles the streaming process for manga translation, yielding images to a gallery."""
+        if not url or url.strip() == "":
+            yield "Please enter a valid URL", []
+            return
+        
+        # Determine which translator to use
+        use_pollinations = (translator == "pollinations")
+        free_translator = translator if not use_pollinations else DEFAULT_FREE_TRANSLATOR
+
+        translated_images = [] # Use a list to accumulate images
+        final_status = "Process started..."
+
+        # Iterate through the generator
+        for status_update, image_result in translate_manga_page(url, src_lang, tgt_lang, use_pollinations, free_translator):
+            
+            if status_update:
+                final_status = status_update # Update status message
+            
+            if image_result:
+                # Convert PIL image to NumPy array
+                if image_result.mode == 'RGBA':
+                    image_result = image_result.convert('RGB')
+                numpy_image = np.array(image_result)
+                translated_images.append(numpy_image)
+                
+                # Debug print - helps track if images are being processed
+                print(f"Added new image to gallery. Total images: {len(translated_images)}")
+            
+            # Yield the current status and updated list of images
+            yield final_status, translated_images
+            
+        # Final yield after the loop finishes
+        yield final_status, translated_images
+
+    
+    def translate_batch_text(texts, src_lang, tgt_lang, translator):
+        """Translate batch of texts using selected translation engine."""
+        # ... (batch translation logic remains the same) ...
+        text_list = [line.strip() for line in texts.split('\n') if line.strip()]
+        if not text_list: return "No text provided for translation."
+        try:
+            if translator == "pollinations":
+                results = translate_with_pollinations(text_list, src_lang, tgt_lang)
+            else:
+                results = translate_with_free_translator(text_list, src_lang, tgt_lang, translator)
+            output = f"Translation Results (using {translator}):\n\n"
+            for item in results:
+                output += f"Original: {item['original']}\nTranslated: {item['translated']}\n\n"
+            return output
+        except Exception as e:
+            print(f"Error in batch_translate_text: {e}")
+            return f"An error occurred: {str(e)}"
+    
+    translate_button.click(
+        process_manga_stream,
+        inputs=[url_input, source_language, target_language, translator_option],
+        outputs=[translation_status, output_gallery]
+    )
+    
+    batch_translate_btn.click(
+        translate_batch_text,
+        inputs=[batch_text, batch_source_language, batch_target_language, batch_translator_option],
+        outputs=batch_result
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    print("Starting Gradio app for Manga Translation...")
+    print(f"Default free translator: {DEFAULT_FREE_TRANSLATOR}")
+    app.launch(share=False)
+    # Use app.launch(share=True) if you want to create a shareable link