First version

.gitattributes

@@ -33,3 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+images/furniture.jpeg filter=lfs diff=lfs merge=lfs -text
+images/Mona_Lisa.jpeg filter=lfs diff=lfs merge=lfs -text
+images/road_sign_art.jpeg filter=lfs diff=lfs merge=lfs -text
+images/strawberries.jpeg filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,452 @@
+from PIL import Image, ImageDraw
+import numpy as np
+import gradio as gr
+import os
+import random
+from skimage.metrics import structural_similarity as ssim
+
+# ============================================================
+# Image Selection & Preprocessing helpers
+# ============================================================
+
+
+def load_image(path_or_img, size=(512, 512)):
+    """
+    Load an image from disk, convert it to RGB,
+    and resize it to a fixed resolution (default 512x512).
+    """
+    if isinstance(path_or_img, str):  # if input is a file path
+        img = Image.open(path_or_img).convert("RGB")
+    else:  # if input is already a PIL image
+        img = path_or_img.convert("RGB")
+    img = img.resize(size, Image.LANCZOS)
+    return img
+
+
+def quantize_pillow(img, k=16):
+    """
+    Apply color quantization using Pillow.
+    Reduces the number of unique colors in the image
+    (simplifies variations, makes mosaic more consistent).
+    """
+    return img.convert("P", palette=Image.ADAPTIVE, colors=k).convert("RGB")
+
+# ============================================================
+# Image Griding & Thresholding helpers
+# ============================================================
+
+
+def variance(arr):
+    """
+    Compute variance of pixel intensities in a cell.
+    - Convert RGB to grayscale by averaging channels
+    - Variance tells us how "detailed" this cell is
+      (high variance = detailed region, low variance = flat region).
+    """
+    gray = np.mean(arr, axis=2)
+    return np.var(gray)
+
+
+def get_average_color(arr):
+    """
+    Compute the average RGB color of all pixels in a cell.
+    Used to classify the cell into a representative color.
+    """
+    return tuple(np.mean(arr.reshape(-1, 3), axis=0).astype(np.uint8))
+
+
+def adaptive_tile_size(var, base_cell, min_size):
+    """
+    Adjust tile size dynamically based on local variance.
+    High variance → smaller tiles
+    Low variance → larger tiles
+    """
+    if var > 800:  # very detailed region
+        return max(min_size, base_cell // 2)
+    elif var > 400:  # medium detail
+        return max(min_size, int(base_cell * 0.75))
+    else:  # flat region
+        return base_cell
+
+
+def blend_tile_with_avg(tile, avg_color, alpha=0.6):
+    """
+    Blend the tile color with the cell's average color.
+    alpha = fraction of tile color; (1-alpha) = fraction of avg_color
+    """
+    tile_arr = np.array(tile).astype(np.float32)
+    avg_arr = np.full_like(tile_arr, avg_color, dtype=np.float32)
+    blended = (alpha * tile_arr + (1-alpha) * avg_arr).astype(np.uint8)
+    return Image.fromarray(blended)
+
+
+def process_cell_with_tiles(
+        result_img, arr, x, y, w, h, tiles, min_size, var_thresh):
+    """
+    Recursively process one cell of the grid:
+    1. Extract region from the image
+    2. Measure variance
+    3. If variance > threshold → subdivide into 4 smaller cells
+    4. Otherwise → classify by average color and replace with nearest tile
+    """
+    cell = arr[y:y+h, x:x+w]
+    v = variance(cell)
+
+    if v > var_thresh and w > min_size and h > min_size:
+        # Subdivide into 4 quadrants for higher detail representation
+        w2, h2 = w // 2, h // 2
+        process_cell_with_tiles(
+            result_img, arr, x, y, w2, h2, tiles, min_size, var_thresh)
+        process_cell_with_tiles(
+            result_img, arr, x+w2, y, w-w2, h2, tiles, min_size, var_thresh)
+        process_cell_with_tiles(
+            result_img, arr, x, y+h2, w2, h-h2, tiles, min_size, var_thresh)
+        process_cell_with_tiles(
+            result_img, arr, x+w2, y+h2, w-w2, h-h2, tiles, min_size,
+            var_thresh)
+    else:
+        # Flat or small region → replace with nearest colored tile
+        avg_color = get_average_color(cell)
+
+        # Find the tile whose color is closest to the average color
+        best_tile, _ = min(
+            tiles,
+            key=lambda t: np.linalg.norm(np.array(t[1]) - np.array(avg_color))
+        )
+
+        # Determine adaptive tile size based on variance
+        cell_tile_size = adaptive_tile_size(v, w, min_size)
+        tile_resized = best_tile.resize((cell_tile_size, cell_tile_size))
+
+        # Blend tile with average color
+        tile_resized = blend_tile_with_avg(tile_resized, avg_color, alpha=0.6)
+
+        # Paste into mosaic result
+        result_img.paste(tile_resized, (x, y))
+
+
+def get_tiles(tile_size=32, palette="default"):
+    """
+    Unified function to get tiles:
+    - If palette == "photo_tiles" → load real image tiles
+    - Otherwise → generate simple colored tiles
+    """
+    if palette == "photo_tiles":
+        return load_tile_images(folder="tiles", tile_size=tile_size)
+    else:
+        return generate_colored_tiles(
+            tile_size=tile_size, palette=palette)
+
+
+def load_tile_images(folder="tiles", tile_size=32):
+    """
+    Load all images in a folder and resize them into tiles.
+    Returns a list of (tile_image, avg_color).
+    """
+    tiles = []
+    for fname in os.listdir(folder):
+        if fname.lower().endswith(("flower.jpeg", "lady.jpg",
+                                   "landscape1.jpeg", "landscape2.jpeg",
+                                   "model.jpg")):
+            path = os.path.join(folder, fname)
+            img = Image.open(path).convert("RGB")
+            img = img.resize((tile_size, tile_size), Image.LANCZOS)
+
+            # compute average color for matching
+            arr = np.array(img)
+            avg_color = tuple(
+                np.mean(arr.reshape(-1, 3), axis=0).astype(np.uint8))
+            tiles.append((img, avg_color))
+    return tiles
+
+
+def mosaic_with_tiles(img, tiles, base_cell=32, min_size=8, var_thresh=500):
+    """
+    Generate a mosaic reconstruction of the image:
+    - Start with a grid of base_cell (default 32x32)
+    - For each cell, run recursive subdivision & replacement
+    """
+    arr = np.array(img)  # convert PIL → numpy
+    h, w, _ = arr.shape
+    result_img = Image.new("RGB", (w, h), (0, 0, 0))  # empty canvas
+
+    # Loop over grid cells
+    for y in range(0, h, base_cell):
+        for x in range(0, w, base_cell):
+            w_cell = min(base_cell, w - x)  # handle right edge
+            h_cell = min(base_cell, h - y)  # handle bottom edge
+            process_cell_with_tiles(
+                result_img, arr, x, y, w_cell, h_cell, tiles, min_size,
+                var_thresh)
+
+    return result_img
+
+
+def segmented_image(img, base_cell=32, min_size=8, var_thresh=500):
+    """
+    Create a segmented version of the image:
+    - Subdivide cells recursively based on variance
+    - Fill each cell with its average color (no tiles)
+    """
+    arr = np.array(img)
+    h, w, _ = arr.shape
+    result_img = Image.new("RGB", (w, h), (0, 0, 0))
+
+    def process_cell(result_img, arr, x, y, w, h):
+        v = variance(arr[y:y+h, x:x+w])
+        if v > var_thresh and w > min_size and h > min_size:
+            w2, h2 = w // 2, h // 2
+            process_cell(result_img, arr, x, y, w2, h2)
+            process_cell(result_img, arr, x+w2, y, w-w2, h2)
+            process_cell(result_img, arr, x, y+h2, w2, h-h2)
+            process_cell(result_img, arr, x+w2, y+h2, w-w2, h-h2)
+        else:
+            avg_color = get_average_color(arr[y:y+h, x:x+w])
+            block = Image.new("RGB", (w, h), avg_color)
+            result_img.paste(block, (x, y))
+
+    for yy in range(0, h, base_cell):
+        for xx in range(0, w, base_cell):
+            w_cell = min(base_cell, w - xx)
+            h_cell = min(base_cell, h - yy)
+            process_cell(result_img, arr, xx, yy, w_cell, h_cell)
+
+    return result_img
+
+
+# ============================================================
+# Tile Preparation
+# ============================================================
+
+
+def generate_colored_tiles(tile_size=32, palette="default"):
+    """
+    Generate a set of colored square tiles
+    Palettes can be switched (default, pastel, warm, random, etc.)
+    """
+    palettes = {
+        "default": [
+            (255, 0, 0), (0, 255, 0), (0, 0, 255),  # primary
+            (255, 255, 0), (255, 165, 0), (128, 0, 128),  # vivid
+            (0, 255, 255), (255, 192, 203), (128, 128, 128),  # misc
+            (255, 255, 255), (0, 0, 0)  # white + black
+        ],
+        "pastel": [
+            (255, 179, 186), (255, 223, 186),
+            (255, 255, 186), (186, 255, 201),
+            (186, 225, 255)
+        ],
+        "warm": [  # 🔥 new warm palette
+            (255, 140, 0), (255, 69, 0), (255, 99, 71),
+            (205, 92, 92), (139, 69, 19)
+        ],
+        "cool": [  # ❄️ cool tones
+            (0, 128, 255), (0, 255, 255),
+            (135, 206, 250), (70, 130, 180),
+            (25, 25, 112)
+        ],
+        "grayscale": [  # 🖤 shades of gray
+            (0, 0, 0), (64, 64, 64), (128, 128, 128),
+            (192, 192, 192), (255, 255, 255)
+        ],
+        "neon": [  # 🌈 bright neon effect
+            (57, 255, 20), (0, 255, 255), (255, 20, 147),
+            (255, 255, 0), (255, 0, 255)
+        ]
+    }
+
+    # 🎲 Random palette: pick N random RGB colors
+    if palette == "random":
+        colors = [
+            (random.randint(0, 255),
+             random.randint(0, 255),
+             random.randint(0, 255))
+            for _ in range(10)  # generate 10 random colors
+        ]
+    else:
+        colors = palettes.get(palette, palettes["default"])
+
+    tiles = []
+    for c in colors:
+        tile = Image.new("RGB", (tile_size, tile_size), c)
+        tiles.append((tile, c))  # store both tile image and its color value
+    return tiles
+
+
+def get_error_image(msg="⚠️ Error"):
+    """
+    Generate a simple placeholder image with an error message.
+    """
+    img = Image.new("RGB", (512, 512), color=(200, 50, 50))  # red background
+    draw = ImageDraw.Draw(img)
+    draw.text((20, 250), msg, fill=(255, 255, 255))
+    return img
+
+
+# ============================================================
+# Performance Metrics functions
+# ============================================================
+
+
+def mse(img1, img2):
+    """
+    Compute Mean Squared Error (MSE) between two images.
+    Lower = better similarity.
+    """
+    arr1 = np.array(img1).astype(np.float32)
+    arr2 = np.array(img2).astype(np.float32)
+    return np.mean((arr1 - arr2) ** 2)
+
+
+def compute_ssim(img1, img2):
+    """
+    Compute Structural Similarity Index (SSIM).
+    Range: -1 to 1
+    - 1.0 means images are identical
+    - Higher values = more perceptually similar
+    """
+    arr1 = np.array(img1)
+    arr2 = np.array(img2)
+    return ssim(arr1, arr2, channel_axis=2, data_range=255)
+
+
+# ============================================================
+# Gradio Interface
+# ============================================================
+
+
+def mosaic_pipeline(input_img, base_cell, min_size, var_thresh, palette):
+    """
+    Full pipeline for Gradio interface:
+    1. Resize and quantize input
+    2. Generate tiles
+    3. Reconstruct mosaic
+    4. Compute similarity metrics
+    """
+
+    if input_img is None:
+        error_img = get_error_image("Please upload an image first")
+        return error_img, error_img, "⚠️ Please upload an image first!"
+
+    # Step 1 preprocessing
+    img = load_image(input_img, size=(512, 512))
+    img_q = quantize_pillow(img, k=16)
+
+    # Step 2 segmentation
+    seg_img = segmented_image(img_q, base_cell, min_size, var_thresh)
+
+    # Step 3 tiles
+    tiles = get_tiles(tile_size=32, palette=palette)
+
+    # Step 4 mosaic construction
+    mosaic = mosaic_with_tiles(
+        img_q, tiles, base_cell=base_cell, min_size=min_size,
+        var_thresh=var_thresh)
+
+    # Step 5 metrics
+    mse_val = mse(img_q, mosaic)
+    ssim_val = compute_ssim(img_q, mosaic)
+
+    return seg_img, mosaic, f"MSE: {mse_val:.2f}, SSIM: {ssim_val:.3f}"
+
+
+# Define interface
+with gr.Blocks() as demo:
+    gr.Markdown("<h1 style='font-size:40px;'>🎨 IMAGE MOSAIC GENERATOR</h1>")
+
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("<h2>⭐ UPLOAD an image to start⭐</h2>")
+            input_img = gr.Image(type="pil", label="Upload an image")
+            gr.Examples(examples=[
+                ["images/ballycastle.jpeg"],
+                ["images/furniture.jpeg"],
+                ["images/Mona_Lisa.jpeg"],
+                ["images/road_sign_art.jpeg"],
+                ["images/strawberries.jpeg"]
+            ],
+                inputs=[input_img],
+                label="Choose an example image from below to start🎉",
+                examples_per_page=5   # number of images per row
+            )
+
+            # Organize controls in a 2x2 grid
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("<h2>CUSTOMIZE your MOSAIC style!⭐</h2>")
+                base_cell = gr.Slider(
+                    8, 64, value=32, step=8, label="Base Grid Size (px)"
+                )
+                gr.Markdown(
+                    """
+                    - 👉 Larger grid size = bigger mosaic tiles (less detail).
+                    - 👉 Smaller grid size = more detailed mosaic.
+                    """
+                )
+
+                var_thresh = gr.Slider(
+                    100, 1000, value=500, step=50, label="Variance Threshold"
+                )
+                gr.Markdown(
+                    """
+                    - 👉 Controls image detail variance before splitting tile
+                    - 👉 Higher = smoother look. Lower = more detail.
+                    """
+                )
+
+            with gr.Column():
+                min_size = gr.Slider(
+                    4, 32, value=8, step=4, label="Minimum Cell Size (px)"
+                )
+                gr.Markdown(
+                    """
+                    - 👉 Minimum size a tile can shrink to.
+                    - 👉 Smaller = allows more variability in tile shapes.
+                    """
+                )
+
+                palette = gr.Dropdown(
+                    ["default", "pastel", "warm", "cool",
+                     "grayscale", "neon", "random", "photo-tiles"],
+                    value="default",
+                    label="Tile Palette"
+                )
+                gr.Markdown(
+                    """
+                    - 👉 Choose the color palette for the tiles.
+                    """
+                )
+
+            run_btn = gr.Button("Generate my mosaic NOW!👀")
+
+        with gr.Column():
+            gr.Markdown("<h2>⭐CHECK amazing results HERE!⭐</h2>")
+            seg_img = gr.Image(type="pil", label="Segmented Image")
+            output_img = gr.Image(type="pil", label="Mosaic Output")
+
+            gr.Markdown("<h2>💭How WELL it worked?💭</h2>")
+            metrics = gr.Textbox(label="MSE & SSIM")
+            gr.Markdown(
+                """
+            - **MSE (Mean Squared Error):** Lower values = mosaic is closer
+              to the original image.
+            - **SSIM (Structural Similarity Index):** Higher values (closer
+              to 1) = better structural similarity to the original.
+                """
+            )
+
+    # Bind function to button click
+    run_btn.click(
+        fn=mosaic_pipeline,
+        inputs=[input_img, base_cell, min_size, var_thresh, palette],
+        outputs=[seg_img, output_img, metrics]
+    )
+
+
+# ============================================================
+# Main function
+# ============================================================
+
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,123 @@
+aiofiles==24.1.0
+altair==5.1.2
+annotated-types==0.7.0
+anyio==4.11.0
+attrs==23.1.0
+bcrypt==4.0.1
+blinker==1.7.0
+Brotli==1.1.0
+cachetools==5.3.2
+certifi==2023.7.22
+charset-normalizer==3.3.1
+click==8.1.7
+contourpy==1.3.3
+coverage==7.3.2
+cycler==0.12.1
+dog.py==0.2.0
+extra-streamlit-components==0.1.60
+fastapi==0.117.1
+ffmpy==0.6.1
+filelock==3.19.1
+fonttools==4.60.0
+frozendict==2.3.9
+fsspec==2025.9.0
+gitdb==4.0.11
+GitPython==3.1.40
+gradio==5.47.1
+gradio_client==1.13.2
+groovy==0.1.2
+h11==0.16.0
+hf-xet==1.1.10
+httpcore==1.0.9
+httpx==0.28.1
+huggingface-hub==0.35.1
+idna==3.4
+imageio==2.37.0
+importlib-metadata==6.8.0
+iniconfig==2.0.0
+Jinja2==3.1.2
+joblib==1.5.2
+jsonschema==4.19.2
+jsonschema-specifications==2023.11.1
+kiwisolver==1.4.9
+lazy_loader==0.4
+lxml==4.9.3
+markdown-it-py==3.0.0
+MarkupSafe==2.1.3
+matplotlib==3.10.6
+mdurl==0.1.2
+networkx==3.5
+node==1.2.2
+npm==0.1.1
+numpy==1.26.2
+odict==1.9.0
+optional-django==0.1.0
+orjson==3.11.3
+packaging==23.2
+pandas==2.1.3
+Pillow==10.1.0
+pluggy==1.3.0
+plumber==1.7
+protobuf==4.25.0
+pyarrow==14.0.1
+pydantic==2.11.9
+pydantic_core==2.33.2
+pydeck==0.8.1b0
+pydub==0.25.1
+Pygments==2.16.1
+PyJWT==2.8.0
+PyLD==2.0.3
+pyparsing==3.2.5
+pytest==7.4.3
+pytest-cov==4.1.0
+python-dateutil==2.8.2
+python-multipart==0.0.20
+python-pptx==0.6.23
+pytz==2023.3.post1
+PyYAML==6.0.1
+referencing==0.31.0
+report==0.0.1
+requests==2.31.0
+rich==13.7.0
+rpds-py==0.12.0
+ruff==0.13.2
+safehttpx==0.1.6
+scikit-image==0.25.2
+scikit-learn==1.7.2
+scipy==1.16.2
+semantic-version==2.10.0
+shellingham==1.5.4
+six==1.16.0
+smmap==5.0.1
+sniffio==1.3.1
+starlette==0.48.0
+streamlit==1.29.0
+streamlit-authenticator==0.2.3
+tenacity==8.2.3
+threadpoolctl==3.6.0
+tifffile==2025.9.20
+toml==0.10.2
+tomlkit==0.13.3
+toolz==0.12.0
+tornado==6.3.3
+tqdm==4.67.1
+typer==0.19.2
+typing-inspection==0.4.1
+typing_extensions==4.15.0
+tzdata==2023.3
+tzlocal==5.2
+urllib3==2.0.7
+uvicorn==0.37.0
+validators==0.22.0
+watchdog==3.0.0
+websockets==15.0.1
+XlsxWriter==3.1.9
+zipp==3.17.0
+zope.component==6.0
+zope.deferredimport==5.0
+zope.deprecation==5.0
+zope.event==5.0
+zope.hookable==7.0
+zope.interface==7.1.0
+zope.lifecycleevent==5.0
+zope.proxy==6.1