Upload app.py with huggingface_hub

app.py

@@ -0,0 +1,347 @@
+import gradio as gr
+import requests
+import io
+import base64
+import time
+from PIL import Image
+import numpy as np
+
+# Advanced structure-preserving models with different capabilities
+STRUCTURE_PRESERVING_MODELS = [
+    {
+        "name": "FLUX.1-dev ControlNet Union Pro",
+        "model_id": "Shakker-Labs/FLUX.1-dev-ControlNet-Union-Pro-2.0",
+        "description": "Advanced ControlNet with multiple control types for precise structure preservation",
+        "supports_controlnet": True
+    },
+    {
+        "name": "ControlNet Room Segmentation",
+        "model_id": "BertChristiaens/controlnet-seg-room",
+        "description": "Specialized for interior design with room segmentation",
+        "supports_controlnet": True
+    },
+    {
+        "name": "FLUX.1 ControlNet Union",
+        "model_id": "InstantX/FLUX.1-dev-Controlnet-Union",
+        "description": "High-quality ControlNet for structure preservation",
+        "supports_controlnet": True
+    },
+    {
+        "name": "Stable Diffusion Depth Img2Img",
+        "model_id": "radames/stable-diffusion-2-depth-img2img",
+        "description": "Uses depth information for structure preservation",
+        "supports_controlnet": False
+    },
+    {
+        "name": "Stable Diffusion v1.5 Img2Img",
+        "model_id": "radames/stable-diffusion-v1-5-img2img",
+        "description": "Reliable image-to-image transformation",
+        "supports_controlnet": False
+    },
+    {
+        "name": "FLUX.1-dev (Fallback)",
+        "model_id": "black-forest-labs/FLUX.1-dev",
+        "description": "General purpose model (fallback)",
+        "supports_controlnet": False
+    }
+]
+
+# Enhanced style presets with structure preservation focus
+ENHANCED_STYLE_PRESETS = {
+    "Modern Minimalist": {
+        "positive": "modern minimalist interior design, clean lines, neutral colors, natural light, contemporary furniture, open space, architectural details preserved, structural elements maintained, room layout unchanged, high quality, professional photography",
+        "negative": "cluttered, busy patterns, dark lighting, traditional style, ornate details, structural changes, layout modifications"
+    },
+    "Luxury Contemporary": {
+        "positive": "luxury contemporary interior, high-end materials, marble surfaces, designer furniture, elegant lighting, sophisticated color palette, architectural structure preserved, room proportions maintained, premium finishes, professional staging",
+        "negative": "cheap materials, poor lighting, basic furniture, structural alterations, room layout changes"
+    },
+    "Scandinavian Style": {
+        "positive": "scandinavian interior design, light wood textures, cozy atmosphere, hygge concept, natural materials, white and light tones, functional furniture, architectural bones preserved, room structure intact, nordic style",
+        "negative": "dark colors, heavy furniture, ornate decorations, structural modifications, layout changes"
+    },
+    "Industrial Chic": {
+        "positive": "industrial interior design, exposed brick, metal fixtures, concrete surfaces, loft style, urban aesthetic, raw materials, architectural features highlighted, structural elements enhanced, warehouse feel",
+        "negative": "soft decorations, pastel colors, traditional style, structural hiding, layout alterations"
+    },
+    "Cozy Traditional": {
+        "positive": "cozy traditional interior, warm colors, comfortable furniture, classic patterns, timeless design, welcoming atmosphere, architectural character preserved, room proportions maintained, heritage style",
+        "negative": "modern minimalism, cold materials, stark lighting, structural changes, contemporary style"
+    }
+}
+
+def encode_image_to_base64(image):
+    """Convert PIL Image to base64 string for API transmission"""
+    if image is None:
+        return None
+    
+    # Convert to RGB if necessary
+    if image.mode != 'RGB':
+        image = image.convert('RGB')
+    
+    # Resize if too large (max 1024x1024 for most models)
+    max_size = 1024
+    if max(image.size) > max_size:
+        ratio = max_size / max(image.size)
+        new_size = tuple(int(dim * ratio) for dim in image.size)
+        image = image.resize(new_size, Image.LANCZOS)
+    
+    # Convert to base64
+    buffer = io.BytesIO()
+    image.save(buffer, format='JPEG', quality=95)
+    image_bytes = buffer.getvalue()
+    base64_string = base64.b64encode(image_bytes).decode('utf-8')
+    
+    return f"data:image/jpeg;base64,{base64_string}"
+
+def call_huggingface_api(model_id, inputs, api_token):
+    """Enhanced API call with better error handling and retry logic"""
+    api_url = f"https://api-inference.huggingface.co/models/{model_id}"
+    
+    headers = {
+        "Authorization": f"Bearer {api_token}",
+        "Content-Type": "application/json"
+    }
+    
+    max_retries = 3
+    for attempt in range(max_retries):
+        try:
+            response = requests.post(api_url, headers=headers, json=inputs, timeout=60)
+            
+            if response.status_code == 200:
+                return response.content, None
+            elif response.status_code == 503:
+                error_data = response.json() if response.headers.get('content-type', '').startswith('application/json') else {}
+                estimated_time = error_data.get('estimated_time', 10)
+                return None, f"Model is loading. Estimated time: {estimated_time}s"
+            elif response.status_code == 404:
+                return None, f"Model {model_id} not found or not accessible"
+            else:
+                return None, f"API Error {response.status_code}: {response.text[:200]}"
+                
+        except requests.exceptions.Timeout:
+            if attempt < max_retries - 1:
+                time.sleep(2 ** attempt)  # Exponential backoff
+                continue
+            return None, "Request timeout. Please try again."
+        except Exception as e:
+            return None, f"Network error: {str(e)}"
+    
+    return None, "Failed after multiple retries"
+
+def transform_room_with_structure_preservation(input_image, style_preset, custom_prompt="", strength=0.7, guidance_scale=7.5, api_token=""):
+    """
+    Transform room design while preserving structural elements
+    """
+    if input_image is None:
+        return None, "Please upload an image first."
+    
+    if not api_token or api_token == "your_token_here":
+        return None, "Please provide a valid HuggingFace API token."
+    
+    # Get style configuration
+    style_config = ENHANCED_STYLE_PRESETS.get(style_preset, ENHANCED_STYLE_PRESETS["Modern Minimalist"])
+    
+    # Build enhanced prompt with structure preservation keywords
+    if custom_prompt.strip():
+        positive_prompt = f"{custom_prompt}, {style_config['positive']}"
+    else:
+        positive_prompt = style_config['positive']
+    
+    # Add extra structure preservation keywords
+    positive_prompt += ", maintain room structure, preserve architectural layout, keep spatial relationships, same room dimensions, identical floor plan"
+    
+    negative_prompt = style_config['negative'] + ", structural changes, room layout modifications, different room, changed proportions, architectural alterations"
+    
+    # Encode image
+    base64_image = encode_image_to_base64(input_image)
+    if not base64_image:
+        return None, "Failed to process input image."
+    
+    # Try models in order of preference
+    for model_info in STRUCTURE_PRESERVING_MODELS:
+        model_id = model_info["model_id"]
+        model_name = model_info["name"]
+        
+        print(f"Trying model: {model_name} ({model_id})")
+        
+        # Prepare inputs based on model capabilities
+        if model_info["supports_controlnet"]:
+            # ControlNet models
+            inputs = {
+                "prompt": positive_prompt,
+                "negative_prompt": negative_prompt,
+                "image": base64_image,
+                "strength": strength,
+                "guidance_scale": guidance_scale,
+                "num_inference_steps": 20,
+                "controlnet_conditioning_scale": 1.0
+            }
+        else:
+            # Standard img2img models
+            inputs = {
+                "prompt": positive_prompt,
+                "negative_prompt": negative_prompt,
+                "image": base64_image,
+                "strength": strength,
+                "guidance_scale": guidance_scale,
+                "num_inference_steps": 25
+            }
+        
+        # Call API
+        image_bytes, error = call_huggingface_api(model_id, inputs, api_token)
+        
+        if image_bytes:
+            try:
+                # Convert response to PIL Image
+                result_image = Image.open(io.BytesIO(image_bytes))
+                success_message = f"✅ Successfully generated with {model_name}!\n\nPrompt used: {positive_prompt[:200]}..." if len(positive_prompt) > 200 else positive_prompt
+                return result_image, success_message
+            except Exception as e:
+                print(f"Failed to process image from {model_name}: {str(e)}")
+                continue
+        else:
+            print(f"Model {model_name} failed: {error}")
+            continue
+    
+    # If all models fail
+    return None, "❌ All structure-preserving models are currently unavailable. This could be due to:\n\n• Models are still loading (try again in a few minutes)\n• High demand on the servers\n• Temporary API issues\n\nPlease try again later or check the model availability on HuggingFace Hub."
+
+# Create the Gradio interface
+def create_interface():
+    """Create the enhanced Gradio interface for structure-preserving room transformation"""
+    
+    with gr.Blocks(title="🏠 AI Interior Design - Structure Preserving", theme=gr.themes.Soft()) as interface:
+        gr.Markdown("""
+        # 🏠 AI Interior Design - Structure Preserving
+        
+        Transform your room's style while **preserving the original structure, layout, and architectural elements**.
+        
+        This app uses advanced **image-to-image** and **ControlNet** models that can:
+        - ✅ Maintain room dimensions and proportions
+        - ✅ Preserve architectural features (windows, doors, walls)  
+        - ✅ Keep furniture placement and spatial relationships
+        - ✅ Transform only the **style, colors, and materials**
+        
+        ## 📋 How to use:
+        1. **Upload** your room photo
+        2. **Choose** a style preset or add custom prompt
+        3. **Adjust** transformation strength (lower = more preservation)
+        4. **Generate** your transformed design!
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                # Input section
+                gr.Markdown("### 📤 Input")
+                input_image = gr.Image(
+                    label="Upload Room Photo",
+                    type="pil",
+                    height=300
+                )
+                
+                style_preset = gr.Dropdown(
+                    choices=list(ENHANCED_STYLE_PRESETS.keys()),
+                    value="Modern Minimalist",
+                    label="🎨 Style Preset",
+                    info="Choose a predefined style"
+                )
+                
+                custom_prompt = gr.Textbox(
+                    label="✏️ Custom Style Description (Optional)",
+                    placeholder="Add specific details like 'add plants', 'wooden floors', 'blue walls'...",
+                    lines=2
+                )
+                
+                # API Token input
+                api_token = gr.Textbox(
+                    label="🔑 HuggingFace API Token",
+                    placeholder="Enter your HF API token (hf_...)",
+                    type="password",
+                    info="Required for accessing the models. Get yours at https://huggingface.co/settings/tokens"
+                )
+                
+                # Advanced settings
+                with gr.Accordion("⚙️ Advanced Settings", open=False):
+                    strength = gr.Slider(
+                        minimum=0.3,
+                        maximum=0.9,
+                        value=0.7,
+                        step=0.1,
+                        label="Transformation Strength",
+                        info="Lower = more preservation, Higher = more change"
+                    )
+                    
+                    guidance_scale = gr.Slider(
+                        minimum=5.0,
+                        maximum=15.0,
+                        value=7.5,
+                        step=0.5,
+                        label="Guidance Scale",
+                        info="How closely to follow the prompt"
+                    )
+                
+                transform_btn = gr.Button(
+                    "🚀 Transform Room",
+                    variant="primary",
+                    size="lg"
+                )
+            
+            with gr.Column(scale=1):
+                # Output section
+                gr.Markdown("### 📤 Result")
+                output_image = gr.Image(
+                    label="Transformed Room",
+                    height=300
+                )
+                
+                output_message = gr.Textbox(
+                    label="Status",
+                    lines=8,
+                    max_lines=15
+                )
+        
+        # Model information
+        with gr.Accordion("🤖 Available Models", open=False):
+            model_info_md = "This app tries the following structure-preserving models in order:\n\n"
+            for i, model in enumerate(STRUCTURE_PRESERVING_MODELS, 1):
+                model_info_md += f"**{i}. {model['name']}**\n"
+                model_info_md += f"   - Model: `{model['model_id']}`\n"
+                model_info_md += f"   - Description: {model['description']}\n"
+                model_info_md += f"   - ControlNet Support: {'✅' if model['supports_controlnet'] else '❌'}\n\n"
+            
+            gr.Markdown(model_info_md)
+        
+        # Examples
+        gr.Markdown("### 🖼️ Example Transformations")
+        gr.Markdown("Upload your room photos to see similar transformations with preserved structure!")
+        
+        # Event handlers
+        transform_btn.click(
+            fn=transform_room_with_structure_preservation,
+            inputs=[input_image, style_preset, custom_prompt, strength, guidance_scale, api_token],
+            outputs=[output_image, output_message],
+            show_progress=True
+        )
+        
+        # Footer
+        gr.Markdown("""
+        ---
+        
+        ### 💡 Tips for Best Results:
+        - Use well-lit, clear photos of rooms
+        - Avoid blurry or dark images  
+        - Lower strength values preserve more of the original structure
+        - Try different style presets to find your favorite
+        
+        ### 🔧 Technical Details:
+        This app uses advanced **image-to-image** models and **ControlNet** technology to maintain structural integrity while transforming style.
+        The models are specifically chosen for their ability to preserve room layout and architectural elements.
+        """)
+    
+    return interface
+
+# Create and launch the interface
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch()