Iniital commit

app.py

@@ -0,0 +1,277 @@
+import gradio as gr
+from PIL import Image
+from vit_mosaic import make_vit_mosaic
+import tempfile
+import os
+import svgwrite
+import base64
+import requests
+from io import BytesIO
+
+
+# -------------------------------------------------
+# Example Images
+# -------------------------------------------------
+
+EXAMPLES = {
+    "Dogs": {
+        "url": "https://raw.githubusercontent.com/daidedou/daidedou.github.io/master/images/dogs.jpg",
+        "credit": "Photo by Jackielsy — Pixabay (CC0)"
+    },
+    "Landscape": {
+        "url": "https://raw.githubusercontent.com/daidedou/daidedou.github.io/master/images/landscape.jpg",
+        "credit": "Photo by brenkee — Pixabay (CC0)"
+    },
+    "Illustration": {
+        "url": "https://raw.githubusercontent.com/daidedou/daidedou.github.io/master/images/illustration.jpg",
+        "credit": "Illustration by the_iop — Pixabay (CC0)"
+    }
+}
+
+# -------------------------------------------------
+# Utilities
+# -------------------------------------------------
+
+def rgb_to_hex(r, g, b):
+    return f"#{r:02X}{g:02X}{b:02X}"
+
+
+def update_color_preview(r, g, b):
+    hex_color = rgb_to_hex(r, g, b)
+    return f"""
+    <div style="
+        width:100%;
+        height:40px;
+        border-radius:8px;
+        border:1px solid #ccc;
+        background:{hex_color};
+    "></div>
+    """
+
+
+def toggle_clipping(enabled):
+    return gr.update(interactive=enabled)
+
+
+def load_image_from_url(url):
+    response = requests.get(url, timeout=10)
+    response.raise_for_status()
+    return Image.open(BytesIO(response.content)).convert("RGB")
+
+
+def on_gallery_select(evt: gr.SelectData):
+    name = list(EXAMPLES.keys())[evt.index]
+    data = EXAMPLES[name]
+    image = load_image_from_url(data["url"])
+    credit = f"**Image Credit:** {data['credit']}"
+    return image, credit
+
+
+def export_svg(image, path):
+    width, height = image.size
+    dwg = svgwrite.Drawing(path, size=(width, height))
+
+    buffer = BytesIO()
+    image.save(buffer, format="PNG")
+    encoded = base64.b64encode(buffer.getvalue()).decode()
+
+    dwg.add(
+        dwg.image(
+            href=f"data:image/png;base64,{encoded}",
+            insert=(0, 0),
+            size=(width, height),
+        )
+    )
+
+    dwg.save()
+
+
+# -------------------------------------------------
+# Generation
+# -------------------------------------------------
+
+def generate(
+    image,
+    patches,
+    max_size,
+    spacing,
+    border_thickness,
+    border_r,
+    border_g,
+    border_b,
+    use_padding,
+    pad_r,
+    pad_g,
+    pad_b,
+    supersample,
+    scale_mode,
+    dpi_value,
+    background_mode,
+    rounded,
+    clipping,
+):
+
+    if image is None:
+        return None, None, None
+
+    border_color = rgb_to_hex(border_r, border_g, border_b)
+    padding_color = None
+
+    if use_padding:
+        padding_color = rgb_to_hex(pad_r, pad_g, pad_b)
+
+    mosaic, _ = make_vit_mosaic(
+        image,
+        target_total_patches=(patches,),
+        max_long_side=max_size,
+        spacing=spacing,
+        border_thickness=border_thickness,
+        border_color=border_color,
+        padding_color=padding_color,
+        supersample=supersample,
+        output_scale_mode=scale_mode,
+        rounded=rounded,
+        true_clipping=clipping,
+    )
+
+    if background_mode == "White":
+        white_bg = Image.new("RGBA", mosaic.size, (255, 255, 255, 255))
+        white_bg.paste(mosaic, (0, 0), mosaic)
+        mosaic = white_bg
+
+    tmp_dir = tempfile.mkdtemp()
+    png_path = os.path.join(tmp_dir, "vit_mosaic.png")
+    svg_path = os.path.join(tmp_dir, "vit_mosaic.svg")
+
+    mosaic.save(png_path, dpi=(dpi_value, dpi_value))
+    export_svg(mosaic, svg_path)
+
+    return mosaic, png_path, svg_path
+
+
+# -------------------------------------------------
+# UI
+# -------------------------------------------------
+
+with gr.Blocks() as demo:
+
+    gr.Markdown("# 🧩 ViT Patch Mosaic Generator")
+
+    with gr.Row():
+
+        # LEFT COLUMN
+        with gr.Column(scale=1):
+
+            gr.Markdown("### ✨ Example Images")
+
+            gallery = gr.Gallery(
+                value=[v["url"] for v in EXAMPLES.values()],
+                columns=3,
+                height=250,
+                allow_preview=False,
+                object_fit="contain",
+            )
+
+            gr.Markdown("### ⚙ Parameters")
+
+            patches = gr.Radio([12, 16], value=16, label="Number of patches")
+
+            max_size = gr.Slider(
+                128, 1024,
+                value=512,
+                step=64,
+                label="Max long side"
+            )
+
+            spacing = gr.Slider(0, 40, value=12, label="Spacing")
+
+            border_thickness = gr.Slider(
+                0, 50,
+                value=14,
+                label="Border thickness"
+            )
+
+            gr.Markdown("### 🎨 Border Color")
+
+            border_r = gr.Slider(0, 255, value=0, label="R")
+            border_g = gr.Slider(0, 255, value=255, label="G")
+            border_b = gr.Slider(0, 255, value=255, label="B")
+
+            color_preview = gr.HTML(update_color_preview(0, 255, 255))
+
+            with gr.Accordion("🧱 Padding Settings", open=False):
+
+                use_padding = gr.Checkbox(value=False, label="Enable padding color")
+                pad_r = gr.Slider(0, 255, value=255, label="Pad R")
+                pad_g = gr.Slider(0, 255, value=255, label="Pad G")
+                pad_b = gr.Slider(0, 255, value=255, label="Pad B")
+
+            with gr.Accordion("⚙ Advanced Settings", open=False):
+
+                rounded = gr.Checkbox(value=True, label="Enable rounded corners")
+                clipping = gr.Checkbox(value=True, label="True rounded clipping")
+
+                supersample = gr.Slider(1, 4, value=2, step=1)
+                scale_mode = gr.Radio(["keep", "downscale"], value="keep")
+                dpi_value = gr.Slider(72, 600, value=300, step=1)
+                background_mode = gr.Radio(["Transparent", "White"], value="Transparent")
+
+            generate_btn = gr.Button("Generate Mosaic")
+
+        # RIGHT COLUMN
+        with gr.Column(scale=1):
+
+            gr.Markdown("### 📥 Selected Image")
+
+            input_image = gr.Image(type="pil", height=250)
+            credit_display = gr.Markdown("")
+
+            gr.Markdown("### 🖼 Mosaic Preview")
+
+            output_image = gr.Image(type="pil", height=350)
+
+            download_png = gr.File(label="Download PNG")
+            download_svg = gr.File(label="Download SVG")
+
+    # -------------------------------------------------
+    # INTERACTIONS (IMPORTANT: OUTSIDE LAYOUT BLOCKS)
+    # -------------------------------------------------
+
+    gallery.select(
+        fn=on_gallery_select,
+        outputs=[input_image, credit_display],
+    )
+
+    border_r.change(update_color_preview, [border_r, border_g, border_b], color_preview)
+    border_g.change(update_color_preview, [border_r, border_g, border_b], color_preview)
+    border_b.change(update_color_preview, [border_r, border_g, border_b], color_preview)
+
+    rounded.change(toggle_clipping, rounded, clipping)
+
+    generate_btn.click(
+        fn=generate,
+        inputs=[
+            input_image,
+            patches,
+            max_size,
+            spacing,
+            border_thickness,
+            border_r,
+            border_g,
+            border_b,
+            use_padding,
+            pad_r,
+            pad_g,
+            pad_b,
+            supersample,
+            scale_mode,
+            dpi_value,
+            background_mode,
+            rounded,
+            clipping,
+        ],
+        outputs=[output_image, download_png, download_svg],
+    )
+
+
+demo.launch()

