Restore

.gitignore

@@ -19,7 +19,7 @@ wheels/
 *.egg-info/
 .installed.cfg
 *.egg
-*.zip
+
 # Virtual environments
 .env
 .venv

.replit

@@ -4,7 +4,7 @@ expertMode = true
 
 [nix]
 channel = "stable-25_05"
-packages = ["freetype", "gut", "lcms2", "libimagequant", "libjpeg", "libjpeg_turbo", "libpng", "libtiff", "libwebp", "libxcrypt", "oneDNN", "openjpeg", "re2", "tcl", "tk", "which", "zlib", "python313Packages.huggingface-hub"]
+packages = ["freetype", "lcms2", "libimagequant", "libjpeg_turbo", "libpng", "libtiff", "libwebp", "libxcrypt", "tcl", "tk", "which", "zlib", "gut"]
 
 [workflows]
 runButton = "Project"
@@ -22,18 +22,22 @@ args = "AI Image Enhancer"
 name = "AI Image Enhancer"
 author = "agent"
 
-[workflows.workflow.metadata]
-outputType = "webview"
-
 [[workflows.workflow.tasks]]
 task = "shell.exec"
-args = "python -m uvicorn app:app --host 0.0.0.0 --port 5000"
+args = "python app_local.py"
 waitForPort = 5000
 
+[workflows.workflow.metadata]
+outputType = "webview"
+
 [[ports]]
 localPort = 5000
 externalPort = 80
 
+[[ports]]
+localPort = 38887
+externalPort = 3000
+
 [[ports]]
 localPort = 39671
 externalPort = 3002

README.md

@@ -10,69 +10,34 @@ license: mit
 
 # AI Image Processing API
 
-A comprehensive image processing API powered by HuggingFace Inference API with multiple AI features including text-to-image generation, super-resolution, background removal, noise reduction, and document scanning.
+A comprehensive image processing API with multiple AI-powered features including super-resolution, background removal, noise reduction, and document scanning.
 
 ## Features
 
-- **Image Generation**: Create images from text prompts using Stable Diffusion XL
-- **Image Enhancement**: Upscale images 2x or 4x using SD x4 Upscaler
-- **Background Removal**: Remove backgrounds using RMBG-1.4 AI model
+- **Image Enhancement**: Upscale images 2x or 4x using Real-ESRGAN
+- **Background Removal**: Remove backgrounds using BiRefNet AI model via rembg
 - **Noise Reduction**: Reduce image noise using OpenCV Non-Local Means Denoising
 - **Document Scanning**: Auto-crop, align, and enhance document photos with AI
-- **Async Processing**: All endpoints support async mode with progress tracking
 - **RESTful API**: Full API with automatic OpenAPI/Swagger documentation
 - **Web Interface**: Simple drag-and-drop interface for testing
 
 ## API Endpoints
 
-### Image Generation
-#### `POST /generate`
-Generate images from text prompts using Stable Diffusion XL.
-
-**Parameters:**
-- `prompt`: Text description of the image to generate (required)
-- `negative_prompt`: What to avoid in the image (optional)
-- `width`: Image width 512-1024 (default: 1024)
-- `height`: Image height 512-1024 (default: 1024)
-- `guidance_scale`: Prompt adherence 1-20 (default: 7.5)
-- `steps`: Inference steps 20-100 (default: 50)
-- `async_mode`: Use async mode with progress tracking (default: false)
-
-#### `POST /generate/async`
-Start async image generation with progress tracking.
-
-#### `POST /generate/base64`
-Generate an image and return as base64-encoded string.
-
 ### Image Enhancement
 #### `POST /enhance`
-Upscale and enhance image quality using SD x4 Upscaler via HuggingFace.
+Upscale and enhance image quality using Real-ESRGAN.
 
 **Parameters:**
 - `file`: Image file (PNG, JPG, JPEG, WebP, BMP)
 - `scale`: Upscale factor (2 or 4, default: 4)
-- `async_mode`: Use async mode with progress tracking (default: false)
-
-#### `POST /enhance/async`
-Start async image enhancement with progress tracking.
-
-#### `POST /enhance/base64`
-Enhance an image and return as base64-encoded string.
 
 ### Background Removal
 #### `POST /remove-background`
-Remove background from an image using RMBG-1.4 via HuggingFace.
+Remove background from an image using BiRefNet AI model.
 
 **Parameters:**
 - `file`: Image file
 - `bgcolor`: Background color - 'transparent', 'white', 'black', or hex color like '#FF0000'
-- `async_mode`: Use async mode with progress tracking (default: false)
-
-#### `POST /remove-background/async`
-Start async background removal with progress tracking.
-
-#### `POST /remove-background/base64`
-Remove background and return as base64-encoded string.
 
 ### Noise Reduction
 #### `POST /denoise`
@@ -81,13 +46,6 @@ Reduce image noise using Non-Local Means Denoising.
 **Parameters:**
 - `file`: Image file
 - `strength`: Denoising strength (1-30, default: 10)
-- `async_mode`: Use async mode with progress tracking (default: false)
-
-#### `POST /denoise/async`
-Start async denoising with progress tracking.
-
-#### `POST /denoise/base64`
-Denoise an image and return as base64-encoded string.
 
 ### Document Scanning
 #### `POST /docscan`
@@ -100,50 +58,31 @@ Scan and enhance document images with AI-powered processing.
 - CLAHE contrast enhancement
 - Bilateral noise reduction (preserves edges)
 - Unsharp mask sharpening
-- Optional HD upscaling with HuggingFace SD Upscaler
+- Optional HD upscaling with Real-ESRGAN
 
 **Parameters:**
 - `file`: Document image (PNG, JPG, JPEG, WebP, BMP)
 - `enhance_hd`: Enable AI HD enhancement (default: true)
 - `scale`: Upscale factor 1-4 (default: 2)
-- `async_mode`: Use async mode with progress tracking (default: false)
-
-#### `POST /docscan/async`
-Start async document scanning with progress tracking.
-
-#### `POST /docscan/base64`
-Scan a document and return as base64-encoded string.
-
-### Async Job Management
-- `GET /progress/{job_id}` - Get job progress and status
-- `GET /result/{job_id}` - Get the result of a completed job
 
 ### Other Endpoints
 - `GET /docs` - Interactive Swagger UI documentation
 - `GET /redoc` - ReDoc documentation
-- `GET /model-info` - Get information about AI models
+- `GET /model-info` - Get information about loaded AI models
 - `GET /health` - Health check endpoint
 
-## Models Used (HuggingFace Inference API)
+## Models Used
 
 | Feature | Model | Description |
 |---------|-------|-------------|
-| Text-to-Image | Stable Diffusion XL | State-of-the-art text-to-image generation |
-| Super Resolution | SD x4 Upscaler | AI-powered 4x image upscaling |
-| Background Removal | RMBG-1.4 | High-accuracy background removal |
+| Super Resolution | Real-ESRGAN x4plus | State-of-the-art image upscaling |
+| Background Removal | BiRefNet-general | High-accuracy segmentation via rembg |
 | Noise Reduction | OpenCV NLM | Non-Local Means Denoising |
-| Document Scanning | OpenCV + SD Upscaler | Edge detection, perspective correction, HD enhancement |
-
-## Environment Variables
-
-- `HF_TOKEN`: HuggingFace API token (required for AI features)
+| Document Scanning | OpenCV + Real-ESRGAN | Edge detection, perspective correction, HD enhancement |
 
 ## Local Development
 
 ```bash
-# Set your HuggingFace token
-export HF_TOKEN="your_huggingface_token"
-
 # Install dependencies
 pip install -r requirements.txt
 
@@ -157,63 +96,11 @@ The server will start at `http://localhost:7860`
 
 1. Create a new Space on Hugging Face
 2. Select "Docker" as the SDK
-3. Add your `HF_TOKEN` as a secret
-4. Upload all files from this repository
-5. The Space will automatically build and start the container
+3. Upload all files from this repository
+4. The Space will automatically build and start the container
 
 ## API Usage Examples
 
-### Python - Image Generation
-```python
-import requests
-
-response = requests.post(
-    "https://your-space.hf.space/generate",
-    params={
-        "prompt": "A beautiful sunset over mountains, photorealistic, 8k",
-        "negative_prompt": "blurry, low quality",
-        "width": 1024,
-        "height": 1024
-    }
-)
-
-with open("generated.png", "wb") as f:
-    f.write(response.content)
-```
-
-### Python - Image Generation (Async)
-```python
-import requests
-import time
-
-# Start generation
-response = requests.post(
-    "https://your-space.hf.space/generate/async",
-    params={
-        "prompt": "A futuristic city at night, cyberpunk style"
-    }
-)
-data = response.json()
-job_id = data["job_id"]
-
-# Poll for progress
-while True:
-    progress = requests.get(f"https://your-space.hf.space/progress/{job_id}").json()
-    print(f"Progress: {progress['progress']}% - {progress['message']}")
-    
-    if progress["status"] == "completed":
-        break
-    elif progress["status"] == "failed":
-        raise Exception(progress.get("error", "Generation failed"))
-    
-    time.sleep(2)
-
-# Get result
-result = requests.get(f"https://your-space.hf.space/result/{job_id}")
-with open("generated.png", "wb") as f:
-    f.write(result.content)
-```
-
 ### Python - Image Enhancement
 ```python
 import requests
@@ -276,10 +163,6 @@ with open("scanned_document.png", "wb") as f:
 
 ### cURL Examples
 ```bash
-# Generate image
-curl -X POST "https://your-space.hf.space/generate?prompt=A%20beautiful%20landscape" \
-  --output generated.png
-
 # Enhance image
 curl -X POST "https://your-space.hf.space/enhance?scale=4" \
   -F "file=@image.jpg" -o enhanced.png

