Create app.py

app.py

@@ -0,0 +1,130 @@
+import tempfile
+import os
+import numpy as np
+from PIL import Image
+import gradio as gr
+
+def make_seamless(pil_img, blend_factor=0.30):
+    """
+    Seamless tiling algorithm:
+    Shifts edges to the center and cross-fades original continuous regions over seams.
+    """
+    img = np.array(pil_img.convert("RGB")).astype(np.float32) / 255.0
+    h, w, c = img.shape
+
+    # 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
+    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 = 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."""
+    w, h = pil_img.size
+    cols, rows = grid_size
+    tiled = Image.new("RGB", (w * cols, h * rows))
+    for r in range(rows):
+        for c in range(cols):
+            tiled.paste(pil_img, (c * w, r * h))
+    return tiled
+
+
+def process_texture(input_image, resolution_str, enable_seamless, blend_width, 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
+    temp_dir = tempfile.mkdtemp()
+    pcx_path = os.path.join(temp_dir, "ut99_texture.pcx")
+    bmp_path = os.path.join(temp_dir, "ut99_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")
+    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
+
+
+# Gradio Interface Setup
+with gr.Blocks(title="UT99 Shameless Texture Forge") as demo:
+    gr.Markdown("# 🎮 UT99 Shameless Photo-to-Texture Converter")
+    gr.Markdown(
+        "Convert photos, street facades, and city blocks into seamless, "
+        "UT99-ready 8-bit indexed textures (.PCX / .BMP)."
+    )
+
+    with gr.Row():
+        with gr.Column():
+            input_img = gr.Image(type="pil", label="Upload Source Photo")
+            
+            resolution = gr.Dropdown(
+                choices=["128x128", "256x256", "512x512"],
+                value="256x256",
+                label="Target Resolution (Power of 2 for UT99 Engine)"
+            )
+            
+            enable_seamless = gr.Checkbox(value=True, label="Enable Shameless Seamless Tiling")
+            
+            blend_width = gr.Slider(
+                minimum=10, maximum=50, value=30, step=1,
+                label="Seam Crossfade Width (%)"
+            )
+            
+            ut99_quantize = gr.Checkbox(
+                value=True,
+                label="Convert to 8-Bit / 256 Colors (Required for UT99 .PCX)"
+            )
+            
+            btn = gr.Button("Generate UT99 Texture", variant="primary")
+
+        with gr.Column():
+            output_texture = gr.Image(type="pil", label="Single Texture Output")
+            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)")
+
+    btn.click(
+        fn=process_texture,
+        inputs=[input_img, resolution, enable_seamless, blend_width, ut99_quantize],
+        outputs=[output_texture, output_preview, pcx_file, bmp_file]
+    )
+
+if __name__ == "__main__":
+    demo.launch()
+