Update app.py

app.py

@@ -1,348 +1,106 @@
-import gradio as gr
-import requests
 import os
-from PIL import Image, ImageFilter, ImageDraw, ImageFont
 import io
-
-# =========================================================
-# Configuration
-# =========================================================
-HF_TOKEN = os.getenv("HF_TOKEN")
-GEN_MODEL_ID = "runwayml/stable-diffusion-v1-5"
-GEN_API_URL = f"https://api-inference.huggingface.co/models/{GEN_MODEL_ID}?wait_for_model=true"
-GEN_STATUS_URL = f"https://api-inference.huggingface.co/status/{GEN_MODEL_ID}"
-
-# Architectural styles
-ARCH_STYLES = [
-    "Gothic Cathedral", "Japanese Zen", "Modern Minimalist",
-    "Medieval Castle", "Art Deco", "Chinese Palace",
-    "Brutalist", "Victorian", "Mediterranean", "Futuristic"
+import gradio as gr
+from PIL import Image, ImageDraw, ImageFont
+from huggingface_hub import InferenceClient
+
+# =============== Config ===============
+HF_TOKEN = os.getenv("HF_TOKEN")  # set this in your environment
+MODEL_ID = "timbrooks/instruct-pix2pix"
+
+STYLES = [
+    "Modern Minimalist",
+    "Victorian",
+    "Brutalist",
+    "Mediterranean",
+    "Gothic Cathedral",
+    "Japanese Zen",
+    "Art Deco",
+    "Futuristic",
+    "Scandinavian",
+    "Meditation Retreat"
 ]
 
-# =========================================================
-# Image utilities
-# =========================================================
-def create_building_analysis(input_image: Image.Image) -> Image.Image:
-    """Create a simple 'edge map' structure analysis visualization."""
-    if input_image is None:
-        return create_info_image("Upload a building photo to start")
-
-    try:
-        img = input_image.resize((512, 512))
-        grayscale = img.convert('L')
-
-        # Edge detection and threshold
-        edges = grayscale.filter(ImageFilter.FIND_EDGES)
-        edges = edges.point(lambda x: 255 if x > 25 else 0)
-
-        # Blue edges on black background
-        analysis_img = Image.new('RGB', (512, 512), 'black')
-        edge_pixels = edges.load()
-        analysis_pixels = analysis_img.load()
-
-        for i in range(512):
-            for j in range(512):
-                if edge_pixels[i, j] > 50:
-                    analysis_pixels[i, j] = (0, 150, 255)  # Blue
-
-        return analysis_img
-
-    except Exception as e:
-        return create_info_image(f"Analysis error: {str(e)}")
-
-
-def create_demo_building(style_name: str) -> Image.Image:
-    """Create a decorative demo image when API is unavailable or generation fails."""
-    colors = {
-        "Gothic Cathedral": ('#2C3E50', '#E74C3C', '#ECF0F1'),
-        "Japanese Zen": ('#8B4513', '#2E8B57', '#F5F5DC'),
-        "Modern Minimalist": ('#FFFFFF', '#3498DB', '#2C3E50'),
-        "Medieval Castle": ('#7F8C8D', '#C0392B', '#34495E'),
-        "Art Deco": ('#D4AF37', '#000000', '#FFFFFF'),
-        "Chinese Palace": ('#C0392B', '#F1C40F', '#2C3E50'),
-        "Brutalist": ('#95A5A6', '#7F8C8D', '#34495E'),
-        "Victorian": ('#E6B0AA', '#F1948A', '#2C3E50'),
-        "Mediterranean": ('#E67E22', '#3498DB', '#F1C40F'),
-        "Futuristic": ('#1ABC9C', '#9B59B6', '#34495E'),
-        "Upload a photo to see magic!": ('#3498DB', '#2C3E50', '#ECF0F1')
-    }
-
-    bg_color, building_color, accent_color = colors.get(
-        style_name, ('#3498DB', '#2C3E50', '#ECF0F1')
-    )
-
-    img = Image.new('RGB', (512, 512), bg_color)
-    draw = ImageDraw.Draw(img)
-
-    # Gradient background
-    for y in range(512):
-        if bg_color == '#FFFFFF':  # Modern Minimalist special case
-            shade = int(200 + (y / 512) * 55)
-            draw.line([(0, y), (512, y)], fill=(shade, shade, shade))
+# =============== Helpers ===============
+def info_image(msg: str, w: int = 768, h: int = 512) -> Image.Image:
+    """Simple image with centered text (used for errors)."""
+    img = Image.new("RGB", (w, h), "#2C3E50")
+    d = ImageDraw.Draw(img)
+    font = ImageFont.load_default()
+    lines = []
+    words = msg.split()
+    line = ""
+    for word in words:
+        test = (line + " " + word).strip()
+        if d.textlength(test, font=font) < (w - 40):
+            line = test
         else:
-            r, g, b = int(bg_color[1:3], 16), int(bg_color[3:5], 16), int(bg_color[5:7], 16)
-            new_r = max(0, min(255, r + (y // 20)))
-            new_g = max(0, min(255, g + (y // 20)))
-            new_b = max(0, min(255, b + (y // 20)))
-            draw.line([(0, y), (512, y)], fill=(new_r, new_g, new_b))
-
-    # Building body
-    draw.rectangle([150, 200, 362, 450], fill=building_color, outline=accent_color, width=3)
-
-    # Windows
-    window_colors = ['#F1C40F', '#E74C3C', '#1ABC9C', '#9B59B6']
-    for i, color in enumerate(window_colors):
-        x_pos = 170 + (i % 3) * 70
-        y_pos = 230 + (i // 3) * 70
-        draw.rectangle([x_pos, y_pos, x_pos + 40, y_pos + 50], fill=color)
-
-    # Roof
-    if "Gothic" in style_name:
-        draw.polygon([(150, 200), (256, 150), (362, 200)], fill=accent_color)
-    elif "Japanese" in style_name:
-        draw.polygon([(150, 200), (256, 170), (362, 200)], fill=accent_color)
-    else:
-        draw.rectangle([150, 190, 362, 200], fill=accent_color)
-
-    # Titles
-    try:
-        font = ImageFont.load_default()
-        text = f"{style_name}"
-        bbox = draw.textbbox((0, 0), text, font=font)
-        text_width = bbox[2] - bbox[0]
-        x = (512 - text_width) // 2
-        draw.text((x, 50), text, fill='white', stroke_width=2, stroke_fill='black', font=font)
-
-        if "Upload" not in style_name:
-            draw.text((180, 470), "Architectural AI Demo", fill='white', font=font)
-    except Exception:
-        draw.text((200, 50), style_name, fill='white')
-
+            lines.append(line)
+            line = word
+    if line:
+        lines.append(line)
+    total_h = len(lines) * 18
+    y = (h - total_h) // 2
+    for L in lines:
+        tw = d.textlength(L, font=font)
+        d.text(((w - tw) // 2, y), L, fill="white", font=font)
+        y += 18
     return img
 
 
-def create_info_image(message: str) -> Image.Image:
-    """Create a plain info panel image with wrapped text."""
-    img = Image.new('RGB', (512, 512), color='#2C3E50')
-    draw = ImageDraw.Draw(img)
-    try:
-        font = ImageFont.load_default()
-        words = message.split(' ')
-        current_line = ""
-        y_text = 200
-
-        for word in words:
-            test_line = current_line + word + " "
-            bbox = draw.textbbox((0, 0), test_line, font=font)
-            text_width = bbox[2] - bbox[0]
-
-            if text_width < 500:
-                current_line = test_line
-            else:
-                draw.text((10, y_text), current_line, fill='white', font=font)
-                y_text += 30
-                current_line = word + " "
-
-        if current_line:
-            draw.text((10, y_text), current_line, fill='white', font=font)
-    except Exception:
-        draw.text((50, 250), message, fill='white')
-
-    return img
-
-# =========================================================
-# HF API helpers
-# =========================================================
-def test_huggingface_api() -> str:
-    """Return a single string suitable for a Textbox with model status."""
-    if not HF_TOKEN:
-        return "❌ No HF_TOKEN found in environment variables."
-
-    headers = {"Authorization": f"Bearer {HF_TOKEN}"}
-    try:
-        r = requests.get(GEN_STATUS_URL, headers=headers, timeout=10)
-        if r.status_code == 200:
-            j = r.json()
-            loaded = j.get("loaded")
-            state = j.get("state")
-            qlen = (j.get("queue") or {}).get("length")
-            return f"✅ API reachable. loaded={loaded}, state={state}, queue_length={qlen}"
-        elif r.status_code == 404:
-            return "❌ Model not found or gated (check access to runwayml/stable-diffusion-v1-5)."
-        else:
-            return f"❌ API error {r.status_code}: {r.text[:180]}"
-    except Exception as e:
-        return f"❌ API test error: {e}"
+def build_prompt(style: str) -> str:
+    return (
+        f"Transform this house into a {style} architectural style. "
+        f"Keep the same perspective and composition. Photorealistic, high detail, realistic lighting."
+    )
 
+# =============== Core ===============
+def transform_house(input_image: Image.Image, style: str):
+    """Upload a house image + style -> transformed image from HF model."""
+    if input_image is None:
+        return info_image("Please upload a house photo first.")
 
-def generate_with_api(style_name: str):
-    """Try to generate image via HF Inference API. Returns PIL.Image or None."""
     if not HF_TOKEN:
-        return None
-
-    prompt = f"architectural rendering of a {style_name.lower()} building, professional photography"
-    headers = {
-        "Authorization": f"Bearer {HF_TOKEN}",
-        "Accept": "image/png"
-    }
-    payload = {
-        "inputs": prompt,
-        "parameters": {
-            "guidance_scale": 7.5,
-            "num_inference_steps": 20
-            # Width/height may not be supported across all deployments:
-            # "width": 512,
-            # "height": 512
-        }
-    }
+        return info_image("HF_TOKEN is missing. Set it in your environment before running.")
 
     try:
-        response = requests.post(GEN_API_URL, headers=headers, json=payload, timeout=60)
-        ctype = response.headers.get("content-type", "")
-        if response.status_code == 200 and ctype.startswith("image/"):
-            return Image.open(io.BytesIO(response.content))
-        elif response.status_code == 503:
-            # Model loading or warming up
-            return None
-        else:
-            # Likely JSON error; log a snippet
-            print(f"❌ API error {response.status_code}: {response.text[:200]}")
-            return None
-    except Exception as e:
-        print(f"❌ Request error: {e}")
-        return None
-
-# =========================================================
-# Main pipeline
-# =========================================================
-def generate_architectural_remix(original_image, style_choice):
-    """Pipeline: test API → analyze structure → generate or show demo."""
-    if original_image is None:
-        analysis_img = create_info_image("Please upload a building photo")
-        status = "Waiting for building photo..."
-        result_img = create_demo_building("Upload a photo to see magic!")
-        return analysis_img, status, result_img
-
-    # Always keep a safe default analysis ready
-    safe_analysis = create_info_image("Analysis unavailable")
-
-    try:
-        # 1) API status (returns a string now)
-        api_status = test_huggingface_api()
-        api_working = api_status.startswith("✅")
-
-        # 2) Structure analysis (guard any failure)
-        try:
-            building_analysis = create_building_analysis(original_image)
-        except Exception:
-            building_analysis = safe_analysis
-
-        # 3) Style name
-        style_name = ARCH_STYLES[style_choice] if style_choice is not None else ARCH_STYLES[0]
-
-        # 4) Generation (or demo fallback)
-        if api_working:
-            generated_image = generate_with_api(style_name)
-            if generated_image:
-                status = f"✅ AI Generated: {style_name} | {api_status}"
-                return building_analysis, status, generated_image
-            else:
-                demo_img = create_demo_building(style_name)
-                status = f"⚠ Generation failed or model loading, showing demo | {api_status}"
-                return building_analysis, status, demo_img
+        client = InferenceClient(model=MODEL_ID, token=HF_TOKEN)
+        prompt = build_prompt(style)
+
+        # InferenceClient.image_to_image returns bytes in most versions; handle either bytes or PIL.Image
+        result = client.image_to_image(
+            prompt=prompt,
+            image=input_image,
+            negative_prompt="blurry, low quality, distorted, text, watermark, extra buildings",
+            guidance_scale=7.0,
+            image_guidance_scale=1.5,
+            num_inference_steps=30,
+        )
+
+        if isinstance(result, bytes):
+            return Image.open(io.BytesIO(result)).convert("RGB")
+        elif isinstance(result, Image.Image):
+            return result.convert("RGB")
         else:
-            demo_img = create_demo_building(style_name)
-            status = f"🎨 Demo Mode: {style_name} | {api_status}"
-            return building_analysis, status, demo_img
-
+            return info_image("Unexpected response from the model.")
     except Exception as e:
-        error_img = create_info_image(f"Error: {str(e)}")
-        status = f"❌ Pipeline error: {str(e)}"
-        return safe_analysis, status, error_img
+        # Graceful error panel instead of crashing the app
+        return info_image(f"Generation failed: {e}")
 
-# =========================================================
-# Gradio UI
-# =========================================================
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("""
-    # 🏛 Architectural Style Remix
-    AI-Powered Building Transformation
-
-    Upload a building → AI analyzes structure → Generates new style
-    """)
+# =============== UI ===============
+with gr.Blocks() as demo:
+    gr.Markdown("# 🏠 House → Style Remix (Hugging Face)")
 
     with gr.Row():
         with gr.Column():
-            input_image = gr.Image(
-                label="🏢 Upload Building Photo",
-                type="pil",
-                height=300
-            )
-
-            style_dropdown = gr.Dropdown(
-                choices=ARCH_STYLES,
-                label="🎨 Select Architectural Style",
-                value=ARCH_STYLES[2],
-                type="index"
-            )
-
-            generate_btn = gr.Button("✨ Generate Style Remix", variant="primary")
-
-            # API test
-            test_api_btn = gr.Button("🔍 Test API Connection", variant="secondary")
-            api_status = gr.Textbox(label="API Status", interactive=False)
-
+            inp = gr.Image(type="pil", label="Upload a house photo")
+            style = gr.Dropdown(STYLES, value=STYLES[0], label="Choose a style")
+            btn = gr.Button("Generate", variant="primary")
         with gr.Column():
-            structure_output = gr.Image(
-                label="📐 Building Structure Analysis",
-                height=300
-            )
-
-            status_text = gr.Textbox(
-                label="Generation Status",
-                value="Ready - Upload a building photo to start!",
-                interactive=False
-            )
-
-            result_image = gr.Image(
-                label="🎭 Generated Building",
-                height=300
-            )
-
-    gr.Markdown("### 🏗 Try These Building Examples:")
-    gr.Examples(
-        examples=[
-            ["https://images.unsplash.com/photo-1564013799919-ab600027ffc6?w=400", 2],
-            ["https://images.unsplash.com/photo-1580587771525-78b9dba3b914?w=400", 1],
-            ["https://images.unsplash.com/photo-1513584684374-8bab748fbf90?w=400", 3]
-        ],
-        inputs=[input_image, style_dropdown],
-        outputs=[structure_output, status_text, result_image],
-        fn=generate_architectural_remix,
-        cache_examples=False
-    )
-
-    # Button actions
-    generate_btn.click(
-        fn=generate_architectural_remix,
-        inputs=[input_image, style_dropdown],
-        outputs=[structure_output, status_text, result_image]
-    )
-
-    test_api_btn.click(
-        fn=test_huggingface_api,
-        outputs=api_status
-    )
-
-    gr.Markdown("""
-    ### 🎯 Project Features:
-    - Structure Analysis: AI detects architectural features
-    - Style Transformation: AI generates buildings in selected styles
-    - Demo Mode: Beautiful fallback images when API is unavailable
-    - API Testing: Check Hugging Face connection status
+            out = gr.Image(label="Transformed House", height=480)
 
-    Note: Free Hugging Face API has rate limits. Demo mode ensures the project always works!
-    """)
+    btn.click(fn=transform_house, inputs=[inp, style], outputs=out)
 
 if __name__ == "__main__":
-    demo.launch(debug=True)
+    # Run:  HF_TOKEN=your_token python app.py
+    demo.launch(debug=False)