app.py

@@ -11,7 +11,6 @@ from fastapi.middleware.cors import CORSMiddleware
 from PIL import Image
 import numpy as np
 from progress_tracker import get_tracker, JobStatus
-import hf_client
 
 UPLOAD_DIR = Path("uploads")
 OUTPUT_DIR = Path("outputs")
@@ -25,27 +24,25 @@ app = FastAPI(
     description="""
 ## AI-Powered Image Processing API
 
-A comprehensive image processing API powered by HuggingFace Inference API.
+A comprehensive image processing API with multiple AI-powered features.
 
 ### Features:
-- **Image Generation**: Generate images from text prompts using Stable Diffusion XL
-- **Image Upscaling**: Enhance image resolution up to 4x using SD x4 Upscaler
-- **Background Removal**: Remove backgrounds using RMBG-1.4 model
+- **Image Upscaling**: Enhance image resolution up to 4x using Real-ESRGAN
+- **Background Removal**: Remove backgrounds using rembg with BiRefNet model
 - **Noise Reduction**: Reduce image noise using advanced denoising algorithms
 - **Document Scanning**: Auto-crop, align, and enhance document photos with AI
-- **Async Processing**: All endpoints support async mode with progress tracking
+- **Quality Enhancement**: Improve image clarity and reduce artifacts
 
 ### Supported Formats:
 - PNG, JPG, JPEG, WebP, BMP
 
-### Models Used (HuggingFace Inference API):
-- **Text-to-Image**: Stable Diffusion XL (stabilityai/stable-diffusion-xl-base-1.0)
-- **Super Resolution**: SD x4 Upscaler (stabilityai/stable-diffusion-x4-upscaler)
-- **Background Removal**: RMBG-1.4 (briaai/RMBG-1.4)
+### Models Used:
+- **Super Resolution**: Real-ESRGAN x4plus
+- **Background Removal**: rembg with BiRefNet-massive model
 - **Noise Reduction**: OpenCV Non-Local Means Denoising
-- **Document Scanner**: OpenCV edge detection + SD Upscaler
+- **Document Scanner**: OpenCV edge detection + Real-ESRGAN upscaling
     """,
-    version="3.0.0",
+    version="2.1.0",
     docs_url="/docs",
     redoc_url="/redoc",
 )
@@ -58,8 +55,26 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+enhancer = None
+bg_remover_session = None
+
+def get_enhancer():
+    global enhancer
+    if enhancer is None:
+        from enhancer import ImageEnhancer
+        enhancer = ImageEnhancer()
+    return enhancer
+
+def get_bg_remover():
+    global bg_remover_session
+    if bg_remover_session is None:
+        from rembg import new_session
+        bg_remover_session = new_session("birefnet-general")
+    return bg_remover_session
+
 @app.get("/", response_class=HTMLResponse)
 async def home():
+    """Serve the main HTML page for testing image processing."""
     html_path = Path("templates/index.html")
     if html_path.exists():
         return html_path.read_text()
@@ -75,17 +90,22 @@ async def home():
 
 @app.get("/health")
 async def health_check():
-    hf_token_set = bool(os.environ.get("HF_TOKEN"))
+    """Health check endpoint."""
     return {
-        "status": "healthy",
-        "version": "3.0.0",
-        "hf_token_configured": hf_token_set,
-        "features": ["generate", "enhance", "remove-background", "denoise", "docscan", "progress-tracking"],
-        "api_provider": "HuggingFace Inference API"
+        "status": "healthy", 
+        "version": "2.0.0",
+        "features": ["enhance", "remove-background", "denoise", "docscan", "progress-tracking"]
     }
 
 @app.get("/progress/{job_id}")
 async def get_progress(job_id: str):
+    """
+    Get the progress of an async image processing job.
+    
+    - **job_id**: The job ID returned when starting an async processing request
+    
+    Returns the current progress, status, and message for the job.
+    """
     progress = tracker.get_progress(job_id)
     if progress is None:
         raise HTTPException(status_code=404, detail="Job not found")
@@ -93,6 +113,13 @@ async def get_progress(job_id: str):
 
 @app.get("/result/{job_id}")
 async def get_result(job_id: str):
+    """
+    Get the result of a completed async job.
+    
+    - **job_id**: The job ID returned when starting an async processing request
+    
+    Returns the processed image as a file download if the job is complete.
+    """
     job = tracker.get_job(job_id)
     if job is None:
         raise HTTPException(status_code=404, detail="Job not found")
@@ -122,187 +149,67 @@ async def get_result(job_id: str):
 
 @app.get("/model-info")
 async def model_info():
-    return hf_client.get_model_info()
-
-
-def process_generate_job(job_id: str, prompt: str, negative_prompt: str, width: int, height: int, guidance_scale: float, steps: int, output_path: Path):
-    try:
-        def progress_callback(progress, message):
-            tracker.update_progress(job_id, progress, message)
-        
-        image = hf_client.generate_image(
-            prompt=prompt,
-            negative_prompt=negative_prompt,
-            width=width,
-            height=height,
-            guidance_scale=guidance_scale,
-            num_inference_steps=steps,
-            progress_callback=progress_callback
-        )
-        
-        image.save(output_path, "PNG")
-        tracker.complete_job(job_id, str(output_path), f"Generated {width}x{height} image")
-        
-    except Exception as e:
-        tracker.fail_job(job_id, str(e))
-
-@app.post("/generate/async")
-async def generate_image_async(
-    prompt: str = Query(..., description="Text prompt describing the image to generate"),
-    negative_prompt: str = Query(default="", description="What to avoid in the image"),
-    width: int = Query(default=1024, ge=512, le=1024, description="Image width (512-1024)"),
-    height: int = Query(default=1024, ge=512, le=1024, description="Image height (512-1024)"),
-    guidance_scale: float = Query(default=7.5, ge=1.0, le=20.0, description="How closely to follow the prompt (1-20)"),
-    steps: int = Query(default=50, ge=20, le=100, description="Number of inference steps (20-100)")
-):
-    """
-    Start async image generation with progress tracking.
-    
-    Uses Stable Diffusion XL via HuggingFace Inference API.
-    
-    Returns a job_id for progress tracking via /progress/{job_id}
-    """
-    job_id = tracker.create_job("Starting image generation...")
-    file_id = str(uuid.uuid4())
-    output_path = OUTPUT_DIR / f"{file_id}_generated.png"
-    
-    thread = threading.Thread(
-        target=process_generate_job,
-        args=(job_id, prompt, negative_prompt, width, height, guidance_scale, steps, output_path)
-    )
-    thread.start()
-    
-    return JSONResponse({
-        "job_id": job_id,
-        "status": "processing",
-        "message": "Image generation started. Poll /progress/{job_id} for updates.",
-        "progress_url": f"/progress/{job_id}",
-        "result_url": f"/result/{job_id}"
-    })
-
-@app.post("/generate")
-async def generate_image(
-    prompt: str = Query(..., description="Text prompt describing the image to generate"),
-    negative_prompt: str = Query(default="", description="What to avoid in the image"),
-    width: int = Query(default=1024, ge=512, le=1024, description="Image width (512-1024)"),
-    height: int = Query(default=1024, ge=512, le=1024, description="Image height (512-1024)"),
-    guidance_scale: float = Query(default=7.5, ge=1.0, le=20.0, description="How closely to follow the prompt (1-20)"),
-    steps: int = Query(default=50, ge=20, le=100, description="Number of inference steps (20-100)"),
-    async_mode: bool = Query(default=False, description="Use async mode with progress tracking")
-):
-    """
-    Generate an image from a text prompt using Stable Diffusion XL.
-    
-    - **prompt**: Describe what you want to see in the image
-    - **negative_prompt**: Describe what you want to avoid
-    - **width/height**: Image dimensions (512-1024, must be multiples of 8)
-    - **guidance_scale**: Higher values follow the prompt more closely
-    - **steps**: More steps = higher quality but slower
-    - **async_mode**: If true, returns job_id for progress tracking
-    
-    Returns the generated image as PNG (or job_id if async_mode=true).
-    """
-    if async_mode:
-        job_id = tracker.create_job("Starting image generation...")
-        file_id = str(uuid.uuid4())
-        output_path = OUTPUT_DIR / f"{file_id}_generated.png"
-        
-        thread = threading.Thread(
-            target=process_generate_job,
-            args=(job_id, prompt, negative_prompt, width, height, guidance_scale, steps, output_path)
-        )
-        thread.start()
-        
-        return JSONResponse({
-            "job_id": job_id,
-            "status": "processing",
-            "message": "Image generation started. Poll /progress/{job_id} for updates.",
-            "progress_url": f"/progress/{job_id}",
-            "result_url": f"/result/{job_id}"
-        })
-    
-    try:
-        image = hf_client.generate_image(
-            prompt=prompt,
-            negative_prompt=negative_prompt,
-            width=width,
-            height=height,
-            guidance_scale=guidance_scale,
-            num_inference_steps=steps
-        )
-        
-        file_id = str(uuid.uuid4())
-        output_path = OUTPUT_DIR / f"{file_id}_generated.png"
-        image.save(output_path, "PNG")
-        
-        return FileResponse(
-            output_path,
-            media_type="image/png",
-            filename=f"generated_{file_id[:8]}.png"
-        )
-        
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error generating image: {str(e)}")
-
-@app.post("/generate/base64")
-async def generate_image_base64(
-    prompt: str = Query(..., description="Text prompt describing the image to generate"),
-    negative_prompt: str = Query(default="", description="What to avoid in the image"),
-    width: int = Query(default=1024, ge=512, le=1024, description="Image width (512-1024)"),
-    height: int = Query(default=1024, ge=512, le=1024, description="Image height (512-1024)"),
-    guidance_scale: float = Query(default=7.5, ge=1.0, le=20.0, description="How closely to follow the prompt"),
-    steps: int = Query(default=50, ge=20, le=100, description="Number of inference steps")
-):
-    """
-    Generate an image and return it as base64-encoded string.
-    
-    Uses Stable Diffusion XL via HuggingFace Inference API.
-    """
-    try:
-        image = hf_client.generate_image(
-            prompt=prompt,
-            negative_prompt=negative_prompt,
-            width=width,
-            height=height,
-            guidance_scale=guidance_scale,
-            num_inference_steps=steps
-        )
-        
-        buffer = io.BytesIO()
-        image.save(buffer, format="PNG")
-        buffer.seek(0)
-        
-        img_base64 = base64.b64encode(buffer.getvalue()).decode("utf-8")
-        
-        return JSONResponse({
-            "success": True,
-            "image_base64": img_base64,
-            "size": {"width": image.width, "height": image.height},
-            "prompt": prompt,
-            "model": "stabilityai/stable-diffusion-xl-base-1.0"
-        })
-        
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error generating image: {str(e)}")
-
+    """Get information about the loaded AI models."""
+    return {
+        "models": {
+            "super_resolution": {
+                "name": "Real-ESRGAN x4plus",
+                "description": "State-of-the-art image super-resolution",
+                "upscale_factors": [2, 4],
+                "source": "https://github.com/xinntao/Real-ESRGAN"
+            },
+            "background_removal": {
+                "name": "BiRefNet-general",
+                "description": "High-accuracy background removal using bilateral reference network",
+                "source": "https://github.com/danielgatis/rembg"
+            },
+            "noise_reduction": {
+                "name": "Non-Local Means Denoising",
+                "description": "Advanced noise reduction algorithm",
+                "source": "OpenCV"
+            },
+            "document_scanner": {
+                "name": "AI Document Scanner",
+                "description": "Auto-crop, perspective correction, alignment, and HD enhancement",
+                "features": ["edge detection", "perspective transform", "CLAHE contrast", "bilateral denoising", "unsharp masking", "Real-ESRGAN upscaling"],
+                "source": "OpenCV + Real-ESRGAN"
+            }
+        },
+        "supported_formats": ["png", "jpg", "jpeg", "webp", "bmp"],
+        "max_input_size": "512x512 for fast processing (images auto-resized)"
+    }
 
 def process_enhance_job(job_id: str, image_bytes: bytes, scale: int, output_path: Path, filename: str):