requirements.txt

@@ -0,0 +1,5 @@
+gradio~=4.44.0
+numpy~=1.26.0
+pillow~=10.4.0
+svgwrite==1.4.3
+requests==2.31.0

vit_mosaic.py

@@ -0,0 +1,164 @@
+"""
+vit_mosaic.py
+
+ViT-style patch mosaic generator
+Supports:
+- Auto grid selection (12 / 16 patches)
+- Transparent or colored padding
+- Rounded borders
+- True rounded clipping
+- Supersampling
+- Downscale or keep resolution
+"""
+
+import math
+import numpy as np
+from PIL import Image, ImageDraw
+from typing import Iterable, Tuple, Union
+
+
+ColorType = Union[Tuple[int, int, int], str]
+
+
+def parse_color(color: ColorType):
+    if isinstance(color, tuple):
+        return (*color, 255)
+    if isinstance(color, str):
+        color = color.strip()
+        if color.startswith("#"):
+            r = int(color[1:3], 16)
+            g = int(color[3:5], 16)
+            b = int(color[5:7], 16)
+            return (r, g, b, 255)
+    raise ValueError("Color must be RGB tuple or hex string '#RRGGBB'")
+
+
+def make_vit_mosaic(
+    image: Image.Image,
+    target_total_patches: Iterable[int] = (12, 16),
+    max_long_side: int = 256,
+    spacing: int = 12,
+    border_thickness: int = 14,
+    border_color: ColorType = "#00FFFF",
+    padding_color: Union[None, ColorType] = None,
+    corner_radius: int = 22,
+    rounded: bool = True,
+    true_clipping: bool = True,
+    supersample: int = 1,
+    output_scale_mode: str = "keep",  # "keep" or "downscale"
+):
+    border_rgba = parse_color(border_color)
+    image = image.convert("RGBA")
+    w, h = image.size
+
+    scale = max_long_side / max(w, h)
+    new_w = int(w * scale)
+    new_h = int(h * scale)
+    image = image.resize((new_w, new_h), Image.LANCZOS)
+
+    aspect = new_w / new_h
+    best_choice = None
+    best_diff = float("inf")
+
+    for total in target_total_patches:
+        for rows in range(1, total + 1):
+            if total % rows == 0:
+                cols = total // rows
+                diff = abs((cols / rows) - aspect)
+                if diff < best_diff:
+                    best_diff = diff
+                    best_choice = (rows, cols)
+
+    rows, cols = best_choice
+
+    patch_w = math.ceil(new_w / cols)
+    patch_h = math.ceil(new_h / rows)
+    patch_size = max(patch_w, patch_h)
+
+    pad_w = patch_size * cols
+    pad_h = patch_size * rows
+
+    if padding_color is None:
+        canvas = Image.new("RGBA", (pad_w, pad_h), (0, 0, 0, 0))
+    else:
+        canvas = Image.new("RGBA", (pad_w, pad_h), parse_color(padding_color))
+
+    offset_x = (pad_w - new_w) // 2
+    offset_y = (pad_h - new_h) // 2
+    canvas.paste(image, (offset_x, offset_y), image)
+
+    arr = np.array(canvas, dtype=np.uint8)
+
+    patches = (
+        arr.reshape(rows, patch_size, cols, patch_size, 4)
+        .transpose(0, 2, 1, 3, 4)
+        .reshape(rows * cols, patch_size, patch_size, 4)
+    )
+
+    ss = max(1, supersample)
+
+    scaled_patch = patch_size * ss
+    scaled_border = border_thickness * ss
+    scaled_radius = corner_radius * ss
+    scaled_spacing = spacing * ss
+
+    tile_w = scaled_patch + 2 * scaled_border
+    tile_h = scaled_patch + 2 * scaled_border
+
+    mosaic_w = cols * tile_w + (cols + 1) * scaled_spacing
+    mosaic_h = rows * tile_h + (rows + 1) * scaled_spacing
+
+    mosaic = Image.new("RGBA", (mosaic_w, mosaic_h), (0, 0, 0, 0))
+
+    def create_tile(patch_img):
+        patch_img = patch_img.resize(
+            (scaled_patch, scaled_patch),
+            Image.NEAREST
+        )
+
+        tile = Image.new("RGBA", (tile_w, tile_h), (0, 0, 0, 0))
+        draw = ImageDraw.Draw(tile)
+
+        if rounded:
+            draw.rounded_rectangle(
+                [0, 0, tile_w - 1, tile_h - 1],
+                radius=scaled_radius,
+                fill=border_rgba,
+            )
+        else:
+            draw.rectangle(
+                [0, 0, tile_w - 1, tile_h - 1],
+                fill=border_rgba,
+            )
+
+        if rounded and true_clipping:
+            mask = Image.new("L", (scaled_patch, scaled_patch), 0)
+            mask_draw = ImageDraw.Draw(mask)
+            mask_draw.rounded_rectangle(
+                [0, 0, scaled_patch - 1, scaled_patch - 1],
+                radius=max(0, scaled_radius - scaled_border),
+                fill=255,
+            )
+            tile.paste(patch_img, (scaled_border, scaled_border), mask)
+        else:
+            tile.paste(patch_img, (scaled_border, scaled_border), patch_img)
+
+        return tile
+
+    for idx in range(patches.shape[0]):
+        r = idx // cols
+        c = idx % cols
+        patch_img = Image.fromarray(patches[idx])
+        tile = create_tile(patch_img)
+
+        x = scaled_spacing + c * (tile_w + scaled_spacing)
+        y = scaled_spacing + r * (tile_h + scaled_spacing)
+        mosaic.paste(tile, (x, y), tile)
+
+    if ss > 1 and output_scale_mode == "downscale":
+        mosaic = mosaic.resize(
+            (mosaic_w // ss, mosaic_h // ss),
+            Image.LANCZOS
+        )
+
+    return mosaic, patches