Add background removal and noise reduction to image processing API

Introduce new API endpoints for background removal and noise reduction, update documentation, and adjust dependencies for broader compatibility.

Replit-Commit-Author: Agent
Replit-Commit-Session-Id: bbef0274-cbeb-475e-9405-87aa3768f3bb
Replit-Commit-Checkpoint-Type: intermediate_checkpoint
Replit-Commit-Event-Id: 9d2f9610-4556-445b-a46a-8f19fcaaec33
Replit-Commit-Screenshot-Url: https://storage.googleapis.com/screenshot-production-us-central1/7d1cb5bc-d8ee-4ca0-b38d-ea189c447bda/bbef0274-cbeb-475e-9405-87aa3768f3bb/XXl5CtQ

.replit

@@ -35,5 +35,5 @@ localPort = 5000
 externalPort = 80
 
 [[ports]]
-localPort = 43219
+localPort = 38887
 externalPort = 3000

Dockerfile

@@ -9,6 +9,9 @@ RUN apt-get update && apt-get install -y \
     && rm -rf /var/lib/apt/lists/*
 
 COPY requirements.txt .
+
+RUN pip install --no-cache-dir torch torchvision --index-url https://download.pytorch.org/whl/cpu
+
 RUN pip install --no-cache-dir -r requirements.txt
 
 COPY . .

README.md

@@ -1,5 +1,5 @@
 ---
-title: AI Image Enhancer
+title: AI Image Processing
 emoji: 🖼️
 colorFrom: blue
 colorTo: purple
@@ -8,56 +8,57 @@ pinned: false
 license: mit
 ---
 
-# AI Image Enhancer API
+# AI Image Processing API
 
-A powerful image enhancement API using Real-ESRGAN, a state-of-the-art deep learning model for image super-resolution and quality enhancement.
+A comprehensive image processing API with multiple AI-powered features including super-resolution, background removal, and noise reduction.
 
 ## Features
 
-- **Image Super-Resolution**: Upscale images 2x or 4x while maintaining quality
-- **AI-Powered Enhancement**: Uses Real-ESRGAN x4plus 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
 - **RESTful API**: Full API with automatic OpenAPI/Swagger documentation
 - **Web Interface**: Simple drag-and-drop interface for testing
-- **Multiple Output Formats**: Download as file or receive as base64
 
 ## API Endpoints
 
-### `GET /docs`
-Interactive Swagger UI documentation
-
-### `GET /redoc`
-ReDoc documentation
-
-### `POST /enhance`
-Enhance an image file
+### Image Enhancement
+#### `POST /enhance`
+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)
 
-**Returns:** Enhanced image as PNG file
-
-### `POST /enhance/base64`
-Enhance an image and return as base64
+### Background Removal
+#### `POST /remove-background`
+Remove background from an image using BiRefNet AI model.
 
 **Parameters:**
 - `file`: Image file
-- `scale`: Upscale factor (2 or 4)
+- `bgcolor`: Background color - 'transparent', 'white', 'black', or hex color like '#FF0000'
 
-**Returns:** JSON with base64-encoded image and metadata
+### Noise Reduction
+#### `POST /denoise`
+Reduce image noise using Non-Local Means Denoising.
 
-### `GET /model-info`
-Get information about the loaded AI model
+**Parameters:**
+- `file`: Image file
+- `strength`: Denoising strength (1-30, default: 10)
 
-### `GET /health`
-Health check endpoint
+### Other Endpoints
+- `GET /docs` - Interactive Swagger UI documentation
+- `GET /redoc` - ReDoc documentation
+- `GET /model-info` - Get information about loaded AI models
+- `GET /health` - Health check endpoint
 
-## Model Information
+## Models Used
 
-- **Model**: Real-ESRGAN x4plus
-- **Architecture**: ESRGAN with RRDB blocks
-- **Capabilities**: General image restoration, super-resolution, artifact removal
-- **Source**: [xinntao/Real-ESRGAN](https://github.com/xinntao/Real-ESRGAN)
+| Feature | Model | Description |
+|---------|-------|-------------|
+| 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 |
 
 ## Local Development
 
@@ -80,7 +81,7 @@ The server will start at `http://localhost:7860`
 
 ## API Usage Examples
 
-### Python
+### Python - Image Enhancement
 ```python
 import requests
 
@@ -95,24 +96,49 @@ with open("enhanced.png", "wb") as f:
     f.write(response.content)
 ```
 
-### cURL
-```bash
-curl -X POST "https://your-space.hf.space/enhance?scale=4" \
-  -F "file=@image.jpg" \
-  -o enhanced.png
+### Python - Background Removal
+```python
+import requests
+
+with open("photo.jpg", "rb") as f:
+    response = requests.post(
+        "https://your-space.hf.space/remove-background",
+        files={"file": f},
+        params={"bgcolor": "transparent"}
+    )
+    
+with open("no_background.png", "wb") as f:
+    f.write(response.content)
 ```
 
-### JavaScript
-```javascript
-const formData = new FormData();
-formData.append('file', imageFile);
+### Python - Noise Reduction
+```python
+import requests
+
+with open("noisy.jpg", "rb") as f:
+    response = requests.post(
+        "https://your-space.hf.space/denoise",
+        files={"file": f},
+        params={"strength": 15}
+    )
+    
+with open("denoised.png", "wb") as f:
+    f.write(response.content)
+```
+
+### cURL Examples
+```bash
+# Enhance image
+curl -X POST "https://your-space.hf.space/enhance?scale=4" \
+  -F "file=@image.jpg" -o enhanced.png
 
-const response = await fetch('/enhance?scale=4', {
-  method: 'POST',
-  body: formData
-});
+# Remove background
+curl -X POST "https://your-space.hf.space/remove-background?bgcolor=transparent" \
+  -F "file=@photo.jpg" -o nobg.png
 
-const blob = await response.blob();
+# Denoise image
+curl -X POST "https://your-space.hf.space/denoise?strength=10" \
+  -F "file=@noisy.jpg" -o denoised.png
 ```
 
 ## License

app.py

@@ -7,6 +7,7 @@ from fastapi.responses import FileResponse, HTMLResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.middleware.cors import CORSMiddleware
 from PIL import Image
+import numpy as np
 
 UPLOAD_DIR = Path("uploads")
 OUTPUT_DIR = Path("outputs")
@@ -14,26 +15,27 @@ UPLOAD_DIR.mkdir(exist_ok=True)
 OUTPUT_DIR.mkdir(exist_ok=True)
 
 app = FastAPI(
-    title="AI Image Enhancer API",
+    title="AI Image Processing API",
     description="""
-## AI-Powered Image Enhancement API
+## AI-Powered Image Processing API
 
-This API uses Real-ESRGAN, a state-of-the-art deep learning model for image super-resolution and enhancement.
+A comprehensive image processing API with multiple AI-powered features.
 
 ### Features:
-- **Image Upscaling**: Enhance image resolution up to 4x
+- **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
 - **Quality Enhancement**: Improve image clarity and reduce artifacts
-- **Multiple Scale Options**: Choose between 2x and 4x upscaling
 
 ### Supported Formats:
 - PNG, JPG, JPEG, WebP, BMP
 
-### Model Information:
-- **Model**: Real-ESRGAN x4plus
-- **Architecture**: ESRGAN with RRDB blocks
-- **Training**: Trained on diverse image datasets for general-purpose enhancement
+### Models Used:
+- **Super Resolution**: Real-ESRGAN x4plus
+- **Background Removal**: rembg with BiRefNet-massive model
+- **Noise Reduction**: OpenCV Non-Local Means Denoising
     """,
-    version="1.0.0",
+    version="2.0.0",
     docs_url="/docs",
     redoc_url="/redoc",
 )
@@ -47,6 +49,7 @@ app.add_middleware(
 )
 
 enhancer = None
+bg_remover_session = None
 
 def get_enhancer():
     global enhancer
@@ -55,17 +58,24 @@ def get_enhancer():
         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 enhancement."""
+    """Serve the main HTML page for testing image processing."""
     html_path = Path("templates/index.html")
     if html_path.exists():
         return html_path.read_text()
     return """
     <html>
-        <head><title>AI Image Enhancer</title></head>
+        <head><title>AI Image Processing</title></head>
         <body>
-            <h1>AI Image Enhancer</h1>
+            <h1>AI Image Processing API</h1>
             <p>Visit <a href="/docs">/docs</a> for API documentation.</p>
         </body>
     </html>
@@ -74,18 +84,36 @@ async def home():
 @app.get("/health")
 async def health_check():
     """Health check endpoint."""
-    return {"status": "healthy", "model": "Real-ESRGAN x4plus"}
+    return {
+        "status": "healthy", 
+        "version": "2.0.0",
+        "features": ["enhance", "remove-background", "denoise"]
+    }
 
 @app.get("/model-info")
 async def model_info():
-    """Get information about the loaded AI model."""
+    """Get information about the loaded AI models."""
     return {
-        "model_name": "Real-ESRGAN x4plus",
-        "description": "Real-ESRGAN model for general image restoration and super-resolution",
-        "upscale_factors": [2, 4],
+        "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"
+            }
+        },
         "supported_formats": ["png", "jpg", "jpeg", "webp", "bmp"],
-        "max_input_size": "2048x2048 recommended",
-        "source": "https://github.com/xinntao/Real-ESRGAN"
+        "max_input_size": "2048x2048 recommended"
     }
 
 @app.post("/enhance")
@@ -122,11 +150,8 @@ async def enhance_image(
             input_image = input_image.resize(new_size, Image.LANCZOS)
         
         file_id = str(uuid.uuid4())
-        input_path = UPLOAD_DIR / f"{file_id}_input.png"
         output_path = OUTPUT_DIR / f"{file_id}_enhanced.png"
         
-        input_image.save(input_path, "PNG")
-        
         try:
             enhancer_instance = get_enhancer()
             enhanced_image = enhancer_instance.enhance(input_image, scale=scale)
@@ -205,6 +230,252 @@ async def enhance_image_base64(
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error processing image: {str(e)}")
 
+@app.post("/remove-background")
+async def remove_background(
+    file: UploadFile = File(..., description="Image file to remove background from"),
+    bgcolor: str = Query(default="transparent", description="Background color: 'transparent', 'white', 'black', or hex color like '#FF0000'")
+):
+    """
+    Remove background from an image using AI.
+    
+    - **file**: Upload an image file (PNG, JPG, JPEG, WebP, BMP)
+    - **bgcolor**: Background color after removal. Options:
+        - 'transparent' (default) - Transparent background (PNG)
+        - 'white' - White background
+        - 'black' - Black background  
+        - Hex color like '#FF0000' - Custom color
+    
+    Returns the image with background removed as PNG.
+    """
+    allowed_types = ["image/png", "image/jpeg", "image/jpg", "image/webp", "image/bmp"]
+    if file.content_type not in allowed_types:
+        raise HTTPException(
+            status_code=400, 
+            detail=f"Invalid file type. Allowed types: {', '.join(allowed_types)}"
+        )
+    
+    try:
+        contents = await file.read()
+        
+        bg_color = None
+        if bgcolor != "transparent":
+            if bgcolor == "white":
+                bg_color = (255, 255, 255, 255)
+            elif bgcolor == "black":
+                bg_color = (0, 0, 0, 255)
+            elif bgcolor.startswith("#"):
+                hex_color = bgcolor.lstrip("#")
+                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)
+        
+        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"
+        output_image.save(output_path, "PNG")
+        
+        return FileResponse(
+            output_path,
+            media_type="image/png",
+            filename=f"nobg_{file.filename.rsplit('.', 1)[0]}.png"
+        )
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error removing background: {str(e)}")
+
+@app.post("/remove-background/base64")
+async def remove_background_base64(
+    file: UploadFile = File(..., description="Image file to remove background from"),
+    bgcolor: str = Query(default="transparent", description="Background color after removal")
+):
+    """
+    Remove background from 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(
+            status_code=400, 
+            detail=f"Invalid file type. Allowed types: {', '.join(allowed_types)}"
+        )
+    
+    try:
+        contents = await file.read()
+        input_image = Image.open(io.BytesIO(contents))
+        
+        bg_color = None
+        if bgcolor != "transparent":
+            if bgcolor == "white":
+                bg_color = (255, 255, 255, 255)
+            elif bgcolor == "black":
+                bg_color = (0, 0, 0, 255)
+            elif bgcolor.startswith("#"):
+                hex_color = bgcolor.lstrip("#")
+                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)
+        
+        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")
+        buffer.seek(0)
+        
+        img_base64 = base64.b64encode(buffer.getvalue()).decode("utf-8")
+        
+        return JSONResponse({
+            "success": True,
+            "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
+        })
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error removing background: {str(e)}")
+
+@app.post("/denoise")
+async def denoise_image(
+    file: UploadFile = File(..., description="Image file to denoise"),
+    strength: int = Query(default=10, ge=1, le=30, description="Denoising strength (1-30, higher = more smoothing)")
+):
+    """
+    Reduce noise in an image using Non-Local Means Denoising.
+    
+    - **file**: Upload an image file (PNG, JPG, JPEG, WebP, BMP)
+    - **strength**: Denoising strength from 1 to 30
+        - Low (1-5): Light noise reduction, preserves details
+        - Medium (6-15): Balanced noise reduction
+        - High (16-30): Strong noise reduction, may lose some details
+    
+    Returns the denoised image as PNG.
+    """
+    allowed_types = ["image/png", "image/jpeg", "image/jpg", "image/webp", "image/bmp"]
+    if file.content_type not in allowed_types:
+        raise HTTPException(
+            status_code=400, 
+            detail=f"Invalid file type. Allowed types: {', '.join(allowed_types)}"
+        )
+    
+    try:
+        contents = await file.read()
+        input_image = Image.open(io.BytesIO(contents))
+        
+        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"
+        output_image.save(output_path, "PNG")
+        
+        return FileResponse(
+            output_path,
+            media_type="image/png",
+            filename=f"denoised_{file.filename.rsplit('.', 1)[0]}.png"
+        )
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error denoising image: {str(e)}")
+
+@app.post("/denoise/base64")
+async def denoise_image_base64(
+    file: UploadFile = File(..., description="Image file to denoise"),
+    strength: int = Query(default=10, ge=1, le=30, description="Denoising strength (1-30)")
+):
+    """
+    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(
+            status_code=400, 
+            detail=f"Invalid file type. Allowed types: {', '.join(allowed_types)}"
+        )
+    
+    try:
+        contents = await file.read()
+        input_image = Image.open(io.BytesIO(contents))
+        
+        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")
+        buffer.seek(0)
+        
+        img_base64 = base64.b64encode(buffer.getvalue()).decode("utf-8")
+        
+        return JSONResponse({
+            "success": True,
+            "image_base64": img_base64,
+            "original_size": {"width": input_image.width, "height": input_image.height},
+            "strength": strength
+        })
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error denoising image: {str(e)}")
+
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)

app_local.py

@@ -1,15 +1,13 @@
 """
 Lightweight local preview server for testing the API structure.
-This version uses simple image resizing instead of the AI model.
-For full AI enhancement, deploy to Hugging Face Spaces.
+This version uses simple image processing instead of AI models.
+For full AI processing, deploy to Hugging Face Spaces.
 """
-import os
 import io
 import uuid
 from pathlib import Path
 from http.server import HTTPServer, SimpleHTTPRequestHandler
 import json
-import cgi
 import urllib.parse
 
 UPLOAD_DIR = Path("uploads")
@@ -27,16 +25,30 @@ class APIHandler(SimpleHTTPRequestHandler):
         elif path == "/docs":
             self.serve_swagger()
         elif path == "/health":
-            self.send_json({"status": "healthy", "model": "Real-ESRGAN x4plus (preview mode)"})
+            self.send_json({
+                "status": "healthy",
+                "version": "2.0.0 (preview)",
+                "features": ["enhance", "remove-background", "denoise"]
+            })
         elif path == "/model-info":
             self.send_json({
-                "model_name": "Real-ESRGAN x4plus",
-                "description": "Real-ESRGAN model for general image restoration and super-resolution",
-                "upscale_factors": [2, 4],
-                "supported_formats": ["png", "jpg", "jpeg", "webp", "bmp"],
-                "max_input_size": "2048x2048 recommended",
-                "source": "https://github.com/xinntao/Real-ESRGAN",
-                "note": "Running in preview mode - deploy to Hugging Face for full AI enhancement"
+                "models": {
+                    "super_resolution": {
+                        "name": "Real-ESRGAN x4plus",
+                        "description": "State-of-the-art image super-resolution",
+                        "note": "Preview mode - deploy to HF Spaces for full AI"
+                    },
+                    "background_removal": {
+                        "name": "BiRefNet-general",
+                        "description": "High-accuracy background removal",
+                        "note": "Preview mode - deploy to HF Spaces for full AI"
+                    },
+                    "noise_reduction": {
+                        "name": "Non-Local Means Denoising",
+                        "description": "Advanced noise reduction algorithm"
+                    }
+                },
+                "supported_formats": ["png", "jpg", "jpeg", "webp", "bmp"]
             })
         elif path == "/openapi.json":
             self.serve_openapi()
@@ -52,30 +64,55 @@ class APIHandler(SimpleHTTPRequestHandler):
         
         if path == "/enhance" or path == "/enhance/base64":
             self.handle_enhance(path, query)
+        elif path == "/remove-background" or path == "/remove-background/base64":
+            self.handle_remove_background(path, query)
+        elif path == "/denoise" or path == "/denoise/base64":
+            self.handle_denoise(path, query)
         else:
             self.send_error(404, "Not Found")
     
+    def parse_multipart(self):
+        content_type = self.headers.get('Content-Type', '')
+        if 'multipart/form-data' not in content_type:
+            return None
+        
+        boundary = None
+        for part in content_type.split(';'):
+            if 'boundary=' in part:
+                boundary = part.split('=')[1].strip()
+                break
+        
+        if not boundary:
+            return None
+        
+        content_length = int(self.headers.get('Content-Length', 0))
+        body = self.rfile.read(content_length)
+        
+        boundary_bytes = boundary.encode()
+        parts = body.split(b'--' + boundary_bytes)
+        
+        for part in parts:
+            if b'filename=' in part:
+                header_end = part.find(b'\r\n\r\n')
+                if header_end != -1:
+                    file_data = part[header_end + 4:]
+                    if file_data.endswith(b'\r\n'):
+                        file_data = file_data[:-2]
+                    if file_data.endswith(b'--'):
+                        file_data = file_data[:-2]
+                    if file_data.endswith(b'\r\n'):
+                        file_data = file_data[:-2]
+                    return file_data
+        
+        return None
+    
     def handle_enhance(self, path, query):
         try:
-            content_type = self.headers.get('Content-Type', '')
-            if 'multipart/form-data' not in content_type:
-                self.send_error(400, "Expected multipart/form-data")
-                return
-            
-            form = cgi.FieldStorage(
-                fp=self.rfile,
-                headers=self.headers,
-                environ={'REQUEST_METHOD': 'POST', 'CONTENT_TYPE': content_type}
-            )
-            
-            if 'file' not in form:
+            file_data = self.parse_multipart()
+            if not file_data:
                 self.send_error(400, "No file uploaded")
                 return
             
-            file_item = form['file']
-            file_data = file_item.file.read()
-            filename = file_item.filename
-            
             scale = int(query.get('scale', [4])[0])
             if scale not in [2, 4]:
                 scale = 4
@@ -116,7 +153,103 @@ class APIHandler(SimpleHTTPRequestHandler):
             else:
                 self.send_response(200)
                 self.send_header('Content-Type', 'image/png')
-                self.send_header('Content-Disposition', f'attachment; filename="enhanced_{filename.rsplit(".", 1)[0]}.png"')
+                self.send_header('Content-Disposition', 'attachment; filename="enhanced.png"')
+                self.end_headers()
+                with open(output_path, 'rb') as f:
+                    self.wfile.write(f.read())
+                    
+        except Exception as e:
+            self.send_error(500, f"Error processing image: {str(e)}")
+    
+    def handle_remove_background(self, path, query):
+        try:
+            file_data = self.parse_multipart()
+            if not file_data:
+                self.send_error(400, "No file uploaded")
+                return
+            
+            bgcolor = query.get('bgcolor', ['transparent'])[0]
+            
+            from PIL import Image
+            input_image = Image.open(io.BytesIO(file_data))
+            
+            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"
+            output_image.save(output_path, "PNG")
+            
+            if "/base64" in path:
+                import base64
+                buffer = io.BytesIO()
+                output_image.save(buffer, format="PNG")
+                buffer.seek(0)
+                img_base64 = base64.b64encode(buffer.getvalue()).decode("utf-8")
+                
+                self.send_json({
+                    "success": True,
+                    "image_base64": img_base64,
+                    "original_size": {"width": input_image.width, "height": input_image.height},
+                    "background": bgcolor,
+                    "note": "Preview mode - deploy to Hugging Face for AI background removal"
+                })
+            else:
+                self.send_response(200)
+                self.send_header('Content-Type', 'image/png')
+                self.send_header('Content-Disposition', 'attachment; filename="nobg.png"')
+                self.end_headers()
+                with open(output_path, 'rb') as f:
+                    self.wfile.write(f.read())
+                    
+        except Exception as e:
+            self.send_error(500, f"Error processing image: {str(e)}")
+    
+    def handle_denoise(self, path, query):
+        try:
+            file_data = self.parse_multipart()
+            if not file_data:
+                self.send_error(400, "No file uploaded")
+                return
+            
+            strength = int(query.get('strength', [10])[0])
+            
+            from PIL import Image, ImageFilter
+            input_image = Image.open(io.BytesIO(file_data))
+            
+            if input_image.mode != "RGB":
+                input_image = input_image.convert("RGB")
+            
+            output_image = input_image.filter(ImageFilter.SMOOTH_MORE)
+            if strength > 10:
+                output_image = output_image.filter(ImageFilter.SMOOTH_MORE)
+            if strength > 20:
+                output_image = output_image.filter(ImageFilter.SMOOTH_MORE)
+            
+            file_id = str(uuid.uuid4())
+            output_path = OUTPUT_DIR / f"{file_id}_denoised.png"
+            output_image.save(output_path, "PNG")
+            
+            if "/base64" in path:
+                import base64
+                buffer = io.BytesIO()
+                output_image.save(buffer, format="PNG")
+                buffer.seek(0)
+                img_base64 = base64.b64encode(buffer.getvalue()).decode("utf-8")
+                
+                self.send_json({
+                    "success": True,
+                    "image_base64": img_base64,
+                    "original_size": {"width": input_image.width, "height": input_image.height},
+                    "strength": strength,
+                    "note": "Preview mode - deploy to Hugging Face for AI denoising"
+                })
+            else:
+                self.send_response(200)
+                self.send_header('Content-Type', 'image/png')
+                self.send_header('Content-Disposition', 'attachment; filename="denoised.png"')
                 self.end_headers()
                 with open(output_path, 'rb') as f:
                     self.wfile.write(f.read())
@@ -139,7 +272,7 @@ class APIHandler(SimpleHTTPRequestHandler):
         swagger_html = """<!DOCTYPE html>
 <html>
 <head>
-    <title>AI Image Enhancer - API Documentation</title>
+    <title>AI Image Processing - API Documentation</title>
     <link rel="stylesheet" type="text/css" href="https://unpkg.com/swagger-ui-dist@5/swagger-ui.css">
     <style>
         body { margin: 0; padding: 0; }
@@ -171,134 +304,41 @@ class APIHandler(SimpleHTTPRequestHandler):
         openapi_spec = {
             "openapi": "3.1.0",
             "info": {
-                "title": "AI Image Enhancer API",
-                "description": "AI-Powered Image Enhancement API using Real-ESRGAN deep learning model.\n\n**Features:**\n- Image upscaling up to 4x resolution\n- Quality enhancement and artifact removal\n- RESTful API with multiple output formats\n\n**Note:** This is a preview deployment. For full AI enhancement, deploy to Hugging Face Spaces.",
-                "version": "1.0.0",
-                "contact": {"name": "AI Image Enhancer"}
+                "title": "AI Image Processing API",
+                "description": "Comprehensive AI-powered image processing API.\n\n**Features:**\n- Image enhancement and upscaling (Real-ESRGAN)\n- Background removal (BiRefNet)\n- Noise reduction (OpenCV NLM)\n\n**Note:** This is a preview deployment. Deploy to Hugging Face Spaces for full AI processing.",
+                "version": "2.0.0"
             },
             "servers": [{"url": "/", "description": "Current server"}],
             "paths": {
                 "/enhance": {
                     "post": {
-                        "summary": "Enhance an image",
-                        "description": "Upload an image and receive an enhanced version with improved resolution and quality.",
-                        "operationId": "enhance_image",
-                        "parameters": [
-                            {
-                                "name": "scale",
-                                "in": "query",
-                                "description": "Upscale factor (2 or 4)",
-                                "required": False,
-                                "schema": {"type": "integer", "default": 4, "enum": [2, 4]}
-                            }
-                        ],
-                        "requestBody": {
-                            "required": True,
-                            "content": {
-                                "multipart/form-data": {
-                                    "schema": {
-                                        "type": "object",
-                                        "required": ["file"],
-                                        "properties": {
-                                            "file": {
-                                                "type": "string",
-                                                "format": "binary",
-                                                "description": "Image file (PNG, JPG, JPEG, WebP, BMP)"
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        },
-                        "responses": {
-                            "200": {
-                                "description": "Enhanced image",
-                                "content": {"image/png": {"schema": {"type": "string", "format": "binary"}}}
-                            },
-                            "400": {"description": "Invalid file type"},
-                            "500": {"description": "Processing error"}
-                        }
+                        "summary": "Enhance image (upscale)",
+                        "description": "Upscale and enhance image quality using Real-ESRGAN.",
+                        "parameters": [{"name": "scale", "in": "query", "schema": {"type": "integer", "default": 4, "enum": [2, 4]}}],
+                        "requestBody": {"required": True, "content": {"multipart/form-data": {"schema": {"type": "object", "properties": {"file": {"type": "string", "format": "binary"}}}}}},
+                        "responses": {"200": {"description": "Enhanced image"}}
                     }
                 },
-                "/enhance/base64": {
+                "/remove-background": {
                     "post": {
-                        "summary": "Enhance an image (Base64 response)",
-                        "description": "Upload an image and receive an enhanced version as a base64-encoded string.",
-                        "operationId": "enhance_image_base64",
-                        "parameters": [
-                            {
-                                "name": "scale",
-                                "in": "query",
-                                "description": "Upscale factor (2 or 4)",
-                                "required": False,
-                                "schema": {"type": "integer", "default": 4, "enum": [2, 4]}
-                            }
-                        ],
-                        "requestBody": {
-                            "required": True,
-                            "content": {
-                                "multipart/form-data": {
-                                    "schema": {
-                                        "type": "object",
-                                        "required": ["file"],
-                                        "properties": {
-                                            "file": {
-                                                "type": "string",
-                                                "format": "binary",
-                                                "description": "Image file"
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        },
-                        "responses": {
-                            "200": {
-                                "description": "Enhanced image data",
-                                "content": {
-                                    "application/json": {
-                                        "schema": {
-                                            "type": "object",
-                                            "properties": {
-                                                "success": {"type": "boolean"},
-                                                "image_base64": {"type": "string"},
-                                                "original_size": {"type": "object"},
-                                                "enhanced_size": {"type": "object"},
-                                                "scale_factor": {"type": "integer"}
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
+                        "summary": "Remove background",
+                        "description": "Remove background from image using BiRefNet AI model.",
+                        "parameters": [{"name": "bgcolor", "in": "query", "schema": {"type": "string", "default": "transparent"}}],
+                        "requestBody": {"required": True, "content": {"multipart/form-data": {"schema": {"type": "object", "properties": {"file": {"type": "string", "format": "binary"}}}}}},
+                        "responses": {"200": {"description": "Image with background removed"}}
                     }
                 },
-                "/health": {
-                    "get": {
-                        "summary": "Health check",
-                        "description": "Check if the API is running",
-                        "operationId": "health_check",
-                        "responses": {
-                            "200": {
-                                "description": "API status",
-                                "content": {"application/json": {"schema": {"type": "object"}}}
-                            }
-                        }
+                "/denoise": {
+                    "post": {
+                        "summary": "Reduce noise",
+                        "description": "Reduce image noise using Non-Local Means Denoising.",
+                        "parameters": [{"name": "strength", "in": "query", "schema": {"type": "integer", "default": 10, "minimum": 1, "maximum": 30}}],
+                        "requestBody": {"required": True, "content": {"multipart/form-data": {"schema": {"type": "object", "properties": {"file": {"type": "string", "format": "binary"}}}}}},
+                        "responses": {"200": {"description": "Denoised image"}}
                     }
                 },
-                "/model-info": {
-                    "get": {
-                        "summary": "Model information",
-                        "description": "Get information about the loaded AI model",
-                        "operationId": "model_info",
-                        "responses": {
-                            "200": {
-                                "description": "Model details",
-                                "content": {"application/json": {"schema": {"type": "object"}}}
-                            }
-                        }
-                    }
-                }
+                "/health": {"get": {"summary": "Health check", "responses": {"200": {"description": "API status"}}}},
+                "/model-info": {"get": {"summary": "Model information", "responses": {"200": {"description": "Model details"}}}}
             }
         }
         self.send_json(openapi_spec)
@@ -324,11 +364,11 @@ class APIHandler(SimpleHTTPRequestHandler):
 def run_server(port=5000):
     server_address = ('0.0.0.0', port)
     httpd = HTTPServer(server_address, APIHandler)
-    print(f"AI Image Enhancer API running at http://0.0.0.0:{port}")
+    print(f"AI Image Processing API running at http://0.0.0.0:{port}")
     print(f"API Documentation: http://0.0.0.0:{port}/docs")
     print(f"Frontend: http://0.0.0.0:{port}/")
-    print("\nNote: This is a preview mode using simple upscaling.")
-    print("For full AI enhancement, deploy to Hugging Face Spaces.")
+    print("\nNote: This is preview mode using simple processing.")
+    print("Deploy to Hugging Face Spaces for full AI features.")
     httpd.serve_forever()
 
 if __name__ == "__main__":

replit.md

@@ -1,13 +1,15 @@
-# AI Image Enhancer
+# AI Image Processing
 
 ## Overview
-An AI-powered image enhancement API using Real-ESRGAN for image super-resolution. The app includes:
+An AI-powered image processing API with multiple features:
+- Image enhancement/upscaling using Real-ESRGAN
+- Background removal using BiRefNet via rembg
+- Noise reduction using OpenCV Non-Local Means Denoising
 - FastAPI backend with automatic Swagger API documentation
-- Simple web frontend for testing image uploads
-- Designed for deployment to Hugging Face Spaces
+- Simple web frontend for testing
 
 ## Current State
-- **Local Preview**: Running with simple upscaling (no AI model due to size constraints)
+- **Local Preview**: Running with simple processing (no heavy AI models due to size constraints)
 - **Full AI Mode**: Available when deployed to Hugging Face Spaces
 
 ## Project Structure
@@ -22,7 +24,7 @@ An AI-powered image enhancement API using Real-ESRGAN for image super-resolution
 ├── Dockerfile          # Docker configuration for HF Spaces
 ├── README.md           # Hugging Face Spaces configuration
 ├── uploads/            # Temporary upload storage
-└── outputs/            # Enhanced image outputs
+└── outputs/            # Processed image outputs
 ```
 
 ## API Endpoints
@@ -30,16 +32,25 @@ An AI-powered image enhancement API using Real-ESRGAN for image super-resolution
 - `GET /docs` - Swagger API documentation
 - `GET /health` - Health check
 - `GET /model-info` - Model information
-- `POST /enhance` - Enhance image (returns PNG file)
-- `POST /enhance/base64` - Enhance image (returns base64 JSON)
+- `POST /enhance` - Enhance/upscale image (Real-ESRGAN)
+- `POST /enhance/base64` - Enhance image (returns base64)
+- `POST /remove-background` - Remove image background (BiRefNet)
+- `POST /remove-background/base64` - Remove background (returns base64)
+- `POST /denoise` - Reduce image noise (OpenCV NLM)
+- `POST /denoise/base64` - Denoise image (returns base64)
 
 ## Deploying to Hugging Face Spaces
 1. Create a new Space on Hugging Face
 2. Select "Docker" as the SDK
 3. Upload all files: `app.py`, `enhancer.py`, `templates/`, `requirements.txt`, `Dockerfile`, `README.md`
-4. The Space will auto-build the container and download the Real-ESRGAN model
+4. The Space will auto-build the container and download AI models
 
 ## Recent Changes
+- 2025-11-28: Added background removal and noise reduction features
+  - BiRefNet integration via rembg for background removal
+  - OpenCV Non-Local Means Denoising
+  - Updated frontend with feature tabs
+  - Updated API documentation
 - 2025-11-28: Initial creation of AI Image Enhancer API
   - FastAPI backend with Swagger docs
   - Real-ESRGAN integration for Hugging Face

requirements.txt

@@ -3,9 +3,11 @@ uvicorn[standard]==0.27.0
 python-multipart==0.0.6
 pillow==10.2.0
 numpy==1.26.3
+opencv-python-headless==4.9.0.80
 torch>=2.1.0
 torchvision>=0.16.0
 realesrgan==0.3.0
 basicsr==1.4.2
 gfpgan==1.3.8
-pillow
+rembg==2.0.50
+onnxruntime==1.17.0

templates/index.html

@@ -3,7 +3,7 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>AI Image Enhancer</title>
+    <title>AI Image Processing</title>
     <style>
         * {
             box-sizing: border-box;
@@ -114,7 +114,7 @@
             color: #888;
         }
         
-        select {
+        select, input[type="text"] {
             width: 100%;
             padding: 12px;
             border-radius: 8px;
@@ -124,7 +124,46 @@
             font-size: 1rem;
         }
         
-        .enhance-btn {
+        .feature-tabs {
+            display: flex;
+            gap: 10px;
+            margin-bottom: 20px;
+            flex-wrap: wrap;
+        }
+        
+        .feature-tab {
+            padding: 12px 24px;
+            border: none;
+            border-radius: 8px;
+            background: rgba(255, 255, 255, 0.1);
+            color: #888;
+            cursor: pointer;
+            transition: all 0.3s;
+            font-size: 1rem;
+        }
+        
+        .feature-tab:hover {
+            background: rgba(255, 255, 255, 0.15);
+        }
+        
+        .feature-tab.active {
+            background: linear-gradient(90deg, #00d2ff, #3a7bd5);
+            color: #fff;
+        }
+        
+        .feature-options {
+            display: none;
+            padding: 15px;
+            background: rgba(255, 255, 255, 0.03);
+            border-radius: 8px;
+            margin-bottom: 15px;
+        }
+        
+        .feature-options.active {
+            display: block;
+        }
+        
+        .process-btn {
             width: 100%;
             padding: 15px;
             margin-top: 20px;
@@ -138,12 +177,12 @@
             transition: transform 0.2s, box-shadow 0.2s;
         }
         
-        .enhance-btn:hover:not(:disabled) {
+        .process-btn:hover:not(:disabled) {
             transform: translateY(-2px);
             box-shadow: 0 10px 30px rgba(0, 210, 255, 0.3);
         }
         
-        .enhance-btn:disabled {
+        .process-btn:disabled {
             opacity: 0.5;
             cursor: not-allowed;
         }
@@ -271,19 +310,36 @@
             color: #888;
             font-size: 0.9rem;
         }
+        
+        .checkerboard {
+            background-image: 
+                linear-gradient(45deg, #666 25%, transparent 25%),
+                linear-gradient(-45deg, #666 25%, transparent 25%),
+                linear-gradient(45deg, transparent 75%, #666 75%),
+                linear-gradient(-45deg, transparent 75%, #666 75%);
+            background-size: 20px 20px;
+            background-position: 0 0, 0 10px, 10px -10px, -10px 0px;
+            background-color: #444;
+        }
     </style>
 </head>
 <body>
     <div class="container">
         <header>
-            <h1>AI Image Enhancer</h1>
-            <p class="subtitle">Enhance your images using Real-ESRGAN deep learning model</p>
+            <h1>AI Image Processing</h1>
+            <p class="subtitle">Enhance, remove backgrounds, and denoise your images with AI</p>
             <div class="api-link">
                 <a href="/docs" target="_blank">View API Documentation</a>
             </div>
         </header>
         
         <section class="upload-section">
+            <div class="feature-tabs">
+                <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>
+            </div>
+            
             <div class="drop-zone" id="dropZone">
                 <div class="drop-zone-icon">📷</div>
                 <p>Drag & drop an image here or click to select</p>
@@ -291,25 +347,60 @@
             </div>
             <input type="file" id="fileInput" accept="image/png,image/jpeg,image/jpg,image/webp,image/bmp">
             
-            <div class="options">
-                <div class="option-group">
-                    <label for="scale">Upscale Factor</label>
-                    <select id="scale">
-                        <option value="2">2x - Double resolution</option>
-                        <option value="4" selected>4x - Quadruple resolution</option>
-                    </select>
+            <div id="enhanceOptions" class="feature-options active">
+                <div class="options">
+                    <div class="option-group">
+                        <label for="scale">Upscale Factor</label>
+                        <select id="scale">
+                            <option value="2">2x - Double resolution</option>
+                            <option value="4" selected>4x - Quadruple resolution</option>
+                        </select>
+                    </div>
+                </div>
+            </div>
+            
+            <div id="removeBgOptions" class="feature-options">
+                <div class="options">
+                    <div class="option-group">
+                        <label for="bgcolor">Background Color</label>
+                        <select id="bgcolor">
+                            <option value="transparent" selected>Transparent</option>
+                            <option value="white">White</option>
+                            <option value="black">Black</option>
+                            <option value="custom">Custom Color</option>
+                        </select>
+                    </div>
+                    <div class="option-group" id="customColorGroup" style="display: none;">
+                        <label for="customColor">Custom Color (Hex)</label>
+                        <input type="text" id="customColor" placeholder="#FF0000" value="#FFFFFF">
+                    </div>
+                </div>
+            </div>
+            
+            <div id="denoiseOptions" class="feature-options">
+                <div class="options">
+                    <div class="option-group">
+                        <label for="strength">Denoise Strength</label>
+                        <select id="strength">
+                            <option value="5">Light (5) - Preserves details</option>
+                            <option value="10" selected>Medium (10) - Balanced</option>
+                            <option value="15">Strong (15) - More smoothing</option>
+                            <option value="20">Very Strong (20)</option>
+                            <option value="30">Maximum (30)</option>
+                        </select>
+                    </div>
                 </div>
             </div>
             
-            <button class="enhance-btn" id="enhanceBtn" disabled>Enhance 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>Enhancing your image with AI magic...</p>
-            <p><small>This may take a moment for larger images</small></p>
+            <p id="loadingText">Processing your image with AI...</p>
+            <p><small>This may take a moment</small></p>
         </div>
         
         <section class="results-section" id="results">
@@ -318,32 +409,32 @@
                     <h3>Original</h3>
                     <img id="originalImg" src="" alt="Original image">
                 </div>
-                <div class="image-box">
-                    <h3>Enhanced</h3>
-                    <img id="enhancedImg" src="" alt="Enhanced image">
-                    <a href="#" class="download-btn" id="downloadBtn" download="enhanced_image.png">Download Enhanced Image</a>
+                <div class="image-box" id="resultBox">
+                    <h3 id="resultLabel">Processed</h3>
+                    <img id="processedImg" src="" alt="Processed image">
+                    <a href="#" class="download-btn" id="downloadBtn" download="processed_image.png">Download Image</a>
                 </div>
             </div>
         </section>
         
         <section class="info-section">
-            <h2>About the Model</h2>
+            <h2>Available Features</h2>
             <div class="info-grid">
                 <div class="info-item">
-                    <h4>Real-ESRGAN x4plus</h4>
-                    <p>State-of-the-art image super-resolution model</p>
+                    <h4>Image Enhancement</h4>
+                    <p>Upscale images 2x-4x using Real-ESRGAN AI model</p>
                 </div>
                 <div class="info-item">
-                    <h4>Deep Learning</h4>
-                    <p>Uses RRDB architecture for high-quality results</p>
+                    <h4>Background Removal</h4>
+                    <p>Remove backgrounds using BiRefNet deep learning model</p>
                 </div>
                 <div class="info-item">
-                    <h4>Multi-purpose</h4>
-                    <p>Works on photos, artwork, and various image types</p>
+                    <h4>Noise Reduction</h4>
+                    <p>Reduce image noise with advanced denoising algorithms</p>
                 </div>
                 <div class="info-item">
                     <h4>API Access</h4>
-                    <p>RESTful API with Swagger documentation at /docs</p>
+                    <p>Full RESTful API with Swagger documentation at /docs</p>
                 </div>
             </div>
         </section>
@@ -352,16 +443,56 @@
     <script>
         const dropZone = document.getElementById('dropZone');
         const fileInput = document.getElementById('fileInput');
-        const enhanceBtn = document.getElementById('enhanceBtn');
+        const processBtn = document.getElementById('processBtn');
         const loading = document.getElementById('loading');
+        const loadingText = document.getElementById('loadingText');
         const results = document.getElementById('results');
         const error = document.getElementById('error');
         const originalImg = document.getElementById('originalImg');
-        const enhancedImg = document.getElementById('enhancedImg');
+        const processedImg = document.getElementById('processedImg');
         const downloadBtn = document.getElementById('downloadBtn');
-        const scaleSelect = document.getElementById('scale');
+        const resultBox = document.getElementById('resultBox');
+        const resultLabel = document.getElementById('resultLabel');
+        
+        const featureTabs = document.querySelectorAll('.feature-tab');
+        const bgcolorSelect = document.getElementById('bgcolor');
+        const customColorGroup = document.getElementById('customColorGroup');
         
         let selectedFile = null;
+        let currentFeature = 'enhance';
+        
+        featureTabs.forEach(tab => {
+            tab.addEventListener('click', () => {
+                featureTabs.forEach(t => t.classList.remove('active'));
+                tab.classList.add('active');
+                currentFeature = tab.dataset.feature;
+                
+                document.querySelectorAll('.feature-options').forEach(opt => opt.classList.remove('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');
+                }
+                
+                updateButtonText();
+            });
+        });
+        
+        bgcolorSelect.addEventListener('change', () => {
+            customColorGroup.style.display = bgcolorSelect.value === 'custom' ? 'block' : 'none';
+        });
+        
+        function updateButtonText() {
+            const texts = {
+                'enhance': 'Enhance Image',
+                'remove-bg': 'Remove Background',
+                'denoise': 'Denoise Image'
+            };
+            processBtn.textContent = texts[currentFeature] || 'Process Image';
+        }
         
         dropZone.addEventListener('click', () => fileInput.click());
         
@@ -396,7 +527,7 @@
             }
             
             selectedFile = file;
-            enhanceBtn.disabled = false;
+            processBtn.disabled = false;
             dropZone.innerHTML = `
                 <div class="drop-zone-icon">✅</div>
                 <p><strong>${file.name}</strong></p>
@@ -412,35 +543,68 @@
             hideError();
         }
         
-        enhanceBtn.addEventListener('click', async () => {
+        processBtn.addEventListener('click', async () => {
             if (!selectedFile) return;
             
-            const scale = scaleSelect.value;
             const formData = new FormData();
             formData.append('file', selectedFile);
             
+            let endpoint = '/enhance';
+            let params = new URLSearchParams();
+            
+            if (currentFeature === 'enhance') {
+                const scale = document.getElementById('scale').value;
+                params.append('scale', scale);
+                loadingText.textContent = 'Enhancing your image with AI...';
+                resultLabel.textContent = 'Enhanced';
+            } else if (currentFeature === 'remove-bg') {
+                endpoint = '/remove-background';
+                let bgcolor = bgcolorSelect.value;
+                if (bgcolor === 'custom') {
+                    bgcolor = document.getElementById('customColor').value;
+                }
+                params.append('bgcolor', bgcolor);
+                loadingText.textContent = 'Removing background with AI...';
+                resultLabel.textContent = 'Background Removed';
+                resultBox.classList.add('checkerboard');
+            } else if (currentFeature === 'denoise') {
+                endpoint = '/denoise';
+                const strength = document.getElementById('strength').value;
+                params.append('strength', strength);
+                loadingText.textContent = 'Reducing noise in your image...';
+                resultLabel.textContent = 'Denoised';
+            }
+            
+            if (currentFeature !== 'remove-bg') {
+                resultBox.classList.remove('checkerboard');
+            }
+            
             loading.classList.add('show');
             results.classList.remove('show');
-            enhanceBtn.disabled = true;
+            processBtn.disabled = true;
             hideError();
             
             try {
-                const response = await fetch(`/enhance?scale=${scale}`, {
+                const response = await fetch(`${endpoint}?${params.toString()}`, {
                     method: 'POST',
                     body: formData
                 });
                 
                 if (!response.ok) {
                     const errorData = await response.json();
-                    throw new Error(errorData.detail || 'Enhancement failed');
+                    throw new Error(errorData.detail || 'Processing failed');
                 }
                 
                 const blob = await response.blob();
                 const imageUrl = URL.createObjectURL(blob);
                 
-                enhancedImg.src = imageUrl;
+                processedImg.src = imageUrl;
                 downloadBtn.href = imageUrl;
                 
+                const filename = currentFeature === 'enhance' ? 'enhanced' : 
+                                 currentFeature === 'remove-bg' ? 'nobg' : 'denoised';
+                downloadBtn.download = `${filename}_${selectedFile.name.split('.')[0]}.png`;
+                
                 loading.classList.remove('show');
                 results.classList.add('show');
                 
@@ -449,7 +613,7 @@
                 loading.classList.remove('show');
             }
             
-            enhanceBtn.disabled = false;
+            processBtn.disabled = false;
         });
         
         function showError(message) {
@@ -460,6 +624,8 @@
         function hideError() {
             error.classList.remove('show');
         }
+        
+        updateButtonText();
     </script>
 </body>
 </html>