+    """Background task to process image enhancement with progress tracking."""
     try:
         input_image = Image.open(io.BytesIO(image_bytes))
         
         if input_image.mode != "RGB":
             input_image = input_image.convert("RGB")
         
-        def progress_callback(progress, message):
-            tracker.update_progress(job_id, progress, message)
+        max_size = 512
+        if input_image.width > max_size or input_image.height > max_size:
+            ratio = min(max_size / input_image.width, max_size / input_image.height)
+            new_size = (int(input_image.width * ratio), int(input_image.height * ratio))
+            input_image = input_image.resize(new_size, Image.LANCZOS)
         
-        enhanced_image = hf_client.upscale_image(
-            image=input_image,
-            scale=scale,
-            progress_callback=progress_callback
-        )
+        tracker.update_progress(job_id, 5.0, "Image loaded and preprocessed")
+        
+        def progress_callback(progress, message, current_step, total_steps):
+            tracker.update_progress(job_id, progress, message, current_step, total_steps)
+        
+        try:
+            enhancer_instance = get_enhancer()
+            enhanced_image = enhancer_instance.enhance(input_image, scale, progress_callback)
+            enhanced_image.save(output_path, "PNG")
+        except ImportError:
+            tracker.update_progress(job_id, 50.0, "Using fallback enhancer...")
+            enhanced_image = input_image.resize(
+                (input_image.width * scale, input_image.height * scale),
+                Image.LANCZOS
+            )
+            enhanced_image.save(output_path, "PNG")
         
-        enhanced_image.save(output_path, "PNG")
         tracker.complete_job(job_id, str(output_path), f"Enhanced to {enhanced_image.width}x{enhanced_image.height}")
         
     except Exception as e:
