Update app.py

app.py

@@ -1,13 +1,17 @@
 import tempfile
 import os
+import io
 import numpy as np
 from PIL import Image
 import gradio as gr
+from huggingface_hub import InferenceClient
 
-def make_seamless(pil_img, blend_factor=0.30):
+# Initialize Hugging Face Inference Client
+client = InferenceClient()
+
+def create_base_seamless_layout(pil_img, blend_factor=0.30):
     """
-    Seamless tiling algorithm:
-    Shifts edges to the center and cross-fades original continuous regions over seams.
+    Creates a shifted structural baseline so the AI can repaint over the seams.
     """
     img = np.array(pil_img.convert("RGB")).astype(np.float32) / 255.0
     h, w, c = img.shape
@@ -15,27 +19,21 @@ def make_seamless(pil_img, blend_factor=0.30):
     # Roll image 50% along both axes
     shifted = np.roll(np.roll(img, h // 2, axis=0), w // 2, axis=1)
 
-    # Calculate distance from central cross seam
+    # Smooth crossfade mask
     y = np.linspace(-1, 1, h)
     x = np.linspace(-1, 1, w)
     xx, yy = np.meshgrid(x, y)
 
-    dist_x = np.abs(xx)
-    dist_y = np.abs(yy)
-
-    # Smooth crossfade mask
-    mask_x = np.clip(dist_x / blend_factor, 0, 1)
-    mask_y = np.clip(dist_y / blend_factor, 0, 1)
+    mask_x = np.clip(np.abs(xx) / blend_factor, 0, 1)
+    mask_y = np.clip(np.abs(yy) / blend_factor, 0, 1)
     mask = np.minimum(mask_x, mask_y)[:, :, np.newaxis]
 
-    # Blend original over the shifted seams
     blended = shifted * mask + img * (1.0 - mask)
     result = (np.clip(blended, 0, 1) * 255).astype(np.uint8)
     return Image.fromarray(result)
 
-
 def create_tiled_preview(pil_img, grid_size=(3, 3)):
-    """Creates a 3x3 tiled composite to check seamless borders."""
+    """Generates a 3x3 tiled composite."""
     w, h = pil_img.size
     cols, rows = grid_size
     tiled = Image.new("RGB", (w * cols, h * rows))
@@ -44,84 +42,113 @@ def create_tiled_preview(pil_img, grid_size=(3, 3)):
             tiled.paste(pil_img, (c * w, r * h))
     return tiled
 
-
-def process_texture(input_image, resolution_str, enable_seamless, blend_width, ut99_quantize):
+def generate_ai_texture(input_image, prompt, negative_prompt, strength, resolution_str, ut99_quantize):
     if input_image is None:
         return None, None, None, None
 
-    # Parse power-of-2 resolution target for UT99
     res_val = int(resolution_str.split("x")[0])
-    img = input_image.resize((res_val, res_val), Image.Resampling.LANCZOS)
-
-    # Apply seamless algorithm
-    if enable_seamless:
-        img = make_seamless(img, blend_factor=blend_width / 100.0)
 
-    # Generate 3x3 Tiling Preview before palette reduction
-    tiled_preview = create_tiled_preview(img)
-
-    # Prepare export formats
+    # 1. Structural pre-processing for seamless geometry
+    base_seamless = create_base_seamless_layout(input_image)
+    resized_input = base_seamless.resize((1024, 1024), Image.Resampling.LANCZOS)
+
+    # 2. Convert PIL Image to Bytes for AI API call
+    img_byte_arr = io.BytesIO()
+    resized_input.save(img_byte_arr, format='JPEG')
+    img_bytes = img_byte_arr.getvalue()
+
+    # 3. Call AI Inference API (Image-to-Image Diffusion)
+    # The strength controls how heavily the AI repaints structural details
+    try:
+        ai_image = client.image_to_image(
+            image=img_bytes,
+            prompt=prompt + ", seamless texture, game asset, detailed, high resolution",
+            negative_prompt=negative_prompt + ", seams, borders, frames, text, watermark",
+            strength=strength,
+            model="stabilityai/stable-diffusion-xl-refiner-1.0"
+        )
+    except Exception:
+        # Fallback model if SDXL refiner queue is full
+        ai_image = client.image_to_image(
+            image=img_bytes,
+            prompt=prompt,
+            strength=strength,
+            model="runwayml/stable-diffusion-v1-5"
+        )
+
+    # 4. Resize AI output to UT99 Target Resolution
+    final_img = ai_image.resize((res_val, res_val), Image.Resampling.LANCZOS)
+
+    # 5. Create 3x3 Seamless Tiling Preview
+    tiled_preview = create_tiled_preview(final_img)
+
+    # 6. Save UT99 Formats (.PCX and .BMP with 8-bit quantization)
     temp_dir = tempfile.mkdtemp()
-    pcx_path = os.path.join(temp_dir, "ut99_texture.pcx")
-    bmp_path = os.path.join(temp_dir, "ut99_texture.bmp")
+    pcx_path = os.path.join(temp_dir, "ut99_ai_texture.pcx")
+    bmp_path = os.path.join(temp_dir, "ut99_ai_texture.bmp")
 
     if ut99_quantize:
-        # UT99 requires 8-bit indexed 256 color palette
-        img_quant = img.convert("P", palette=Image.Palette.ADAPTIVE, colors=256)
-        img_quant.save(pcx_path, format="PCX")
-        img_quant.save(bmp_path, format="BMP")
-        final_preview = img_quant.convert("RGB")
+        quantized = final_img.convert("P", palette=Image.Palette.ADAPTIVE, colors=256)
+        quantized.save(pcx_path, format="PCX")
+        quantized.save(bmp_path, format="BMP")
+        display_img = quantized.convert("RGB")
     else:
-        img.save(pcx_path, format="PCX")
-        img.save(bmp_path, format="BMP")
-        final_preview = img
-
-    return final_preview, tiled_preview, pcx_path, bmp_path
+        final_img.save(pcx_path, format="PCX")
+        final_img.save(bmp_path, format="BMP")
+        display_img = final_img
 
+    return display_img, tiled_preview, pcx_path, bmp_path
 
-# Gradio Interface Setup
-with gr.Blocks(title="UT99 Shameless Texture Forge") as demo:
-    gr.Markdown("# 🎮 UT99 Shameless Photo-to-Texture Converter")
+# Gradio Interface
+with gr.Blocks(title="UT99 AI Texture Generator") as demo:
+    gr.Markdown("# 🤖 UT99 AI Texture Synthesizer")
     gr.Markdown(
-        "Convert photos, street facades, and city blocks into seamless, "
-        "UT99-ready 8-bit indexed textures (.PCX / .BMP)."
+        "Generates seamless textures from photos, city blocks, and landscapes using AI Image-to-Image diffusion."
     )
 
     with gr.Row():
         with gr.Column():
-            input_img = gr.Image(type="pil", label="Upload Source Photo")
+            input_img = gr.Image(type="pil", label="Upload Source Photo (City Block / Landscape)")
             
-            resolution = gr.Dropdown(
-                choices=["128x128", "256x256", "512x512"],
-                value="256x256",
-                label="Target Resolution (Power of 2 for UT99 Engine)"
+            prompt = gr.Textbox(
+                value="Weathered rocky canyon terrain, detailed stone texture, Unreal Engine style",
+                label="AI Prompt (Describe the style and details to generate)"
             )
             
-            enable_seamless = gr.Checkbox(value=True, label="Enable Shameless Seamless Tiling")
+            negative_prompt = gr.Textbox(
+                value="blurry, ugly, distorted, frames, borders",
+                label="Negative Prompt"
+            )
+
+            strength = gr.Slider(
+                minimum=0.1, maximum=0.9, value=0.45, step=0.05,
+                label="AI Generation Strength (Higher = More new details, Lower = Keeps original photo closer)"
+            )
             
-            blend_width = gr.Slider(
-                minimum=10, maximum=50, value=30, step=1,
-                label="Seam Crossfade Width (%)"
+            resolution = gr.Dropdown(
+                choices=["128x128", "256x256", "512x512"],
+                value="256x256",
+                label="Target Resolution (UT99 Engine Power of 2)"
             )
             
             ut99_quantize = gr.Checkbox(
                 value=True,
-                label="Convert to 8-Bit / 256 Colors (Required for UT99 .PCX)"
+                label="Convert to 8-Bit / 256 Colors (.PCX / .BMP)"
             )
             
-            btn = gr.Button("Generate UT99 Texture", variant="primary")
+            btn = gr.Button("Generate AI Texture", variant="primary")
 
         with gr.Column():
-            output_texture = gr.Image(type="pil", label="Single Texture Output")
+            output_texture = gr.Image(type="pil", label="AI Generated Texture")
             output_preview = gr.Image(type="pil", label="3x3 Seamless Tiling Test")
             
             with gr.Row():
-                pcx_file = gr.File(label="Download .PCX (UnrealEd Standard)")
-                bmp_file = gr.File(label="Download .BMP (8-bit)")
+                pcx_file = gr.File(label="Download .PCX")
+                bmp_file = gr.File(label="Download .BMP")
 
     btn.click(
-        fn=process_texture,
-        inputs=[input_img, resolution, enable_seamless, blend_width, ut99_quantize],
+        fn=generate_ai_texture,
+        inputs=[input_img, prompt, negative_prompt, strength, resolution, ut99_quantize],
         outputs=[output_texture, output_preview, pcx_file, bmp_file]
     )