Create app.py

app.py

@@ -0,0 +1,369 @@
+import spaces  # MUST be line 1 for ZeroGPU
+
+# ---------------------------------------------------------------------------
+# GRADIO SCHEMA BUG PATCH (Prevents TypeError on boolean schema definitions)
+# ---------------------------------------------------------------------------
+import gradio_client.utils as gc_utils
+
+_orig_get_type = gc_utils.get_type
+def _safe_get_type(schema):
+    if not isinstance(schema, dict):
+        return "Any"
+    return _orig_get_type(schema)
+gc_utils.get_type = _safe_get_type
+
+_orig_json_schema_to_python_type = gc_utils._json_schema_to_python_type
+def _safe_json_schema_to_python_type(schema, defs=None):
+    if not isinstance(schema, dict):
+        return "Any"
+    return _orig_json_schema_to_python_type(schema, defs)
+gc_utils._json_schema_to_python_type = _safe_json_schema_to_python_type
+# ---------------------------------------------------------------------------
+
+import tempfile
+import os
+import random
+import torch
+import numpy as np
+from PIL import Image, ImageEnhance
+import gradio as gr
+from diffusers import StableDiffusionInpaintPipeline
+
+pipe_inpaint = None
+
+def get_inpaint_pipeline():
+    global pipe_inpaint
+    if pipe_inpaint is None:
+        pipe_inpaint = StableDiffusionInpaintPipeline.from_pretrained(
+            "runwayml/stable-diffusion-inpainting",
+            torch_dtype=torch.float16,
+            safety_checker=None
+        )
+        pipe_inpaint.enable_attention_slicing()
+    return pipe_inpaint
+
+def shift_image_50(pil_img, mode):
+    arr = np.array(pil_img.convert("RGB"))
+    h, w, _ = arr.shape
+    if "Horizontal" in mode:
+        shifted = np.roll(arr, w // 2, axis=1)
+    else:
+        shifted = np.roll(np.roll(arr, h // 2, axis=0), w // 2, axis=1)
+    return Image.fromarray(shifted)
+
+def unshift_image_50(pil_img, mode):
+    arr = np.array(pil_img.convert("RGB"))
+    h, w, _ = arr.shape
+    if "Horizontal" in mode:
+        unshifted = np.roll(arr, -(w // 2), axis=1)
+    else:
+        unshifted = np.roll(np.roll(arr, -(h // 2), axis=0), -(w // 2), axis=1)
+    return Image.fromarray(unshifted)
+
+def create_smooth_cosine_mask(width, height, seam_pct_x=0.25, seam_pct_y=0.35, mode="Full 2D (Both Axes)"):
+    x = np.linspace(-0.5, 0.5, width)
+    y = np.linspace(-0.5, 0.5, height)
+    xx, yy = np.meshgrid(x, y)
+
+    rx = seam_pct_x / 2.0
+    ry = seam_pct_y / 2.0
+
+    sx = np.zeros_like(xx)
+    mask_x = np.abs(xx) <= rx
+    sx[mask_x] = 0.5 * (1.0 + np.cos(np.pi * np.abs(xx[mask_x]) / rx))
+
+    if "Horizontal" in mode:
+        mask_final = sx
+    else:
+        sy = np.zeros_like(yy)
+        mask_y = np.abs(yy) <= ry
+        sy[mask_y] = 0.5 * (1.0 + np.cos(np.pi * np.abs(yy[mask_y]) / ry))
+        mask_final = 1.0 - (1.0 - sx) * (1.0 - sy)
+
+    mask_uint8 = (np.clip(mask_final, 0, 1) * 255).astype(np.uint8)
+    return Image.fromarray(mask_uint8, mode="L")
+
+def extract_brush_mask(editor_data):
+    """Extracts background image and painted red brush layer from Gradio ImageEditor."""
+    if editor_data is None:
+        return None, None
+
+    if isinstance(editor_data, dict):
+        bg = editor_data.get("background") or editor_data.get("composite")
+        if bg is None:
+            return None, None
+        bg = bg.convert("RGB")
+
+        layers = editor_data.get("layers", [])
+        if layers and len(layers) > 0:
+            combined_alpha = np.zeros((bg.height, bg.width), dtype=np.uint8)
+            for layer in layers:
+                if layer is not None:
+                    layer_rgba = layer.convert("RGBA")
+                    if layer_rgba.size != (bg.width, bg.height):
+                        layer_rgba = layer_rgba.resize((bg.width, bg.height), Image.Resampling.NEAREST)
+                    alpha = np.array(layer_rgba.split()[-1])
+                    combined_alpha = np.maximum(combined_alpha, alpha)
+
+            if np.max(combined_alpha) > 0:
+                mask_arr = np.where(combined_alpha > 10, 255, 0).astype(np.uint8)
+                return bg, Image.fromarray(mask_arr, mode="L")
+
+    return editor_data.convert("RGB"), None
+
+def create_tiled_preview(pil_img, mode="Horizontal Only (Landscapes/City Facades)"):
+    preview_img = pil_img.copy()
+    if preview_img.width > 1024:
+        preview_img = preview_img.resize((1024, 1024), Image.Resampling.LANCZOS)
+
+    w, h = preview_img.size
+
+    if "Horizontal" in mode:
+        tiled = Image.new("RGB", (w * 3, h))
+        for c in range(3):
+            tiled.paste(preview_img, (c * w, 0))
+    else:
+        tiled = Image.new("RGB", (w * 3, h * 3))
+        for r in range(3):
+            for c in range(3):
+                tiled.paste(preview_img, (c * w, r * h))
+
+    return tiled
+
+def export_files(scaled_result, resolution_str, ut99_quantize):
+    res_val = int(resolution_str.split("x")[0])
+    temp_dir = tempfile.mkdtemp()
+    pcx_path = os.path.join(temp_dir, f"ut99_texture_{res_val}.pcx")
+    bmp_path = os.path.join(temp_dir, f"ut99_texture_{res_val}.bmp")
+
+    if ut99_quantize:
+        quantized = scaled_result.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:
+        scaled_result.save(pcx_path, format="PCX")
+        scaled_result.save(bmp_path, format="BMP")
+        display_img = scaled_result
+
+    return display_img, pcx_path, bmp_path
+
+@spaces.GPU
+def auto_generate_seamless(
+    input_image, prompt, negative_prompt, tiling_mode,
+    seam_width_pct, seam_height_pct, steps, guidance_scale, seed_val,
+    sharpness_boost, resolution_str, ut99_quantize
+):
+    if input_image is None:
+        return None, None, None, None, None, "⚠️ Please upload a source photo first."
+
+    actual_seed = random.randint(0, 2147483647) if (seed_val == -1 or seed_val is None) else int(seed_val)
+    res_val = int(resolution_str.split("x")[0])
+
+    pipeline = get_inpaint_pipeline()
+    pipeline.to("cuda")
+    generator = torch.Generator("cuda").manual_seed(actual_seed)
+
+    original_photo = input_image.convert("RGB")
+    proc_photo = original_photo.resize((512, 512), Image.Resampling.LANCZOS)
+    
+    user_steps = max(10, int(steps))
+    user_guidance = float(guidance_scale)
+
+    photo_prompt = prompt + ", raw photo, ultra realistic, sharp photographic detail, DSLR 8k, crisp texture, natural lighting"
+    strict_negative = negative_prompt + ", oil painting, painting, illustration, drawing, 3d render, anime, smooth, blurry, artistic, cartoon, canvas texture, digital art, vector"
+
+    # HORIZONTAL MODE (UNTOUCHED)
+    if "Horizontal" in tiling_mode:
+        shifted_photo = shift_image_50(proc_photo, tiling_mode)
+        seam_mask_cosine = create_smooth_cosine_mask(512, 512, seam_pct_x=seam_width_pct / 100.0, mode=tiling_mode)
+
+        inpainted_zone = pipeline(
+            prompt=photo_prompt,
+            negative_prompt=strict_negative,
+            image=shifted_photo,
+            mask_image=seam_mask_cosine,
+            num_inference_steps=user_steps,
+            guidance_scale=user_guidance,
+            generator=generator
+        ).images[0]
+
+        seamless_result = Image.composite(inpainted_zone, shifted_photo, seam_mask_cosine)
+
+    # 2D MODE
+    else:
+        shifted_photo_2d = shift_image_50(proc_photo, tiling_mode)
+        seam_mask_2d_cosine = create_smooth_cosine_mask(
+            512, 512,
+            seam_pct_x=seam_width_pct / 100.0,
+            seam_pct_y=seam_height_pct / 100.0,
+            mode=tiling_mode
+        )
+
+        inpainted_2d_zone = pipeline(
+            prompt=photo_prompt,
+            negative_prompt=strict_negative,
+            image=shifted_photo_2d,
+            mask_image=seam_mask_2d_cosine,
+            num_inference_steps=user_steps,
+            guidance_scale=user_guidance,
+            generator=generator
+        ).images[0]
+
+        blended_2d = Image.composite(inpainted_2d_zone, shifted_photo_2d, seam_mask_2d_cosine)
+        seamless_result = unshift_image_50(blended_2d, tiling_mode)
+
+    scaled_result = seamless_result.resize((res_val, res_val), Image.Resampling.LANCZOS)
+
+    if sharpness_boost > 1.0:
+        scaled_result = ImageEnhance.Sharpness(scaled_result).enhance(sharpness_boost)
+
+    tiled_preview = create_tiled_preview(scaled_result, mode=tiling_mode)
+    display_img, pcx_path, bmp_path = export_files(scaled_result, resolution_str, ut99_quantize)
+
+    # Populate editor canvas with generated result for optional manual touch-up
+    editor_update = {"background": scaled_result, "layers": [], "composite": scaled_result}
+    status_msg = f"✅ Auto Generation Complete | Loaded into Touch-Up Canvas | Seed: {actual_seed}"
+
+    return editor_update, display_img, tiled_preview, pcx_path, bmp_path, status_msg
+
+@spaces.GPU
+def manual_edge_repair(
+    editor_data, prompt, negative_prompt, tiling_mode,
+    steps, guidance_scale, seed_val, sharpness_boost, resolution_str, ut99_quantize
+):
+    bg_img, mask_img = extract_brush_mask(editor_data)
+
+    if bg_img is None or mask_img is None:
+        return None, None, None, None, None, "⚠️ Please draw red brush strokes over visible edges first."
+
+    actual_seed = random.randint(0, 2147483647) if (seed_val == -1 or seed_val is None) else int(seed_val)
+    res_val = int(resolution_str.split("x")[0])
+
+    pipeline = get_inpaint_pipeline()
+    pipeline.to("cuda")
+    generator = torch.Generator("cuda").manual_seed(actual_seed)
+
+    init_512 = bg_img.resize((512, 512), Image.Resampling.LANCZOS)
+    mask_512 = mask_img.resize((512, 512), Image.Resampling.NEAREST)
+
+    user_steps = max(10, int(steps))
+    user_guidance = float(guidance_scale)
+
+    photo_prompt = prompt + ", raw photo, ultra realistic, sharp photographic detail, DSLR 8k, seamless texture blending"
+    strict_negative = negative_prompt + ", oil painting, painting, illustration, drawing, 3d render, anime, smooth, blurry, artistic, cartoon"
+
+    # Inpaint specifically over user painted red mask
+    repaired_512 = pipeline(
+        prompt=photo_prompt,
+        negative_prompt=strict_negative,
+        image=init_512,
+        mask_image=mask_512,
+        num_inference_steps=user_steps,
+        guidance_scale=user_guidance,
+        generator=generator
+    ).images[0]
+
+    scaled_result = repaired_512.resize((res_val, res_val), Image.Resampling.LANCZOS)
+
+    if sharpness_boost > 1.0:
+        scaled_result = ImageEnhance.Sharpness(scaled_result).enhance(sharpness_boost)
+
+    tiled_preview = create_tiled_preview(scaled_result, mode=tiling_mode)
+    display_img, pcx_path, bmp_path = export_files(scaled_result, resolution_str, ut99_quantize)
+
+    editor_update = {"background": scaled_result, "layers": [], "composite": scaled_result}
+    status_msg = f"🩹 Manual Edge Repair Complete | Seed: {actual_seed} | Res: {res_val}x{res_val}"
+
+    return editor_update, display_img, tiled_preview, pcx_path, bmp_path, status_msg
+
+# Gradio Interface
+with gr.Blocks(title="UT99 ZeroGPU Hybrid Texture Forge") as demo:
+    gr.Markdown("# ⚡ UT99 ZeroGPU Hybrid Texture Forge")
+    gr.Markdown("Auto-generate seamless textures, then paint red lines over any remaining sharp edges to selectively repair them.")
+
+    with gr.Row():
+        with gr.Column():
+            input_img = gr.Image(type="pil", label="1. Upload Source Photo")
+
+            tiling_mode = gr.Radio(
+                choices=["Horizontal Only (Landscapes/City Facades)", "Full 2D (Both Axes)"],
+                value="Full 2D (Both Axes)",
+                label="Seamless Mode"
+            )
+
+            prompt = gr.Textbox(
+                value="Detailed fabric curtain texture, sharp photographic pattern",
+                label="AI Inpainting Prompt"
+            )
+
+            negative_prompt = gr.Textbox(
+                value="seam line, border, frame, edge line, blur, watermark, repeating grid",
+                label="Negative Prompt"
+            )
+
+            with gr.Row():
+                seam_width_pct = gr.Slider(minimum=10, maximum=50, value=30, step=5, label="Auto Horizontal Seam Width (%)")
+                seam_height_pct = gr.Slider(minimum=10, maximum=60, value=35, step=5, label="Auto Vertical Seam Height (%)")
+
+            with gr.Row():
+                steps = gr.Slider(minimum=10, maximum=50, value=25, step=1, label="Denoising Steps")
+                guidance_scale = gr.Slider(minimum=1.0, maximum=15.0, value=7.5, step=0.5, label="Guidance Scale (CFG)")
+
+            with gr.Row():
+                sharpness_boost = gr.Slider(minimum=1.0, maximum=2.5, value=1.3, step=0.1, label="Sharpness Restorer")
+                seed_val = gr.Number(value=-1, precision=0, label="Seed (-1 = Random)")
+
+            resolution = gr.Dropdown(
+                choices=["128x128", "256x256 (Default UT99)", "512x512 (HD UT99)", "1024x1024", "2048x2048 (2K)", "4096x4096 (4K)", "8192x8192 (8K)"],
+                value="1024x1024",
+                label="Output Resolution"
+            )
+
+            ut99_quantize = gr.Checkbox(value=False, label="Convert to 8-Bit / 256 Colors (.PCX / .BMP)")
+
+            btn_auto = gr.Button("🚀 1. Auto-Generate Seamless Texture", variant="primary")
+
+        with gr.Column():
+            output_status = gr.Textbox(label="Status / Applied Parameters", interactive=False)
+
+            editor = gr.ImageEditor(
+                type="pil",
+                label="2. Manual Seam Touch-Up Canvas (Draw red brush line over any visible seam cut)",
+                transforms=[],
+                brush=gr.Brush(colors=["#FF0000"], default_size=18)
+            )
+
+            btn_repair = gr.Button("🩹 2. Inpaint Red Painted Edges", variant="secondary")
+
+            output_texture = gr.Image(type="pil", label="Final Output Texture")
+            output_preview = gr.Image(type="pil", label="Tiling Preview Test (3x3 Grid / Panorama)")
+
+            with gr.Row():
+                pcx_file = gr.File(label="Download .PCX")
+                bmp_file = gr.File(label="Download .BMP")
+
+    # Auto generation
+    btn_auto.click(
+        fn=auto_generate_seamless,
+        inputs=[
+            input_img, prompt, negative_prompt, tiling_mode,
+            seam_width_pct, seam_height_pct, steps, guidance_scale, seed_val,
+            sharpness_boost, resolution, ut99_quantize
+        ],
+        outputs=[editor, output_texture, output_preview, pcx_file, bmp_file, output_status]
+    )
+
+    # Manual edge repair
+    btn_repair.click(
+        fn=manual_edge_repair,
+        inputs=[
+            editor, prompt, negative_prompt, tiling_mode,
+            steps, guidance_scale, seed_val, sharpness_boost, resolution, ut99_quantize
+        ],
+        outputs=[editor, output_texture, output_preview, pcx_file, bmp_file, output_status]
+    )
+
+if __name__ == "__main__":
+    demo.launch(show_api=False)
+