Delete app.py

app.py

@@ -1,325 +0,0 @@
-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, ImageFilter, 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):
-    """Shifts image +50% so outer edge seams land directly in the canvas center."""
-    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):
-    """Shifts image back -50% so inpainted continuous joins become outer borders."""
-    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_seam_mask(width, height, seam_pct=0.20, mode="Horizontal Only (Landscapes/City Facades)"):
-    """Creates a targeted center mask over the seam join."""
-    mask_arr = np.zeros((height, width), dtype=np.uint8)
-    if "Horizontal" in mode:
-        w_seam = int(width * seam_pct)
-        x_start = (width - w_seam) // 2
-        mask_arr[:, x_start:x_start + w_seam] = 255
-    else:
-        # Full 2D Crosshair (+) Mask
-        w_seam = int(width * seam_pct)
-        h_seam = int(height * seam_pct)
-        x_start = (width - w_seam) // 2
-        y_start = (height - h_seam) // 2
-        mask_arr[:, x_start:x_start + w_seam] = 255
-        mask_arr[y_start:y_start + h_seam, :] = 255
-    return Image.fromarray(mask_arr)
-
-def apply_2d_border_harmonization(pil_img, border_px=8):
-    """
-    Intelligent 2D border harmonization:
-    Smooths micro-gradient color/texture transitions along extreme top/bottom
-    and left/right boundaries to ensure 100% zero-seam 2D tiling.
-    """
-    img = np.array(pil_img.convert("RGB")).astype(np.float32)
-    h, w, c = img.shape
-    
-    # Smooth Top and Bottom edges together
-    alpha_y = np.linspace(0, 1, border_px)[:, np.newaxis, np.newaxis]
-    top_strip = img[:border_px, :, :]
-    bot_strip = img[-border_px:, :, :]
-    avg_h = (top_strip + bot_strip) / 2.0
-    
-    img[:border_px, :, :] = top_strip * alpha_y + avg_h * (1.0 - alpha_y)
-    img[-border_px:, :, :] = bot_strip * (1.0 - alpha_y) + avg_h * alpha_y
-
-    # Smooth Left and Right edges together
-    alpha_x = np.linspace(0, 1, border_px)[np.newaxis, :, np.newaxis]
-    left_strip = img[:, :border_px, :]
-    right_strip = img[:, -border_px:, :]
-    avg_w = (left_strip + right_strip) / 2.0
-    
-    img[:, :border_px, :] = left_strip * alpha_x + avg_w * (1.0 - alpha_x)
-    img[:, -border_px:, :] = right_strip * (1.0 - alpha_x) + avg_w * alpha_x
-
-    return Image.fromarray(np.clip(img, 0, 255).astype(np.uint8))
-
-def create_tiled_preview(pil_img, mode="Horizontal Only (Landscapes/City Facades)"):
-    """Generates a 1x3 horizontal panorama or 3x3 grid preview."""
-    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:
-        # Full 3x3 Grid Preview for 2D mode
-        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
-
-@spaces.GPU
-def generate_photorealistic_seamless(
-    input_image, prompt, negative_prompt, tiling_mode,
-    seam_width_pct, steps, guidance_scale, seed_val,
-    sharpness_boost, resolution_str, ut99_quantize
-):
-    if input_image is None:
-        return None, None, None, None, "⚠️ Please upload a source photo first."
-
-    # Seed Selection logic
-    if seed_val == -1 or seed_val is None:
-        actual_seed = random.randint(0, 2147483647)
-    else:
-        actual_seed = 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"
-
-    # =========================================================================
-    # UNTOUCHED HORIZONTAL CODE (Landscapes / City Facades)
-    # =========================================================================
-    if "Horizontal" in tiling_mode:
-        shifted_photo = shift_image_50(proc_photo, tiling_mode)
-        seam_mask_sharp = create_seam_mask(512, 512, seam_pct=seam_width_pct / 100.0, mode=tiling_mode)
-        seam_mask_feathered = seam_mask_sharp.filter(ImageFilter.GaussianBlur(radius=10))
-
-        inpainted_zone = pipeline(
-            prompt=photo_prompt,
-            negative_prompt=strict_negative,
-            image=shifted_photo,
-            mask_image=seam_mask_sharp,
-            num_inference_steps=user_steps,
-            guidance_scale=user_guidance,
-            generator=generator
-        ).images[0]
-
-        seamless_result = Image.composite(inpainted_zone, shifted_photo, seam_mask_feathered)
-
-    # =========================================================================
-    # ENHANCED INTELLIGENT FULL 2D ENGINE (Cube / Pattern Tiling)
-    # =========================================================================
-    else:
-        # 1. Shift canvas 50% along both X and Y axes
-        shifted_photo_2d = shift_image_50(proc_photo, tiling_mode)
-        
-        # 2. Build 2D crosshair mask with wide Gaussian alpha feathering
-        seam_mask_2d_sharp = create_seam_mask(512, 512, seam_pct=seam_width_pct / 100.0, mode=tiling_mode)
-        seam_mask_2d_feathered = seam_mask_2d_sharp.filter(ImageFilter.GaussianBlur(radius=14))
-
-        # 3. AI Inpaints central 2D cross join
-        inpainted_2d_zone = pipeline(
-            prompt=photo_prompt,
-            negative_prompt=strict_negative,
-            image=shifted_photo_2d,
-            mask_image=seam_mask_2d_sharp,
-            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_feathered)
-
-        # 4. UN-SHIFT -50% X and -50% Y so the inpainted cross becomes the seamless outer borders
-        unrolled_2d = unshift_image_50(blended_2d, tiling_mode)
-
-        # 5. Apply 2D Border Harmonization for zero-seam 3x3 grid tiling
-        seamless_result = apply_2d_border_harmonization(unrolled_2d, border_px=8)
-
-    # High-resolution output scaling
-    scaled_result = seamless_result.resize((res_val, res_val), Image.Resampling.LANCZOS)
-
-    if sharpness_boost > 1.0:
-        enhancer = ImageEnhance.Sharpness(scaled_result)
-        scaled_result = enhancer.enhance(sharpness_boost)
-
-    tiled_preview = create_tiled_preview(scaled_result, mode=tiling_mode)
-
-    # Export formats (.PCX / .BMP)
-    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
-
-    status_msg = f"✅ Photorealistic Seamless Complete | Mode: {tiling_mode} | Seed: {actual_seed} | Res: {res_val}x{res_val}"
-    return display_img, tiled_preview, pcx_path, bmp_path, status_msg
-
-# Gradio Interface
-with gr.Blocks(title="UT99 ZeroGPU Photorealistic Texture Forge") as demo:
-    gr.Markdown("# ⚡ UT99 ZeroGPU Photorealistic Texture Forge")
-    gr.Markdown("Intelligent 2D and 1D seamless texture generation with seed selection and 8-bit UT99 exports.")
-
-    with gr.Row():
-        with gr.Column():
-            input_img = gr.Image(type="pil", label="Upload Source Photo (Fabric / Stone / City Block)")
-
-            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=35, value=20, step=5,
-                    label="Seam Inpaint Width (% of canvas masked)"
-                )
-                sharpness_boost = gr.Slider(
-                    minimum=1.0, maximum=2.5, value=1.3, step=0.1,
-                    label="Photo Sharpness Restorer"
-                )
-
-            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)")
-
-            seed_val = gr.Number(
-                value=-1, precision=0,
-                label="Seed Selection (-1 = Random Integer)"
-            )
-
-            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 = gr.Button("🚀 Generate Photorealistic Seamless Texture", variant="primary")
-
-        with gr.Column():
-            output_status = gr.Textbox(label="Status / Applied Parameters", interactive=False)
-            output_texture = gr.Image(type="pil", label="Photorealistic Seamless Output")
-            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")
-
-    btn.click(
-        fn=generate_photorealistic_seamless,
-        inputs=[
-            input_img, prompt, negative_prompt, tiling_mode,
-            seam_width_pct, steps, guidance_scale, seed_val,
-            sharpness_boost, resolution, ut99_quantize
-        ],
-        outputs=[output_texture, output_preview, pcx_file, bmp_file, output_status]
-    )
-
-if __name__ == "__main__":
-    demo.launch(show_api=False)
-