@@ -312,14 +219,16 @@ def process_enhance_job(job_id: str, image_bytes: bytes, scale: int, output_path
 async def enhance_image_async(
     background_tasks: BackgroundTasks,
     file: UploadFile = File(..., description="Image file to enhance (PNG, JPG, JPEG, WebP, BMP)"),
-    scale: int = Query(default=4, ge=2, le=4, description="Upscale factor (2 or 4)")
+    scale: int = Query(default=2, ge=2, le=4, description="Upscale factor (2 or 4)")
 ):
     """
     Start async image enhancement with progress tracking.
     
-    Uses SD x4 Upscaler via HuggingFace Inference API.
+    - **file**: Upload an image file (PNG, JPG, JPEG, WebP, BMP)
+    - **scale**: Upscaling factor - 2 for 2x resolution, 4 for 4x resolution
     
-    Returns a job_id for progress tracking via /progress/{job_id}
+    Returns a job_id that can be used to track progress via /progress/{job_id}
+    and retrieve the result via /result/{job_id}
     """
     allowed_types = ["image/png", "image/jpeg", "image/jpg", "image/webp", "image/bmp"]
     if file.content_type not in allowed_types:
@@ -350,14 +259,14 @@ async def enhance_image_async(
 @app.post("/enhance")
 async def enhance_image(
     file: UploadFile = File(..., description="Image file to enhance (PNG, JPG, JPEG, WebP, BMP)"),
-    scale: int = Query(default=4, ge=2, le=4, description="Upscale factor (2 or 4)"),
+    scale: int = Query(default=2, ge=2, le=4, description="Upscale factor (2 or 4)"),
     async_mode: bool = Query(default=False, description="Use async mode with progress tracking")
 ):
     """
-    Enhance an image using SD x4 Upscaler via HuggingFace Inference API.
+    Enhance an image using Real-ESRGAN AI model.
     
     - **file**: Upload an image file (PNG, JPG, JPEG, WebP, BMP)
-    - **scale**: Upscaling factor - 2x or 4x resolution
+    - **scale**: Upscaling factor - 2 for 2x resolution, 4 for 4x resolution
     - **async_mode**: If true, returns job_id for progress tracking instead of waiting
     
     Returns the enhanced image as a PNG file (or job_id if async_mode=true).
@@ -396,11 +305,28 @@ async def enhance_image(
         if input_image.mode != "RGB":
             input_image = input_image.convert("RGB")
         
-        enhanced_image = hf_client.upscale_image(image=input_image, scale=scale)
+        max_size = 512
+        if input_image.width > max_size or input_image.height > max_size:
+            ratio = min(max_size / input_image.width, max_size / input_image.height)
+            new_size = (int(input_image.width * ratio), int(input_image.height * ratio))
+            input_image = input_image.resize(new_size, Image.LANCZOS)
         
         file_id = str(uuid.uuid4())
         output_path = OUTPUT_DIR / f"{file_id}_enhanced.png"
-        enhanced_image.save(output_path, "PNG")
+        
+        try:
+            import concurrent.futures
+            enhancer_instance = get_enhancer()
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                future = executor.submit(enhancer_instance.enhance, input_image, scale)
+                enhanced_image = future.result(timeout=300)
+            enhanced_image.save(output_path, "PNG")
+        except ImportError:
+            enhanced_image = input_image.resize(
+                (input_image.width * scale, input_image.height * scale),
+                Image.LANCZOS
+            )
+            enhanced_image.save(output_path, "PNG")
         
         return FileResponse(
             output_path,
@@ -414,13 +340,15 @@ async def enhance_image(
 @app.post("/enhance/base64")
 async def enhance_image_base64(
     file: UploadFile = File(..., description="Image file to enhance"),
-    scale: int = Query(default=4, ge=2, le=4, description="Upscale factor (2 or 4)")
+    scale: int = Query(default=2, ge=2, le=4, description="Upscale factor (2 or 4)")
 ):
     """
     Enhance an image and return it as base64-encoded string.
     
-    Uses SD x4 Upscaler via HuggingFace Inference API.
+    Useful for integrations that prefer base64 over file downloads.
     """
+    import base64
+    
     allowed_types = ["image/png", "image/jpeg", "image/jpg", "image/webp", "image/bmp"]
     if file.content_type not in allowed_types:
         raise HTTPException(
@@ -435,7 +363,23 @@ async def enhance_image_base64(
         if input_image.mode != "RGB":
             input_image = input_image.convert("RGB")
         
-        enhanced_image = hf_client.upscale_image(image=input_image, scale=scale)
+        max_size = 512
+        if input_image.width > max_size or input_image.height > max_size:
+            ratio = min(max_size / input_image.width, max_size / input_image.height)
+            new_size = (int(input_image.width * ratio), int(input_image.height * ratio))
+            input_image = input_image.resize(new_size, Image.LANCZOS)
+        
+        try:
+            import concurrent.futures
+            enhancer_instance = get_enhancer()
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                future = executor.submit(enhancer_instance.enhance, input_image, scale)
+                enhanced_image = future.result(timeout=300)
+        except ImportError:
+            enhanced_image = input_image.resize(
+                (input_image.width * scale, input_image.height * scale),
+                Image.LANCZOS
+            )
         
         buffer = io.BytesIO()
         enhanced_image.save(buffer, format="PNG")
@@ -448,28 +392,19 @@ async def enhance_image_base64(
             "image_base64": img_base64,
             "original_size": {"width": input_image.width, "height": input_image.height},
             "enhanced_size": {"width": enhanced_image.width, "height": enhanced_image.height},
-            "scale_factor": scale,
-            "model": "stabilityai/stable-diffusion-x4-upscaler"
+            "scale_factor": scale
         })
         
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error processing image: {str(e)}")
 
-
 def process_remove_bg_job(job_id: str, image_bytes: bytes, bgcolor: str, output_path: Path):
+    """Background task for removing background with progress tracking."""
     try:
-        def progress_callback(progress, message):
-            tracker.update_progress(job_id, progress, message)
-        
-        output_image = hf_client.remove_background(
-            image_bytes=image_bytes,
-            progress_callback=progress_callback
-        )
+        tracker.update_progress(job_id, 10.0, "Loading image...")
         
+        bg_color = None
         if bgcolor != "transparent":
-            tracker.update_progress(job_id, 85.0, "Applying background color...")
-            background = Image.new("RGBA", output_image.size)
-            
             if bgcolor == "white":
                 bg_color = (255, 255, 255, 255)
             elif bgcolor == "black":
@@ -479,16 +414,24 @@ def process_remove_bg_job(job_id: str, image_bytes: bytes, bgcolor: str, output_
                 if len(hex_color) == 6:
                     r, g, b = int(hex_color[0:2], 16), int(hex_color[2:4], 16), int(hex_color[4:6], 16)
                     bg_color = (r, g, b, 255)
-                else:
-                    bg_color = (255, 255, 255, 255)
-            else:
-                bg_color = (255, 255, 255, 255)
-            
-            background = Image.new("RGBA", output_image.size, bg_color)
-            background.paste(output_image, mask=output_image.split()[3] if output_image.mode == "RGBA" else None)
-            output_image = background
         
-        tracker.update_progress(job_id, 95.0, "Saving result...")
+        tracker.update_progress(job_id, 20.0, "Initializing AI model...")
+        
+        try:
+            from rembg import remove
+            tracker.update_progress(job_id, 40.0, "Removing background...")
+            session = get_bg_remover()
+            tracker.update_progress(job_id, 60.0, "Processing...")
+            output_data = remove(image_bytes, session=session, bgcolor=bg_color)
+            output_image = Image.open(io.BytesIO(output_data))
+        except ImportError:
+            tracker.update_progress(job_id, 50.0, "Using fallback (no rembg)...")
+            input_image = Image.open(io.BytesIO(image_bytes))
+            if input_image.mode != "RGBA":
+                input_image = input_image.convert("RGBA")
+            output_image = input_image
+        
+        tracker.update_progress(job_id, 90.0, "Saving result...")
         output_image.save(output_path, "PNG")
         tracker.complete_job(job_id, str(output_path), "Background removed successfully")
         
@@ -503,8 +446,6 @@ async def remove_background_async(
     """
     Start async background removal with progress tracking.
     
-    Uses RMBG-1.4 via HuggingFace Inference API.
-    
     Returns a job_id for progress tracking via /progress/{job_id}
     """
     allowed_types = ["image/png", "image/jpeg", "image/jpg", "image/webp", "image/bmp"]
@@ -537,7 +478,7 @@ async def remove_background(
     async_mode: bool = Query(default=False, description="Use async mode with progress tracking")
 ):
     """
-    Remove background from an image using RMBG-1.4 via HuggingFace Inference API.
+    Remove background from an image using AI.
     
     - **file**: Upload an image file (PNG, JPG, JPEG, WebP, BMP)
     - **bgcolor**: Background color after removal. Options:
@@ -578,8 +519,7 @@ async def remove_background(
         })
     
     try:
-        output_image = hf_client.remove_background(image_bytes=contents)
-        
+        bg_color = None
         if bgcolor != "transparent":
             if bgcolor == "white":
                 bg_color = (255, 255, 255, 255)
@@ -590,14 +530,17 @@ async def remove_background(
                 if len(hex_color) == 6:
                     r, g, b = int(hex_color[0:2], 16), int(hex_color[2:4], 16), int(hex_color[4:6], 16)
                     bg_color = (r, g, b, 255)
-                else:
-                    bg_color = (255, 255, 255, 255)
-            else:
-                bg_color = (255, 255, 255, 255)
-            
-            background = Image.new("RGBA", output_image.size, bg_color)
-            background.paste(output_image, mask=output_image.split()[3] if output_image.mode == "RGBA" else None)
-            output_image = background
+        
+        try:
+            from rembg import remove
+            session = get_bg_remover()
+            output_data = remove(contents, session=session, bgcolor=bg_color)
+            output_image = Image.open(io.BytesIO(output_data))
+        except ImportError:
+            input_image = Image.open(io.BytesIO(contents))
+            if input_image.mode != "RGBA":
+                input_image = input_image.convert("RGBA")
+            output_image = input_image
         
         file_id = str(uuid.uuid4())
         output_path = OUTPUT_DIR / f"{file_id}_nobg.png"
@@ -619,9 +562,9 @@ async def remove_background_base64(
 ):
     """
     Remove background from an image and return as base64.
-    
-    Uses RMBG-1.4 via HuggingFace Inference API.
     """
+    import base64
+    
     allowed_types = ["image/png", "image/jpeg", "image/jpg", "image/webp", "image/bmp"]
     if file.content_type not in allowed_types:
         raise HTTPException(
@@ -633,8 +576,7 @@ async def remove_background_base64(
         contents = await file.read()
         input_image = Image.open(io.BytesIO(contents))
         
-        output_image = hf_client.remove_background(image_bytes=contents)
-        
+        bg_color = None
         if bgcolor != "transparent":
             if bgcolor == "white":
                 bg_color = (255, 255, 255, 255)
@@ -645,14 +587,16 @@ async def remove_background_base64(
                 if len(hex_color) == 6:
                     r, g, b = int(hex_color[0:2], 16), int(hex_color[2:4], 16), int(hex_color[4:6], 16)
                     bg_color = (r, g, b, 255)
-                else:
-                    bg_color = (255, 255, 255, 255)
-            else:
-                bg_color = (255, 255, 255, 255)
-            
-            background = Image.new("RGBA", output_image.size, bg_color)
-            background.paste(output_image, mask=output_image.split()[3] if output_image.mode == "RGBA" else None)
-            output_image = background
+        
+        try:
+            from rembg import remove
+            session = get_bg_remover()
+            output_data = remove(contents, session=session, bgcolor=bg_color)
+            output_image = Image.open(io.BytesIO(output_data))
+        except ImportError:
+            if input_image.mode != "RGBA":
+                input_image = input_image.convert("RGBA")
+            output_image = input_image
         
         buffer = io.BytesIO()
         output_image.save(buffer, format="PNG")
@@ -665,27 +609,48 @@ async def remove_background_base64(
             "image_base64": img_base64,
             "original_size": {"width": input_image.width, "height": input_image.height},
             "output_size": {"width": output_image.width, "height": output_image.height},
-            "background": bgcolor,
-            "model": "briaai/RMBG-1.4"
+            "background": bgcolor
         })
         
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error removing background: {str(e)}")
 
-
 def process_denoise_job(job_id: str, image_bytes: bytes, strength: int, output_path: Path):
+    """Background task for denoising with progress tracking."""
     try:
+        tracker.update_progress(job_id, 10.0, "Loading image...")
         input_image = Image.open(io.BytesIO(image_bytes))
         
-        def progress_callback(progress, message):
-            tracker.update_progress(job_id, progress, message)
+        if input_image.mode != "RGB":
+            input_image = input_image.convert("RGB")
         
-        output_image = hf_client.denoise_image(
-            image=input_image,
-            strength=strength,
-            progress_callback=progress_callback
-        )
+        tracker.update_progress(job_id, 20.0, "Applying denoising filter...")
         
+        try:
+            import cv2
+            tracker.update_progress(job_id, 30.0, "Using OpenCV Non-Local Means...")
+            img_array = np.array(input_image)
+            img_bgr = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR)
+            
+            tracker.update_progress(job_id, 50.0, "Processing...")
+            denoised_bgr = cv2.fastNlMeansDenoisingColored(
+                img_bgr, 
+                None, 
+                h=strength,
+                hForColorComponents=strength,
+                templateWindowSize=7,
+                searchWindowSize=21
+            )
+            
+            tracker.update_progress(job_id, 80.0, "Converting result...")
+            denoised_rgb = cv2.cvtColor(denoised_bgr, cv2.COLOR_BGR2RGB)
+            output_image = Image.fromarray(denoised_rgb)
+        except ImportError:
+            tracker.update_progress(job_id, 50.0, "Using PIL fallback...")
+            from PIL import ImageFilter
+            output_image = input_image.filter(ImageFilter.SMOOTH_MORE)
+        
+        tracker.update_progress(job_id, 90.0, "Saving result...")
         output_image.save(output_path, "PNG")
         tracker.complete_job(job_id, str(output_path), "Denoising complete")
         
@@ -773,7 +738,29 @@ async def denoise_image(
     
     try:
         input_image = Image.open(io.BytesIO(contents))
-        output_image = hf_client.denoise_image(image=input_image, strength=strength)
+        
+        if input_image.mode != "RGB":
+            input_image = input_image.convert("RGB")
+        
+        try:
+            import cv2
+            img_array = np.array(input_image)
+            img_bgr = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR)
+            
+            denoised_bgr = cv2.fastNlMeansDenoisingColored(
+                img_bgr, 
+                None, 
+                h=strength,
+                hForColorComponents=strength,
+                templateWindowSize=7,
+                searchWindowSize=21
+            )
+            
+            denoised_rgb = cv2.cvtColor(denoised_bgr, cv2.COLOR_BGR2RGB)
+            output_image = Image.fromarray(denoised_rgb)
+        except ImportError:
+            from PIL import ImageFilter
+            output_image = input_image.filter(ImageFilter.SMOOTH_MORE)
         
         file_id = str(uuid.uuid4())
         output_path = OUTPUT_DIR / f"{file_id}_denoised.png"
@@ -796,6 +783,8 @@ async def denoise_image_base64(
     """
     Reduce noise in an image and return as base64.
     """
+    import base64
+    
     allowed_types = ["image/png", "image/jpeg", "image/jpg", "image/webp", "image/bmp"]
     if file.content_type not in allowed_types:
         raise HTTPException(
@@ -806,7 +795,29 @@ async def denoise_image_base64(
     try:
         contents = await file.read()
         input_image = Image.open(io.BytesIO(contents))
-        output_image = hf_client.denoise_image(image=input_image, strength=strength)
+        
+        if input_image.mode != "RGB":
+            input_image = input_image.convert("RGB")
+        
+        try:
+            import cv2
+            img_array = np.array(input_image)
+            img_bgr = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR)
+            
+            denoised_bgr = cv2.fastNlMeansDenoisingColored(
+                img_bgr, 
+                None, 
+                h=strength,
+                hForColorComponents=strength,
+                templateWindowSize=7,
+                searchWindowSize=21
+            )
+            
+            denoised_rgb = cv2.cvtColor(denoised_bgr, cv2.COLOR_BGR2RGB)
+            output_image = Image.fromarray(denoised_rgb)
+        except ImportError:
+            from PIL import ImageFilter
+            output_image = input_image.filter(ImageFilter.SMOOTH_MORE)
         
         buffer = io.BytesIO()
         output_image.save(buffer, format="PNG")
@@ -835,6 +846,7 @@ def get_doc_scanner():
     return doc_scanner
 
 def process_docscan_job(job_id: str, image_bytes: bytes, enhance_hd: bool, scale: int, output_path: Path):
+    """Background task for document scanning with progress tracking."""
     try:
         tracker.update_progress(job_id, 5.0, "Loading document image...")
         input_image = Image.open(io.BytesIO(image_bytes))
@@ -855,7 +867,7 @@ def process_docscan_job(job_id: str, image_bytes: bytes, enhance_hd: bool, scale
         scanner = get_doc_scanner()
         
         if enhance_hd:
-            tracker.update_progress(job_id, 60.0, "Applying HD enhancement (HuggingFace AI)...")
+            tracker.update_progress(job_id, 60.0, "Applying HD enhancement (AI upscaling)...")
         else:
             tracker.update_progress(job_id, 60.0, "Finalizing document...")
         
@@ -905,7 +917,7 @@ async def scan_document_async(
 @app.post("/docscan")
 async def scan_document(
     file: UploadFile = File(..., description="Document image to scan (PNG, JPG, JPEG, WebP, BMP)"),
-    enhance_hd: bool = Query(default=True, description="Apply HD enhancement using AI (HuggingFace)"),
+    enhance_hd: bool = Query(default=True, description="Apply HD enhancement using AI (Real-ESRGAN)"),
     scale: int = Query(default=2, ge=1, le=4, description="Upscale factor for HD enhancement (1-4)"),
     async_mode: bool = Query(default=False, description="Use async mode with progress tracking")
 ):
@@ -920,7 +932,7 @@ async def scan_document(
     - **Contrast enhancement**: Applies CLAHE for improved readability
     - **Noise reduction**: Uses bilateral filtering to reduce noise while preserving edges
     - **Sharpening**: Applies unsharp masking for crisp text without artifacts
-    - **HD upscaling**: Uses HuggingFace SD Upscaler for high-definition output
+    - **HD upscaling**: Optionally uses Real-ESRGAN for high-definition output
     
     Parameters:
     - **file**: Upload a photo of a document (supports various angles and lighting)
@@ -997,7 +1009,10 @@ async def scan_document_base64(
     Scan and enhance a document image, returning the result as base64.
     
     Same processing as /docscan but returns base64-encoded image data.
+    Useful for integrations that prefer base64 over file downloads.
     """
+    import base64
+    
     allowed_types = ["image/png", "image/jpeg", "image/jpg", "image/webp", "image/bmp"]
     if file.content_type not in allowed_types:
         raise HTTPException(
@@ -1042,7 +1057,7 @@ async def scan_document_base64(
                 "contrast_enhancement": "CLAHE",
                 "noise_reduction": "bilateral_filter",
                 "sharpening": "unsharp_mask",
-                "hd_upscaling": "HuggingFace SD Upscaler" if enhance_hd else "disabled"
+                "hd_upscaling": "Real-ESRGAN" if enhance_hd else "disabled"
             }
         })
         

document_scanner.py

@@ -153,11 +153,12 @@ class DocumentScanner:
         
         if enhance_hd:
             try:
-                import hf_client
-                hd_image = hf_client.upscale_image(brightened, scale=scale)
+                from enhancer import ImageEnhancer
+                ai_enhancer = ImageEnhancer()
+                hd_image = ai_enhancer.enhance(brightened, scale=scale)
                 return hd_image
             except Exception as e:
-                print(f"[DocScan] Using fallback upscaling: {e}")
+                print(f"[DocScan] Using fallback upscaling (AI models load on Hugging Face deployment)")
                 new_size = (brightened.width * scale, brightened.height * scale)
                 hd_image = brightened.resize(new_size, Image.LANCZOS)
                 return self.enhance_sharpness(hd_image, amount=0.5)

hf_client.py

@@ -1,391 +0,0 @@
-import os
-import io
-import time
-import base64
-import requests
-from PIL import Image
-from typing import Optional, Tuple, Callable
-
-HF_TOKEN = os.environ.get("HF_TOKEN")
-HF_API_BASE = "https://api-inference.huggingface.co/models"
-
-MODELS = {
-    "text_to_image": "stabilityai/stable-diffusion-xl-base-1.0",
-    "upscaler": "stabilityai/stable-diffusion-x4-upscaler",
-    "background_removal": "briaai/RMBG-1.4",
-}
-
-def get_headers():
-    if not HF_TOKEN:
-        raise ValueError("HF_TOKEN environment variable is not set")
-    return {"Authorization": f"Bearer {HF_TOKEN}"}
-
-
-def wait_for_model(model_id: str, max_retries: int = 10, retry_delay: float = 5.0) -> bool:
-    url = f"{HF_API_BASE}/{model_id}"
-    headers = get_headers()
-    
-    for attempt in range(max_retries):
-        try:
-            response = requests.post(
-                url,
-                headers=headers,
-                json={"inputs": "test", "options": {"wait_for_model": True}},
-                timeout=30
-            )
-            if response.status_code == 200:
-                return True
-            elif response.status_code == 503:
-                time.sleep(retry_delay)
-                continue
-            else:
-                return True
-        except requests.exceptions.Timeout:
-            time.sleep(retry_delay)
-            continue
-    return False
-
-
-def generate_image(
-    prompt: str,
-    negative_prompt: str = "",
-    width: int = 1024,
-    height: int = 1024,
-    guidance_scale: float = 7.5,
-    num_inference_steps: int = 50,
-    progress_callback: Optional[Callable] = None
-) -> Image.Image:
-    model_id = MODELS["text_to_image"]
-    url = f"{HF_API_BASE}/{model_id}"
-    headers = get_headers()
-    
-    if progress_callback:
-        progress_callback(10.0, "Connecting to AI model...")
-    
-    payload = {
-        "inputs": prompt,
-        "parameters": {
-            "negative_prompt": negative_prompt,
-            "width": width,
-            "height": height,
-            "guidance_scale": guidance_scale,
-            "num_inference_steps": num_inference_steps,
-        },
-        "options": {
-            "wait_for_model": True,
-            "use_cache": False
-        }
-    }
-    
-    if progress_callback:
-        progress_callback(20.0, "Sending request to Stable Diffusion XL...")
-    
-    max_retries = 3
-    retry_delay = 10.0
-    
-    for attempt in range(max_retries):
-        try:
-            response = requests.post(url, headers=headers, json=payload, timeout=300)
-            
-            if response.status_code == 200:
-                if progress_callback:
-                    progress_callback(90.0, "Processing response...")
-                image = Image.open(io.BytesIO(response.content))
-                if progress_callback:
-                    progress_callback(100.0, "Image generated successfully!")
-                return image
-            elif response.status_code == 503:
-                if progress_callback:
-                    progress_callback(30.0 + attempt * 10, f"Model loading... (attempt {attempt + 1}/{max_retries})")
-                time.sleep(retry_delay)
-                continue
-            else:
-                error_msg = response.json().get("error", response.text)
-                raise Exception(f"API error: {error_msg}")
-        except requests.exceptions.Timeout:
-            if attempt < max_retries - 1:
-                time.sleep(retry_delay)
-                continue
-            raise Exception("Request timed out")
-    
-    raise Exception("Failed to generate image after multiple retries")
-
-
-def upscale_image(
-    image: Image.Image,
-    prompt: str = "high quality, detailed, sharp",
-    scale: int = 4,
-    progress_callback: Optional[Callable] = None
-) -> Image.Image:
-    model_id = MODELS["upscaler"]
-    url = f"{HF_API_BASE}/{model_id}"
-    headers = get_headers()
-    headers["Content-Type"] = "application/json"
-    
-    if progress_callback:
-        progress_callback(10.0, "Preparing image for upscaling...")
-    
-    if image.mode != "RGB":
-        image = image.convert("RGB")
-    
-    max_dim = 128
-    if image.width > max_dim or image.height > max_dim:
-        ratio = min(max_dim / image.width, max_dim / image.height)
-        new_size = (int(image.width * ratio), int(image.height * ratio))
-        image = image.resize(new_size, Image.LANCZOS)
-    
-    buffer = io.BytesIO()
-    image.save(buffer, format="PNG")
-    buffer.seek(0)
-    img_base64 = base64.b64encode(buffer.getvalue()).decode("utf-8")
-    
-    if progress_callback:
-        progress_callback(20.0, "Sending to SD x4 Upscaler...")
-    
-    payload = {
-        "inputs": {
-            "image": img_base64,
-            "prompt": prompt,
-        },
-        "parameters": {
-            "num_inference_steps": 75,
-            "guidance_scale": 9.0,
-        },
-        "options": {
-            "wait_for_model": True
-        }
-    }
-    
-    max_retries = 3
-    retry_delay = 15.0
-    
-    for attempt in range(max_retries):
-        try:
-            if progress_callback:
-                progress_callback(30.0 + attempt * 15, f"Processing with AI... (attempt {attempt + 1})")
-            
-            response = requests.post(url, headers=headers, json=payload, timeout=300)
-            
-            if response.status_code == 200:
-                if progress_callback:
-                    progress_callback(90.0, "Finalizing upscaled image...")
-                upscaled = Image.open(io.BytesIO(response.content))
-                if progress_callback:
-                    progress_callback(100.0, "Upscaling complete!")
-                return upscaled
-            elif response.status_code == 503:
-                if progress_callback:
-                    progress_callback(30.0 + attempt * 10, "Model loading, please wait...")
-                time.sleep(retry_delay)
-                continue
-            elif response.status_code == 422:
-                if progress_callback:
-                    progress_callback(40.0, "Using fallback upscaling method...")
-                new_size = (image.width * scale, image.height * scale)
-                return image.resize(new_size, Image.LANCZOS)
-            else:
-                error_info = response.json() if response.headers.get("content-type", "").startswith("application/json") else {"error": response.text}
-                error_msg = error_info.get("error", str(error_info))
-                if attempt < max_retries - 1:
-                    time.sleep(retry_delay)
-                    continue
-                if progress_callback:
-                    progress_callback(50.0, "Using fallback method...")
-                new_size = (image.width * scale, image.height * scale)
-                return image.resize(new_size, Image.LANCZOS)
-        except requests.exceptions.Timeout:
-            if attempt < max_retries - 1:
-                time.sleep(retry_delay)
-                continue
-            if progress_callback:
-                progress_callback(50.0, "Timeout, using fallback...")
-            new_size = (image.width * scale, image.height * scale)
-            return image.resize(new_size, Image.LANCZOS)
-    
-    new_size = (image.width * scale, image.height * scale)
-    return image.resize(new_size, Image.LANCZOS)
-
-
-def remove_background(
-    image_bytes: bytes,
-    progress_callback: Optional[Callable] = None
-) -> Image.Image:
-    model_id = MODELS["background_removal"]
-    url = f"{HF_API_BASE}/{model_id}"
-    headers = get_headers()
-    
-    if progress_callback:
-        progress_callback(10.0, "Preparing image...")
-    
-    if progress_callback:
-        progress_callback(20.0, "Sending to RMBG-1.4 model...")
-    
-    max_retries = 3
-    retry_delay = 10.0
-    
-    for attempt in range(max_retries):
-        try:
-            if progress_callback:
-                progress_callback(30.0 + attempt * 15, f"Processing... (attempt {attempt + 1})")
-            
-            response = requests.post(
-                url,
-                headers=headers,
-                data=image_bytes,
-                timeout=120
-            )
-            
-            if response.status_code == 200:
-                content_type = response.headers.get("content-type", "")
-                
-                if "image" in content_type:
-                    if progress_callback:
-                        progress_callback(90.0, "Processing mask...")
-                    mask = Image.open(io.BytesIO(response.content))
-                    original = Image.open(io.BytesIO(image_bytes))
-                    
-                    if original.mode != "RGBA":
-                        original = original.convert("RGBA")
-                    
-                    if mask.mode != "L":
-                        mask = mask.convert("L")
-                    
-                    if mask.size != original.size:
-                        mask = mask.resize(original.size, Image.LANCZOS)
-                    
-                    original.putalpha(mask)
-                    
-                    if progress_callback:
-                        progress_callback(100.0, "Background removed!")
-                    return original
-                else:
-                    result = response.json()
-                    if isinstance(result, list) and len(result) > 0:
-                        if progress_callback:
-                            progress_callback(90.0, "Processing segmentation result...")
-                        original = Image.open(io.BytesIO(image_bytes))
-                        if original.mode != "RGBA":
-                            original = original.convert("RGBA")
-                        if progress_callback:
-                            progress_callback(100.0, "Background removed!")
-                        return original
-                    raise Exception(f"Unexpected response format: {result}")
-            elif response.status_code == 503:
-                if progress_callback:
-                    progress_callback(30.0 + attempt * 10, "Model loading...")
-                time.sleep(retry_delay)
-                continue
-            else:
-                error_msg = response.text
-                try:
-                    error_msg = response.json().get("error", response.text)
-                except:
-                    pass
-                if attempt < max_retries - 1:
-                    time.sleep(retry_delay)
-                    continue
-                raise Exception(f"API error: {error_msg}")
-        except requests.exceptions.Timeout:
-            if attempt < max_retries - 1:
-                time.sleep(retry_delay)
-                continue
-            raise Exception("Request timed out")
-    
-    raise Exception("Failed to remove background after multiple retries")
-
-
-def denoise_image(
-    image: Image.Image,
-    strength: int = 10,
-    progress_callback: Optional[Callable] = None
-) -> Image.Image:
-    if progress_callback:
-        progress_callback(10.0, "Loading image...")
-    
-    if image.mode != "RGB":
-        image = image.convert("RGB")
-    
-    if progress_callback:
-        progress_callback(30.0, "Applying denoising filter...")
-    
-    try:
-        import cv2
-        import numpy as np
-        
-        if progress_callback:
-            progress_callback(50.0, "Using OpenCV Non-Local Means...")
-        
-        img_array = np.array(image)
-        img_bgr = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR)
-        
-        denoised_bgr = cv2.fastNlMeansDenoisingColored(
-            img_bgr,
-            None,
-            h=strength,
-            hForColorComponents=strength,
-            templateWindowSize=7,
-            searchWindowSize=21
-        )
-        
-        if progress_callback:
-            progress_callback(80.0, "Converting result...")
-        
-        denoised_rgb = cv2.cvtColor(denoised_bgr, cv2.COLOR_BGR2RGB)
-        output_image = Image.fromarray(denoised_rgb)
-        
-        if progress_callback:
-            progress_callback(100.0, "Denoising complete!")
-        
-        return output_image
-    except ImportError:
-        if progress_callback:
-            progress_callback(50.0, "Using PIL fallback...")
-        from PIL import ImageFilter
-        output_image = image.filter(ImageFilter.SMOOTH_MORE)
-        if progress_callback:
-            progress_callback(100.0, "Denoising complete!")
-        return output_image
-
-
-def get_model_info():
-    return {
-        "models": {
-            "text_to_image": {
-                "name": "Stable Diffusion XL",
-                "model_id": MODELS["text_to_image"],
-                "description": "State-of-the-art text-to-image generation with 1024x1024 native resolution",
-                "provider": "HuggingFace Inference API",
-                "source": "https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0"
-            },
-            "super_resolution": {
-                "name": "Stable Diffusion x4 Upscaler",
-                "model_id": MODELS["upscaler"],
-                "description": "AI-powered 4x image upscaling with diffusion models",
-                "provider": "HuggingFace Inference API",
-                "source": "https://huggingface.co/stabilityai/stable-diffusion-x4-upscaler"
-            },
-            "background_removal": {
-                "name": "RMBG-1.4",
-                "model_id": MODELS["background_removal"],
-                "description": "State-of-the-art background removal trained on diverse content",
-                "provider": "HuggingFace Inference API",
-                "source": "https://huggingface.co/briaai/RMBG-1.4"
-            },
-            "noise_reduction": {
-                "name": "OpenCV Non-Local Means",
-                "description": "Advanced noise reduction algorithm",
-                "provider": "Local Processing",
-                "source": "OpenCV"
-            },
-            "document_scanner": {
-                "name": "AI Document Scanner",
-                "description": "Edge detection, perspective correction, and enhancement",
-                "features": ["auto-crop", "perspective transform", "CLAHE contrast", "bilateral denoising"],
-                "provider": "Local Processing + HuggingFace",
-                "source": "OpenCV + SD Upscaler"
-            }
-        },
-        "api_provider": "HuggingFace Inference API",
-        "supported_formats": ["png", "jpg", "jpeg", "webp", "bmp"],
-        "authentication": "Bearer token required (HF_TOKEN)"
-    }

requirements.txt

@@ -11,9 +11,3 @@ basicsr==1.4.2
 gfpgan==1.3.8
 rembg==2.0.50
 onnxruntime==1.17.0
-fastapi
-opencv-python
-pillow
-python-multipart
-requests
-uvicorn

templates/index.html

@@ -43,17 +43,6 @@
             font-size: 1.1rem;
         }
         
-        .powered-by {
-            margin-top: 10px;
-            color: #666;
-            font-size: 0.9rem;
-        }
-        
-        .powered-by a {
-            color: #00d2ff;
-            text-decoration: none;
-        }
-        
         .api-link {
             margin-top: 15px;
         }
@@ -125,7 +114,7 @@
             color: #888;
         }
         
-        select, input[type="text"], textarea {
+        select, input[type="text"] {
             width: 100%;
             padding: 12px;
             border-radius: 8px;
@@ -135,11 +124,6 @@
             font-size: 1rem;
         }
         
-        textarea {
-            resize: vertical;
-            min-height: 80px;
-        }
-        
         .feature-tabs {
             display: flex;
             gap: 10px;
@@ -217,10 +201,6 @@
             gap: 20px;
         }
         
-        .image-comparison.single {
-            grid-template-columns: 1fr;
-        }
-        
         @media (max-width: 600px) {
             .image-comparison {
                 grid-template-columns: 1fr;
@@ -375,22 +355,13 @@
             background-position: 0 0, 0 10px, 10px -10px, -10px 0px;
             background-color: #444;
         }
-        
-        .prompt-section {
-            margin-bottom: 20px;
-        }
-        
-        .prompt-section textarea {
-            margin-bottom: 10px;
-        }
     </style>
 </head>
 <body>
     <div class="container">
         <header>
             <h1>AI Image Processing</h1>
-            <p class="subtitle">Generate, enhance, remove backgrounds, denoise, and scan documents with AI</p>
-            <p class="powered-by">Powered by <a href="https://huggingface.co/inference-api" target="_blank">HuggingFace Inference API</a></p>
+            <p class="subtitle">Enhance, remove backgrounds, denoise, and scan documents with AI</p>
             <div class="api-link">
                 <a href="/docs" target="_blank">View API Documentation</a>
             </div>
@@ -398,71 +369,20 @@
         
         <section class="upload-section">
             <div class="feature-tabs">
-                <button class="feature-tab active" data-feature="generate">Generate</button>
-                <button class="feature-tab" data-feature="enhance">Enhance</button>
+                <button class="feature-tab active" data-feature="enhance">Enhance</button>
                 <button class="feature-tab" data-feature="remove-bg">Remove Background</button>
                 <button class="feature-tab" data-feature="denoise">Denoise</button>
                 <button class="feature-tab" data-feature="docscan">Doc Scan</button>
             </div>
             
-            <div id="generateOptions" class="feature-options active">
-                <div class="prompt-section">
-                    <label for="prompt">Describe the image you want to create</label>
-                    <textarea id="prompt" placeholder="A majestic lion in a savanna at sunset, photorealistic, 8k, detailed"></textarea>
-                </div>
-                <div class="prompt-section">
-                    <label for="negativePrompt">What to avoid (optional)</label>
-                    <textarea id="negativePrompt" placeholder="blurry, low quality, distorted, ugly"></textarea>
-                </div>
-                <div class="options">
-                    <div class="option-group">
-                        <label for="genWidth">Width</label>
-                        <select id="genWidth">
-                            <option value="512">512px</option>
-                            <option value="768">768px</option>
-                            <option value="1024" selected>1024px</option>
-                        </select>
-                    </div>
-                    <div class="option-group">
-                        <label for="genHeight">Height</label>
-                        <select id="genHeight">
-                            <option value="512">512px</option>
-                            <option value="768">768px</option>
-                            <option value="1024" selected>1024px</option>
-                        </select>
-                    </div>
-                    <div class="option-group">
-                        <label for="guidanceScale">Guidance Scale</label>
-                        <select id="guidanceScale">
-                            <option value="5">5 - More creative</option>
-                            <option value="7.5" selected>7.5 - Balanced</option>
-                            <option value="10">10 - Follow prompt closely</option>
-                            <option value="15">15 - Very strict</option>
-                        </select>
-                    </div>
-                    <div class="option-group">
-                        <label for="steps">Steps</label>
-                        <select id="steps">
-                            <option value="20">20 - Fast</option>
-                            <option value="30">30 - Quick</option>
-                            <option value="50" selected>50 - Balanced</option>
-                            <option value="75">75 - High quality</option>
-                        </select>
-                    </div>
-                </div>
-                <p style="color: #888; font-size: 0.85rem; margin-top: 10px;">
-                    Uses Stable Diffusion XL for high-quality image generation.
-                </p>
-            </div>
-            
-            <div id="uploadZone" class="drop-zone" style="display: none;">
+            <div class="drop-zone" id="dropZone">
                 <div class="drop-zone-icon">📷</div>
                 <p>Drag & drop an image here or click to select</p>
                 <p><small>Supports: PNG, JPG, JPEG, WebP, BMP</small></p>
             </div>
             <input type="file" id="fileInput" accept="image/png,image/jpeg,image/jpg,image/webp,image/bmp">
             
-            <div id="enhanceOptions" class="feature-options">
+            <div id="enhanceOptions" class="feature-options active">
                 <div class="options">
                     <div class="option-group">
                         <label for="scale">Upscale Factor</label>
@@ -472,9 +392,6 @@
                         </select>
                     </div>
                 </div>
-                <p style="color: #888; font-size: 0.85rem; margin-top: 10px;">
-                    Uses SD x4 Upscaler via HuggingFace for AI-powered upscaling.
-                </p>
             </div>
             
             <div id="removeBgOptions" class="feature-options">
@@ -493,9 +410,6 @@
                         <input type="text" id="customColor" placeholder="#FF0000" value="#FFFFFF">
                     </div>
                 </div>
-                <p style="color: #888; font-size: 0.85rem; margin-top: 10px;">
-                    Uses RMBG-1.4 via HuggingFace for state-of-the-art background removal.
-                </p>
             </div>
             
             <div id="denoiseOptions" class="feature-options">
@@ -527,7 +441,7 @@
                     <div class="option-group">
                         <label for="enhanceHd">AI HD Enhancement</label>
                         <select id="enhanceHd">
-                            <option value="true" selected>Enabled (HuggingFace AI)</option>
+                            <option value="true" selected>Enabled (Real-ESRGAN)</option>
                             <option value="false">Disabled (faster)</option>
                         </select>
                     </div>
@@ -537,14 +451,14 @@
                 </p>
             </div>
             
-            <button class="process-btn" id="processBtn">Generate Image</button>
+            <button class="process-btn" id="processBtn" disabled>Process Image</button>
             
             <div class="error" id="error"></div>
         </section>
         
         <div class="loading" id="loading">
             <div class="spinner"></div>
-            <p id="loadingText">Processing with AI...</p>
+            <p id="loadingText">Processing your image with AI...</p>
             <div class="progress-container">
                 <div class="progress-percentage" id="progressPercentage">0%</div>
                 <div class="progress-bar-wrapper">
@@ -556,8 +470,8 @@
         </div>
         
         <section class="results-section" id="results">
-            <div class="image-comparison" id="imageComparison">
-                <div class="image-box" id="originalBox">
+            <div class="image-comparison">
+                <div class="image-box">
                     <h3>Original</h3>
                     <img id="originalImg" src="" alt="Original image">
                 </div>
@@ -572,17 +486,13 @@
         <section class="info-section">
             <h2>Available Features</h2>
             <div class="info-grid">
-                <div class="info-item">
-                    <h4>Image Generation</h4>
-                    <p>Create images from text prompts using Stable Diffusion XL</p>
-                </div>
                 <div class="info-item">
                     <h4>Image Enhancement</h4>
-                    <p>Upscale images 2x-4x using SD x4 Upscaler via HuggingFace</p>
+                    <p>Upscale images 2x-4x using Real-ESRGAN AI model</p>
                 </div>
                 <div class="info-item">
                     <h4>Background Removal</h4>
-                    <p>Remove backgrounds using RMBG-1.4 via HuggingFace</p>
+                    <p>Remove backgrounds using BiRefNet deep learning model</p>
                 </div>
                 <div class="info-item">
                     <h4>Noise Reduction</h4>
@@ -601,7 +511,7 @@
     </div>
     
     <script>
-        const dropZone = document.getElementById('uploadZone');
+        const dropZone = document.getElementById('dropZone');
         const fileInput = document.getElementById('fileInput');
         const processBtn = document.getElementById('processBtn');
         const loading = document.getElementById('loading');
@@ -612,9 +522,7 @@
         const processedImg = document.getElementById('processedImg');
         const downloadBtn = document.getElementById('downloadBtn');
         const resultBox = document.getElementById('resultBox');
-        const originalBox = document.getElementById('originalBox');
         const resultLabel = document.getElementById('resultLabel');
-        const imageComparison = document.getElementById('imageComparison');
         const progressBar = document.getElementById('progressBar');
         const progressPercentage = document.getElementById('progressPercentage');
         const progressMessage = document.getElementById('progressMessage');
@@ -624,7 +532,7 @@
         const customColorGroup = document.getElementById('customColorGroup');
         
         let selectedFile = null;
-        let currentFeature = 'generate';
+        let currentFeature = 'enhance';
         
         featureTabs.forEach(tab => {
             tab.addEventListener('click', () => {
@@ -634,23 +542,14 @@
                 
                 document.querySelectorAll('.feature-options').forEach(opt => opt.classList.remove('active'));
                 
-                if (currentFeature === 'generate') {
-                    document.getElementById('generateOptions').classList.add('active');
-                    dropZone.style.display = 'none';
-                    processBtn.disabled = false;
-                } else {
-                    dropZone.style.display = 'block';
-                    processBtn.disabled = !selectedFile;
-                    
-                    if (currentFeature === 'enhance') {
-                        document.getElementById('enhanceOptions').classList.add('active');
-                    } else if (currentFeature === 'remove-bg') {
-                        document.getElementById('removeBgOptions').classList.add('active');
-                    } else if (currentFeature === 'denoise') {
-                        document.getElementById('denoiseOptions').classList.add('active');
-                    } else if (currentFeature === 'docscan') {
-                        document.getElementById('docscanOptions').classList.add('active');
-                    }
+                if (currentFeature === 'enhance') {
+                    document.getElementById('enhanceOptions').classList.add('active');
+                } else if (currentFeature === 'remove-bg') {
+                    document.getElementById('removeBgOptions').classList.add('active');
+                } else if (currentFeature === 'denoise') {
+                    document.getElementById('denoiseOptions').classList.add('active');
+                } else if (currentFeature === 'docscan') {
+                    document.getElementById('docscanOptions').classList.add('active');
                 }
                 
                 updateButtonText();
@@ -663,7 +562,6 @@
         
         function updateButtonText() {
             const texts = {
-                'generate': 'Generate Image',
                 'enhance': 'Enhance Image',
                 'remove-bg': 'Remove Background',
                 'denoise': 'Denoise Image',
@@ -705,9 +603,7 @@
             }
             
             selectedFile = file;
-            if (currentFeature !== 'generate') {
-                processBtn.disabled = false;
-            }
+            processBtn.disabled = false;
             dropZone.innerHTML = `
                 <div class="drop-zone-icon">✅</div>
                 <p><strong>${file.name}</strong></p>
@@ -760,155 +656,138 @@
                             const resultResponse = await fetch(resultUrl);
                             
                             if (resultResponse.status === 202) {
-                                await new Promise(r => setTimeout(r, 500));
                                 resultRetries++;
+                                await new Promise(resolve => setTimeout(resolve, 1000));
                                 continue;
                             }
                             
                             if (!resultResponse.ok) {
-                                throw new Error('Failed to get result');
+                                let errorMessage = 'Failed to get result';
+                                try {
+                                    const errorData = await resultResponse.json();
+                                    errorMessage = errorData.detail || errorMessage;
+                                } catch (e) {}
+                                throw new Error(errorMessage);
                             }
                             
                             const blob = await resultResponse.blob();
                             return URL.createObjectURL(blob);
                         }
-                        throw new Error('Result not ready after completion');
+                        throw new Error('Timed out waiting for result');
+                    } else if (data.status === 'failed') {
+                        throw new Error(data.error || data.message || 'Processing failed');
                     }
                     
-                    if (data.status === 'failed') {
-                        throw new Error(data.error || 'Processing failed');
-                    }
-                    
-                    await new Promise(r => setTimeout(r, 1000));
-                } catch (e) {
-                    throw e;
+                    await new Promise(resolve => setTimeout(resolve, 500));
+                } catch (err) {
+                    throw err;
                 }
             }
             
-            throw new Error('Processing timed out');
+            throw new Error('Timed out waiting for processing to complete');
         }
         
         processBtn.addEventListener('click', async () => {
-            if (currentFeature !== 'generate' && !selectedFile) {
-                showError('Please select an image first');
-                return;
-            }
-            
-            if (currentFeature === 'generate') {
-                const prompt = document.getElementById('prompt').value.trim();
-                if (!prompt) {
-                    showError('Please enter a prompt describing the image you want to create');
-                    return;
-                }
-            }
+            if (!selectedFile) return;
             
-            hideError();
-            results.classList.remove('show');
-            loading.classList.add('show');
-            processBtn.disabled = true;
-            resetProgress();
+            const formData = new FormData();
+            formData.append('file', selectedFile);
             
-            let endpoint = '';
-            let formData = new FormData();
-            let useAsync = true;
-            let isGenerate = false;
+            let endpoint = '/enhance/async';
+            let params = new URLSearchParams();
             
-            if (currentFeature === 'generate') {
-                isGenerate = true;
-                const prompt = document.getElementById('prompt').value.trim();
-                const negativePrompt = document.getElementById('negativePrompt').value.trim();
-                const width = document.getElementById('genWidth').value;
-                const height = document.getElementById('genHeight').value;
-                const guidanceScale = document.getElementById('guidanceScale').value;
-                const steps = document.getElementById('steps').value;
-                
-                endpoint = `/generate/async?prompt=${encodeURIComponent(prompt)}&negative_prompt=${encodeURIComponent(negativePrompt)}&width=${width}&height=${height}&guidance_scale=${guidanceScale}&steps=${steps}`;
-                loadingText.textContent = 'Generating image with Stable Diffusion XL...';
-            } else if (currentFeature === 'enhance') {
+            if (currentFeature === 'enhance') {
+                endpoint = '/enhance/async';
                 const scale = document.getElementById('scale').value;
-                endpoint = `/enhance/async?scale=${scale}`;
-                formData.append('file', selectedFile);
-                loadingText.textContent = 'Enhancing with SD x4 Upscaler...';
+                params.append('scale', scale);
+                loadingText.textContent = 'Enhancing your image with AI...';
+                resultLabel.textContent = 'Enhanced';
             } else if (currentFeature === 'remove-bg') {
+                endpoint = '/remove-background/async';
                 let bgcolor = bgcolorSelect.value;
                 if (bgcolor === 'custom') {
                     bgcolor = document.getElementById('customColor').value;
                 }
-                endpoint = `/remove-background/async?bgcolor=${encodeURIComponent(bgcolor)}`;
-                formData.append('file', selectedFile);
-                loadingText.textContent = 'Removing background with RMBG-1.4...';
+                params.append('bgcolor', bgcolor);
+                loadingText.textContent = 'Removing background with AI...';
+                resultLabel.textContent = 'Background Removed';
+                resultBox.classList.add('checkerboard');
             } else if (currentFeature === 'denoise') {
+                endpoint = '/denoise/async';
                 const strength = document.getElementById('strength').value;
-                endpoint = `/denoise/async?strength=${strength}`;
-                formData.append('file', selectedFile);
-                loadingText.textContent = 'Denoising image...';
+                params.append('strength', strength);
+                loadingText.textContent = 'Reducing noise in your image...';
+                resultLabel.textContent = 'Denoised';
             } else if (currentFeature === 'docscan') {
+                endpoint = '/docscan/async';
                 const docScale = document.getElementById('docScale').value;
                 const enhanceHd = document.getElementById('enhanceHd').value;
-                endpoint = `/docscan/async?scale=${docScale}&enhance_hd=${enhanceHd}`;
-                formData.append('file', selectedFile);
-                loadingText.textContent = 'Scanning document...';
+                params.append('scale', docScale);
+                params.append('enhance_hd', enhanceHd);
+                loadingText.textContent = 'Scanning and enhancing document...';
+                resultLabel.textContent = 'Scanned Document';
+            }
+            
+            if (currentFeature !== 'remove-bg') {
+                resultBox.classList.remove('checkerboard');
             }
             
+            loading.classList.add('show');
+            results.classList.remove('show');
+            processBtn.disabled = true;
+            hideError();
+            resetProgress();
+            
             try {
-                let response;
-                if (isGenerate) {
-                    response = await fetch(endpoint, { method: 'POST' });
-                } else {
-                    response = await fetch(endpoint, {
-                        method: 'POST',
-                        body: formData
-                    });
-                }
+                const response = await fetch(`${endpoint}?${params.toString()}`, {
+                    method: 'POST',
+                    body: formData
+                });
                 
                 if (!response.ok) {
-                    const err = await response.json();
-                    throw new Error(err.detail || 'Processing failed');
+                    const errorData = await response.json();
+                    throw new Error(errorData.detail || 'Processing failed');
                 }
                 
-                const data = await response.json();
+                const jobData = await response.json();
+                const jobId = jobData.job_id;
+                const resultUrl = jobData.result_url;
+                
+                updateProgress(5, 'Job started...');
+                
+                const imageUrl = await pollProgress(jobId, resultUrl);
+                
+                updateProgress(100, 'Loading result image...');
+                
+                await new Promise((resolve, reject) => {
+                    processedImg.onload = resolve;
+                    processedImg.onerror = () => reject(new Error('Failed to load result image'));
+                    processedImg.src = imageUrl;
+                    
+                    setTimeout(() => resolve(), 10000);
+                });
+                
+                downloadBtn.href = imageUrl;
+                
+                const filenames = {
+                    'enhance': 'enhanced',
+                    'remove-bg': 'nobg',
+                    'denoise': 'denoised',
+                    'docscan': 'scanned'
+                };
+                const filename = filenames[currentFeature] || 'processed';
+                downloadBtn.download = `${filename}_${selectedFile.name.split('.')[0]}.png`;
                 
-                if (data.job_id) {
-                    const imageUrl = await pollProgress(data.job_id, data.result_url);
-                    showResult(imageUrl, isGenerate);
-                }
-            } catch (e) {
-                showError(e.message);
-            } finally {
                 loading.classList.remove('show');
-                processBtn.disabled = currentFeature !== 'generate' && !selectedFile;
-            }
-        });
-        
-        function showResult(imageUrl, isGenerate = false) {
-            processedImg.src = imageUrl;
-            downloadBtn.href = imageUrl;
-            
-            const labels = {
-                'generate': 'Generated',
-                'enhance': 'Enhanced',
-                'remove-bg': 'Background Removed',
-                'denoise': 'Denoised',
-                'docscan': 'Scanned'
-            };
-            resultLabel.textContent = labels[currentFeature] || 'Processed';
-            
-            if (currentFeature === 'remove-bg') {
-                resultBox.classList.add('checkerboard');
-            } else {
-                resultBox.classList.remove('checkerboard');
-            }
-            
-            if (isGenerate) {
-                originalBox.style.display = 'none';
-                imageComparison.classList.add('single');
-            } else {
-                originalBox.style.display = 'block';
-                imageComparison.classList.remove('single');
+                results.classList.add('show');
+                
+            } catch (err) {
+                showError(err.message);
+                loading.classList.remove('show');
             }
             
-            results.classList.add('show');
-        }
+            processBtn.disabled = false;
+        });
         
         function showError(message) {
             error.textContent = message;
@@ -918,6 +797,8 @@
         function hideError() {
             error.classList.remove('show');
         }
+        
+        updateButtonText();
     </script>
 </body>
 </html>